New Sort Order Lexicographic Options setting for Explorer

src/vs/base/common/comparers.ts

@@ -6,11 +6,11 @@
 import { sep } from 'vs/base/common/path';
 import { IdleValue } from 'vs/base/common/async';
 
-// When comparing large numbers of strings, such as in sorting large arrays, is better for
-// performance to create an Intl.Collator object and use the function provided by its compare
-// property than it is to use String.prototype.localeCompare()
+// When comparing large numbers of strings it's better for performance to create an
+// Intl.Collator object and use the function provided by its compare property
+// than it is to use String.prototype.localeCompare()
 
-// A collator with numeric sorting enabled, and no sensitivity to case or to accents
+// A collator with numeric sorting enabled, and no sensitivity to case, accents or diacritics.
 const intlFileNameCollatorBaseNumeric: IdleValue<{ collator: Intl.Collator, collatorIsNumeric: boolean }> = new IdleValue(() => {
  const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
  return {
@@ -28,36 +28,66 @@ const intlFileNameCollatorNumeric: IdleValue<{ collator: Intl.Collator }> = new
 });
 
 // A collator with numeric sorting enabled, and sensitivity to accents and diacritics but not case.
-const intlFileNameCollatorNumericCaseInsenstive: IdleValue<{ collator: Intl.Collator }> = new IdleValue(() => {
+const intlFileNameCollatorNumericCaseInsensitive: IdleValue<{ collator: Intl.Collator }> = new IdleValue(() => {
  const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'accent' });
  return {
  collator: collator
  };
-});/** Compares filenames without distinguishing the name from the extension. Disambiguates by unicode comparison. */
+});
+
+/** Compares filenames without distinguishing the name from the extension. Disambiguates by unicode comparison. */
 export function compareFileNames(one: string | null, other: string | null, caseSensitive = false): number {
  const a = one || '';
  const b = other || '';
  const result = intlFileNameCollatorBaseNumeric.value.collator.compare(a, b);
 
- // Using the numeric option in the collator will
- // make compare(`foo1`, `foo01`) === 0. We must disambiguate.
+ // Using the numeric option will make compare(`foo1`, `foo01`) === 0. Disambiguate.
  if (intlFileNameCollatorBaseNumeric.value.collatorIsNumeric && result === 0 && a !== b) {
  return a < b ? -1 : 1;
  }
 
  return result;
 }
 
-/** Compares filenames without distinguishing the name from the extension. Disambiguates by length, not unicode comparison. */
+/** Compares full filenames without grouping by case. */
 export function compareFileNamesDefault(one: string | null, other: string | null): number {
  const collatorNumeric = intlFileNameCollatorNumeric.value.collator;
  one = one || '';
  other = other || '';
 
- // Compare the entire filename - both name and extension - and disambiguate by length if needed
  return compareAndDisambiguateByLength(collatorNumeric, one, other);
 }
 
+/** Compares full filenames grouping uppercase names before lowercase. */
+export function compareFileNamesUpper(one: string | null, other: string | null) {
+ const collatorNumeric = intlFileNameCollatorNumeric.value.collator;
+ one = one || '';
+ other = other || '';
+
+ return compareCaseUpperFirst(one, other) || compareAndDisambiguateByLength(collatorNumeric, one, other);
+}
+
+/** Compares full filenames grouping lowercase names before uppercase. */
+export function compareFileNamesLower(one: string | null, other: string | null) {
+ const collatorNumeric = intlFileNameCollatorNumeric.value.collator;
+ one = one || '';
+ other = other || '';
+
+ return compareCaseLowerFirst(one, other) || compareAndDisambiguateByLength(collatorNumeric, one, other);
+}
+
+/** Compares full filenames by unicode value. */
+export function compareFileNamesUnicode(one: string | null, other: string | null) {
+ one = one || '';
+ other = other || '';
+
+ if (one === other) {
+ return 0;
+ }
+
+ return one < other ? -1 : 1;
+}
+
 export function noIntlCompareFileNames(one: string | null, other: string | null, caseSensitive = false): number {
  if (!caseSensitive) {
  one = one && one.toLowerCase();
@@ -78,15 +108,15 @@ export function noIntlCompareFileNames(one: string | null, other: string | null,
  return oneExtension < otherExtension ? -1 : 1;
 }
 
+/** Compares filenames by extension, then by name. Disambiguates by unicode comparison. */
 export function compareFileExtensions(one: string | null, other: string | null): number {
  const [oneName, oneExtension] = extractNameAndExtension(one);
  const [otherName, otherExtension] = extractNameAndExtension(other);
 
  let result = intlFileNameCollatorBaseNumeric.value.collator.compare(oneExtension, otherExtension);
 
  if (result === 0) {
- // Using the numeric option in the collator will
- // make compare(`foo1`, `foo01`) === 0. We must disambiguate.
+ // Using the numeric option will make compare(`foo1`, `foo01`) === 0. Disambiguate.
  if (intlFileNameCollatorBaseNumeric.value.collatorIsNumeric && oneExtension !== otherExtension) {
  return oneExtension < otherExtension ? -1 : 1;
  }
@@ -102,24 +132,65 @@ export function compareFileExtensions(one: string | null, other: string | null):
  return result;
 }
 
-/** Compares filenames by extenson, then by full filename */
+/** Compares filenames by extenson, then by full filename. Mixes uppercase and lowercase names together. */
 export function compareFileExtensionsDefault(one: string | null, other: string | null): number {
  one = one || '';
  other = other || '';
  const oneExtension = extractExtension(one);
  const otherExtension = extractExtension(other);
  const collatorNumeric = intlFileNameCollatorNumeric.value.collator;
- const collatorNumericCaseInsensitive = intlFileNameCollatorNumericCaseInsenstive.value.collator;
- let result;
+ const collatorNumericCaseInsensitive = intlFileNameCollatorNumericCaseInsensitive.value.collator;
 
- // Check for extension differences, ignoring differences in case and comparing numbers numerically.
- result = compareAndDisambiguateByLength(collatorNumericCaseInsensitive, oneExtension, otherExtension);
- if (result !== 0) {
- return result;
+ return compareAndDisambiguateByLength(collatorNumericCaseInsensitive, oneExtension, otherExtension) ||
+ compareAndDisambiguateByLength(collatorNumeric, one, other);
+}
+
+/** Compares filenames by extension, then case, then full filename. Groups uppercase names before lowercase. */
+export function compareFileExtensionsUpper(one: string | null, other: string | null): number {
+ one = one || '';
+ other = other || '';
+ const oneExtension = extractExtension(one);
+ const otherExtension = extractExtension(other);
+ const collatorNumeric = intlFileNameCollatorNumeric.value.collator;
+ const collatorNumericCaseInsensitive = intlFileNameCollatorNumericCaseInsensitive.value.collator;
+
+ return compareAndDisambiguateByLength(collatorNumericCaseInsensitive, oneExtension, otherExtension) ||
+ compareCaseUpperFirst(one, other) ||
+ compareAndDisambiguateByLength(collatorNumeric, one, other);
+}
+
+/** Compares filenames by extension, then case, then full filename. Groups lowercase names before uppercase. */
+export function compareFileExtensionsLower(one: string | null, other: string | null): number {
+ one = one || '';
+ other = other || '';
+ const oneExtension = extractExtension(one);
+ const otherExtension = extractExtension(other);
+ const collatorNumeric = intlFileNameCollatorNumeric.value.collator;
+ const collatorNumericCaseInsensitive = intlFileNameCollatorNumericCaseInsensitive.value.collator;
+
+ return compareAndDisambiguateByLength(collatorNumericCaseInsensitive, oneExtension, otherExtension) ||
+ compareCaseLowerFirst(one, other) ||
+ compareAndDisambiguateByLength(collatorNumeric, one, other);
+}
+
+/** Compares filenames by case-insensitive extension unicode value, then by full filename unicode value. */
+export function compareFileExtensionsUnicode(one: string | null, other: string | null) {
+ one = one || '';
+ other = other || '';
+ const oneExtension = extractExtension(one).toLowerCase();
+ const otherExtension = extractExtension(other).toLowerCase();
+
+ // Check for extension differences
+ if (oneExtension !== otherExtension) {
+ return oneExtension < otherExtension ? -1 : 1;
  }
 
- // Compare full filenames
- return compareAndDisambiguateByLength(collatorNumeric, one, other);
+ // Check for full filename differences.
+ if (one !== other) {
+ return one < other ? -1 : 1;
+ }
+
+ return 0;
 }
 
 const FileNameMatch = /^(.*?)(\.([^.]*))?$/;
@@ -130,7 +201,7 @@ function extractNameAndExtension(str?: string | null, dotfilesAsNames = false):
 
  let result: [string, string] = [(match && match[1]) || '', (match && match[3]) || ''];
 
- // if the dotfilesAsNames option is selected, treat an empty filename with an extension,
+ // if the dotfilesAsNames option is selected, treat an empty filename with an extension
  // or a filename that starts with a dot, as a dotfile name
  if (dotfilesAsNames && (!result[0] && result[1] || result[0] && result[0].charAt(0) === '.')) {
  result = [result[0] + '.' + result[1], ''];
@@ -162,6 +233,54 @@ function compareAndDisambiguateByLength(collator: Intl.Collator, one: string, ot
  return 0;
 }
 
+/** @returns `true` if the string is starts with a lowercase letter. Otherwise, `false`. */
+function startsWithLower(string: string) {
+ const character = string.charAt(0);
+
+ return (character.toLocaleUpperCase() !== character) ? true : false;
+}
+
+/** @returns `true` if the string starts with an uppercase letter. Otherwise, `false`. */
+function startsWithUpper(string: string) {
+ const character = string.charAt(0);
+
+ return (character.toLocaleLowerCase() !== character) ? true : false;
+}
+
+/**
+ * Compares the case of the provided strings - lowercase before uppercase
+ *
+ * @returns
+ * ```text
+ * -1 if one is lowercase and other is uppercase
+ * 1 if one is uppercase and other is lowercase
+ * 0 otherwise
+ * ```
+ */
+function compareCaseLowerFirst(one: string, other: string): number {
+ if (startsWithLower(one) && startsWithUpper(other)) {
+ return -1;
+ }
+ return (startsWithUpper(one) && startsWithLower(other)) ? 1 : 0;
+}
+
+/**
+ * Compares the case of the provided strings - uppercase before lowercase
+ *
+ * @returns
+ * ```text
+ * -1 if one is uppercase and other is lowercase
+ * 1 if one is lowercase and other is uppercase
+ * 0 otherwise
+ * ```
+ */
+function compareCaseUpperFirst(one: string, other: string): number {
+ if (startsWithUpper(one) && startsWithLower(other)) {
+ return -1;
+ }
+ return (startsWithLower(one) && startsWithUpper(other)) ? 1 : 0;
+}
+
 function comparePathComponents(one: string, other: string, caseSensitive = false): number {
  if (!caseSensitive) {
  one = one && one.toLowerCase();