Moved sort functions

src/index.ts

@@ -53,8 +53,6 @@ export * from './redactCredentialsInURL.js';
 export * from './resultify.js';
 export * from './secToString.js';
 export * from './set.js';
-export * from './sort-factory.js';
-export * from './sort.js';
 export * from './stripWhitespace.js';
 export * from './suffix.js';
 export * from './toPascalCase.js';

src/predicate/factory/index.ts

@@ -9,6 +9,7 @@ export * from './matching.js';
 export * from './maybeArray.js';
 export * from './nonNullable.js';
 export * from './nullable.js';
+export * from './nullish.js';
 export * from './optional.js';
 export * from './range.js';
 export * from './shape.js';

src/predicate/factory/nullish.ts

@@ -0,0 +1,7 @@
+import type { Nullish } from '../../types/common.js';
+import type { TypePredicateFn } from '../../types/functions.js';
+
+export const nullish =
+  <T>(predicate: TypePredicateFn<T>): TypePredicateFn<Nullish<T>> =>
+  (input: unknown): input is Nullish<T> =>
+    input == null || predicate(input);

src/sort/byLocaleCompare.ts

@@ -0,0 +1 @@
+export const byLocaleCompare = (left: string, right: string): number => left.localeCompare(right);

src/sort/bySimpleComparison.ts

@@ -0,0 +1,3 @@
+export const bySimpleComparison = <T>(left: T, right: T): number => {
+  return left === right ? 0 : left > right ? 1 : -1;
+};

src/sort/bySubtraction.ts

@@ -0,0 +1,4 @@
+import { parseNumber } from '../parseNumber.js';
+
+export const bySubtraction = <T extends number | bigint | string>(left: T, right: T): number =>
+  parseNumber(left) - parseNumber(right);

src/sort/byTimestamp.ts

@@ -0,0 +1,7 @@
+import { getMilliseconds } from '../getMilliseconds.js';
+
+export const byTimestamp = <T extends string | number | Date>(left: T, right: T): number => {
+  const timeDiff = getMilliseconds(left) - getMilliseconds(right);
+
+  return Number.isNaN(timeDiff) ? -1 : timeDiff;
+};

src/sort-factory.ts → src/sort/factory/byProperty.ts

@@ -1,11 +1,6 @@
-import type { CompareFn } from './types/functions.js';
+import type { CompareFn } from '../../types/functions.js';
 
 export const byProperty =
   <T extends object, K extends keyof T = keyof T>(compareFn: CompareFn<T[K]>, property: K): CompareFn<T> =>
   (left, right) =>
     compareFn(left[property], right[property]);
-
-export const byReverseOf =
-  <T>(compareFn: CompareFn<T>): CompareFn<T> =>
-  (left, right) =>
-    0 - compareFn(left, right);

src/sort/factory/byReverseOf.ts

@@ -0,0 +1,6 @@
+import type { CompareFn } from '../../types/functions.js';
+
+export const byReverseOf =
+  <T>(compareFn: CompareFn<T>): CompareFn<T> =>
+  (left, right) =>
+    0 - compareFn(left, right);

src/types/common.ts

@@ -43,3 +43,5 @@ export type AnyAsyncFunction = (...args: any[]) => Promise<any>;
 export type AnyNewable = {
   new (...args: any[]): any;
 };
+
+export type Nullish<T> = T | null | undefined;

test/predicate/factory/nullish.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { nullish } from '../../../src/predicate/factory/nullish.js';
+import { isBoolean } from '../../../src/predicate/isBoolean.js';
+
+describe('nullish()', () => {
+  it('Returns a type predicate function', () => {
+    expect(nullish(isBoolean)).toBeInstanceOf(Function);
+  });
+
+  it('Calls a type predicate function', () => {
+    const predicate = vi.fn(isBoolean) as unknown as typeof isBoolean;
+
+    const fn = nullish(predicate);
+
+    expect(fn(true)).toBeTruthy();
+    expect(fn(false)).toBeTruthy();
+    expect(fn(null)).toBeTruthy();
+    expect(fn(undefined)).toBeTruthy();
+    expect(predicate).toHaveBeenCalledTimes(2);
+  });
+});

test/sort/byLocaleCompare.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+
+import { byLocaleCompare } from '../../src/sort/byLocaleCompare.js';
+
+describe('byLocaleCompare()', () => {
+  it('compares by string localeCompare', () => {
+    expect(['c', 'b', 'a'].sort(byLocaleCompare)).toEqual(['a', 'b', 'c']);
+  });
+});

test/sort/bySimpleComparison.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+
+import { bySimpleComparison } from '../../src/sort/bySimpleComparison.js';
+
+describe('bySimpleComparison()', () => {
+  it('compares using operators', () => {
+    expect([1, 0, 3, 2].sort(bySimpleComparison)).toEqual([0, 1, 2, 3]);
+
+    expect([true, false, true].sort(bySimpleComparison)).toEqual([false, true, true]);
+
+    expect(['c', 'b', 1, 'a', 'x', 'z', 'y', 1].sort(bySimpleComparison)).toEqual(['a', 1, 1, 'b', 'c', 'x', 'y', 'z']);
+  });
+});

test/sort/bySubtraction.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+
+import { bySubtraction } from '../../src/sort/bySubtraction.js';
+
+describe('bySubtraction()', () => {
+  it('compares using subtraction', () => {
+    expect([1, 0, 3, 2].sort(bySubtraction)).toEqual([0, 1, 2, 3]);
+
+    expect(['1', 0n, 3, 2].sort(bySubtraction)).toEqual([0n, '1', 2, 3]);
+  });
+});

test/sort/byTimestamp.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { byTimestamp } from '../../src/sort/byTimestamp.js';
+
+describe('byTimestamp()', () => {
+  it('sorts by timestamp', () => {
+    const now = new Date();
+    const past = new Date();
+
+    past.setDate(past.getDate() - 10);
+
+    const data = [now, 0, past, now.toISOString(), past.toISOString(), 1];
+
+    expect(data.sort(byTimestamp)).toEqual([0, 1, past, past.toISOString(), now, now.toISOString()]);
+  });
+
+  it('Handles bad dates', () => {
+    const now = new Date();
+    const bad = Date.parse('not a date');
+
+    const data = [now, bad];
+
+    expect(data.sort(byTimestamp)).toEqual([bad, now]);
+  });
+});

test/sort-factory.test.ts → test/sort/factory/byProperty.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
-import { byProperty, byReverseOf } from '../src/sort-factory.js';
-import { byLocaleCompare } from '../src/sort.js';
+import { byLocaleCompare } from '../../../src/sort/byLocaleCompare.js';
+import { byProperty } from '../../../src/sort/factory/byProperty.js';
 
 describe('byProperty()', () => {
   it('returns a CompareFn', () => {
@@ -28,13 +28,3 @@ describe('byProperty()', () => {
     ]);
   });
 });
-
-describe('byReverseOf()', () => {
-  it('returns a CompareFn', () => {
-    expect(byReverseOf(byLocaleCompare)).instanceOf(Function);
-  });
-
-  it('Sorts using the returned CompareFn', () => {
-    expect(['a', 'b', 'c'].sort(byReverseOf(byLocaleCompare))).toEqual(['c', 'b', 'a']);
-  });
-});

test/sort/factory/byReverseOf.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+
+import { byLocaleCompare } from '../../../src/sort/byLocaleCompare.js';
+import { byReverseOf } from '../../../src/sort/factory/byReverseOf.js';
+
+describe('byReverseOf()', () => {
+  it('returns a CompareFn', () => {
+    expect(byReverseOf(byLocaleCompare)).instanceOf(Function);
+  });
+
+  it('Sorts using the returned CompareFn', () => {
+    expect(['a', 'b', 'c'].sort(byReverseOf(byLocaleCompare))).toEqual(['c', 'b', 'a']);
+  });
+});