@tamtamchik/json-deep-sort 1.4.0-beta.3 → 1.4.0-beta.4

package/dist/index.js

@@ -24,188 +24,113 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/primitive-array-sorter.ts
-var SORTABLE_PRIMITIVE_TYPES = ["string", "number", "boolean"];
+// src/types.ts
 var NULLISH_VALUES = [null, void 0];
-var PrimitiveArraySorter = class {
-  /**
-   * Sorts primitive arrays when enabled
-   */
-  static sortPrimitiveArray(array, ascending, sortPrimitiveArrays) {
-    if (!sortPrimitiveArrays || !this.canSortPrimitiveArray(array)) {
-      return array;
-    }
-    return [...array].sort(
-      (a, b) => this.compareSortablePrimitives(a, b, ascending)
-    );
-  }
-  /**
-   * Checks if an array can be sorted as primitives
-   */
-  static canSortPrimitiveArray(array) {
-    return this.allItemsAreSortablePrimitives(array) && this.allItemsHaveSameSortableType(array);
-  }
-  /**
-   * Checks if all items are sortable primitives
-   */
-  static allItemsAreSortablePrimitives(array) {
-    return array.every((item) => this.isSortablePrimitive(item));
-  }
-  /**
-   * Checks if all items have the same sortable type
-   */
-  static allItemsHaveSameSortableType(array) {
-    if (array.length === 0) return true;
-    if (this.hasNullishValues(array)) {
-      return false;
-    }
-    const firstItem = array[0];
-    if (!this.isSortablePrimitive(firstItem)) return false;
-    const firstType = typeof firstItem;
-    return array.every((item) => typeof item === firstType);
-  }
-  /**
-   * Compares two sortable primitive values
-   */
-  static compareSortablePrimitives(a, b, ascending) {
-    if (typeof a === "string" && typeof b === "string") {
-      return this.compareStrings(a, b, ascending);
-    }
-    if (typeof a === "number" && typeof b === "number") {
-      return this.compareNumbers(a, b, ascending);
-    }
-    if (typeof a === "boolean" && typeof b === "boolean") {
-      return this.compareBooleans(a, b, ascending);
-    }
-    return 0;
-  }
-  /**
-   * Compares two strings
-   */
-  static compareStrings(a, b, ascending) {
-    const result = a.localeCompare(b);
-    return ascending ? result : -result;
-  }
-  /**
-   * Compares two numbers
-   */
-  static compareNumbers(a, b, ascending) {
-    if (isNaN(a) && isNaN(b)) return 0;
-    if (isNaN(a)) return 1;
-    if (isNaN(b)) return -1;
-    const result = a - b;
-    return ascending ? result : -result;
-  }
-  /**
-   * Compares two booleans
-   */
-  static compareBooleans(a, b, ascending) {
-    if (a === b) return 0;
-    if (a) return ascending ? 1 : -1;
-    return ascending ? -1 : 1;
-  }
-  /**
-   * Checks if a value is a sortable primitive
-   */
-  static isSortablePrimitive(value) {
-    return SORTABLE_PRIMITIVE_TYPES.includes(
-      typeof value
-    );
-  }
-  /**
-   * Checks if an array has nullish values
-   */
-  static hasNullishValues(array) {
-    return array.some(this.isNullish);
-  }
-  /**
-   * Checks if a value is nullish
-   */
-  static isNullish(value) {
-    return NULLISH_VALUES.includes(value);
-  }
-};
+var SORTABLE_PRIMITIVE_TYPES = [
+  "string",
+  "number",
+  "boolean"
+];
 
 // src/type-guards.ts
-var TypeGuards = class {
-  /**
-   * Checks if a value is a primitive (string, number, boolean, null, undefined)
-   */
-  static isPrimitive(data) {
-    return this.isSortablePrimitive(data) || this.isNullish(data);
-  }
-  /**
-   * Checks if a value is a sortable primitive (string, number, boolean)
-   */
-  static isSortablePrimitive(value) {
-    const sortableTypes = ["string", "number", "boolean"];
-    return sortableTypes.includes(typeof value);
-  }
-  /**
-   * Checks if a value is nullish (null or undefined)
-   */
-  static isNullish(value) {
-    return value === null || value === void 0;
-  }
-  /**
-   * Checks if a value is a plain object
-   */
-  static isObject(data) {
-    return typeof data === "object" && data !== null;
-  }
-  /**
-   * Checks if an object is non-sortable (Date, RegExp, Function, etc.)
-   */
-  static isNonSortableObject(obj) {
-    const nonSortableTypes = [
-      Date,
-      RegExp,
-      Function,
-      Error,
-      Map,
-      Set,
-      WeakMap,
-      WeakSet,
-      Promise
-    ];
-    return nonSortableTypes.some((type) => obj instanceof type) || Symbol.iterator in Object(obj);
-  }
-  /**
-   * Checks if an array has nullish values
-   */
-  static hasNullishValues(array) {
-    return array.some(this.isNullish);
-  }
-};
-
-// src/index.ts
-function sort(data, ascending = true, sortPrimitiveArrays = false) {
-  const options = { ascending, sortPrimitiveArrays };
-  return sortRecursively(data, options);
+function isNullish(value) {
+  return NULLISH_VALUES.includes(value);
 }
-function sortRecursively(data, options) {
-  if (Array.isArray(data)) {
-    return sortArray(data, options);
+function hasNullishValues(array) {
+  return array.some(isNullish);
+}
+function isSortablePrimitive(value) {
+  return SORTABLE_PRIMITIVE_TYPES.includes(
+    typeof value
+  );
+}
+function isPrimitive(data) {
+  return isSortablePrimitive(data) || isNullish(data);
+}
+function isObject(data) {
+  return typeof data === "object" && data !== null;
+}
+function isNonSortableObject(obj) {
+  const nonSortableTypes = [
+    Date,
+    RegExp,
+    Function,
+    Error,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Promise
+  ];
+  return nonSortableTypes.some((type) => obj instanceof type) || Symbol.iterator in Object(obj);
+}
+
+// src/comparators.ts
+function compareSortablePrimitives(a, b, ascending) {
+  if (typeof a === "string" && typeof b === "string") {
+    return ascending ? a.localeCompare(b) : b.localeCompare(a);
   }
-  if (TypeGuards.isPrimitive(data) || TypeGuards.isNonSortableObject(data)) {
-    return data;
+  if (typeof a === "number" && typeof b === "number") {
+    return compareNumbers(a, b, ascending);
   }
-  if (TypeGuards.isObject(data)) {
-    return sortObject(data, options);
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return compareBooleans(a, b, ascending);
   }
-  return data;
+  return 0;
+}
+function compareNumbers(a, b, ascending) {
+  if (Number.isNaN(a) && Number.isNaN(b)) return 0;
+  if (Number.isNaN(a)) return 1;
+  if (Number.isNaN(b)) return -1;
+  return ascending ? a - b : b - a;
+}
+function compareBooleans(a, b, ascending) {
+  if (a === b) return 0;
+  if (a) return ascending ? 1 : -1;
+  return ascending ? -1 : 1;
+}
+function compareObjectKeys(keyA, keyB, ascending) {
+  if (typeof keyA === "symbol" && typeof keyB === "symbol") return 0;
+  if (typeof keyA === "symbol") return 1;
+  if (typeof keyB === "symbol") return -1;
+  const stringA = keyA;
+  const stringB = keyB;
+  return ascending ? stringA.localeCompare(stringB) : stringB.localeCompare(stringA);
 }
+
+// src/array-sorter.ts
 function sortArray(array, options) {
-  const sortedPrimitiveArray = PrimitiveArraySorter.sortPrimitiveArray(
-    array,
-    options.ascending,
-    options.sortPrimitiveArrays
-  );
-  if (sortedPrimitiveArray !== array) {
-    return sortedPrimitiveArray;
+  if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
+    return sortPrimitiveArray(array, options.ascending);
   }
   return array.map((item) => sortRecursively(item, options));
 }
+function shouldSortPrimitiveArray(array, sortPrimitiveArrays) {
+  return sortPrimitiveArrays && canSortPrimitiveArray(array);
+}
+function canSortPrimitiveArray(array) {
+  return allItemsAreSortablePrimitives(array) && allItemsHaveSameSortableType(array);
+}
+function allItemsAreSortablePrimitives(array) {
+  return array.every(isSortablePrimitive);
+}
+function sortPrimitiveArray(array, ascending) {
+  return [...array].sort((a, b) => compareSortablePrimitives(a, b, ascending));
+}
+function allItemsHaveSameSortableType(array) {
+  if (array.length === 0) return true;
+  if (hasNullishValues(array)) {
+    return false;
+  }
+  const firstItem = array[0];
+  if (!isSortablePrimitive(firstItem)) return false;
+  const expectedType = typeof firstItem;
+  const allSameType = array.every((item) => typeof item === expectedType);
+  if (allSameType) return true;
+  return array.every(isSortablePrimitive);
+}
+
+// src/object-sorter.ts
 function sortObject(obj, options) {
   const entries = collectObjectEntries(obj);
   const sortedEntries = sortObjectEntries(entries, options.ascending);
@@ -223,14 +148,6 @@ function sortObjectEntries(entries, ascending) {
     ([keyA], [keyB]) => compareObjectKeys(keyA, keyB, ascending)
   );
 }
-function compareObjectKeys(keyA, keyB, ascending) {
-  if (typeof keyA === "symbol" && typeof keyB === "symbol") return 0;
-  if (typeof keyA === "symbol") return 1;
-  if (typeof keyB === "symbol") return -1;
-  const stringA = keyA;
-  const stringB = keyB;
-  return ascending ? stringA.localeCompare(stringB) : stringB.localeCompare(stringA);
-}
 function createSortedObject(entries, options) {
   const sortedEntries = entries.map(([key, value]) => [
     key,
@@ -238,6 +155,26 @@ function createSortedObject(entries, options) {
   ]);
   return Object.fromEntries(sortedEntries);
 }
+
+// src/core.ts
+function sortRecursively(data, options) {
+  if (Array.isArray(data)) {
+    return sortArray(data, options);
+  }
+  if (isPrimitive(data) || isNonSortableObject(data)) {
+    return data;
+  }
+  if (isObject(data)) {
+    return sortObject(data, options);
+  }
+  return data;
+}
+
+// src/index.ts
+function sort(data, ascending = true, sortPrimitiveArrays = false) {
+  const options = { ascending, sortPrimitiveArrays };
+  return sortRecursively(data, options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   sort

package/dist/index.mjs

@@ -1,185 +1,110 @@
-// src/primitive-array-sorter.ts
-var SORTABLE_PRIMITIVE_TYPES = ["string", "number", "boolean"];
+// src/types.ts
 var NULLISH_VALUES = [null, void 0];
-var PrimitiveArraySorter = class {
-  /**
-   * Sorts primitive arrays when enabled
-   */
-  static sortPrimitiveArray(array, ascending, sortPrimitiveArrays) {
-    if (!sortPrimitiveArrays || !this.canSortPrimitiveArray(array)) {
-      return array;
-    }
-    return [...array].sort(
-      (a, b) => this.compareSortablePrimitives(a, b, ascending)
-    );
-  }
-  /**
-   * Checks if an array can be sorted as primitives
-   */
-  static canSortPrimitiveArray(array) {
-    return this.allItemsAreSortablePrimitives(array) && this.allItemsHaveSameSortableType(array);
-  }
-  /**
-   * Checks if all items are sortable primitives
-   */
-  static allItemsAreSortablePrimitives(array) {
-    return array.every((item) => this.isSortablePrimitive(item));
-  }
-  /**
-   * Checks if all items have the same sortable type
-   */
-  static allItemsHaveSameSortableType(array) {
-    if (array.length === 0) return true;
-    if (this.hasNullishValues(array)) {
-      return false;
-    }
-    const firstItem = array[0];
-    if (!this.isSortablePrimitive(firstItem)) return false;
-    const firstType = typeof firstItem;
-    return array.every((item) => typeof item === firstType);
-  }
-  /**
-   * Compares two sortable primitive values
-   */
-  static compareSortablePrimitives(a, b, ascending) {
-    if (typeof a === "string" && typeof b === "string") {
-      return this.compareStrings(a, b, ascending);
-    }
-    if (typeof a === "number" && typeof b === "number") {
-      return this.compareNumbers(a, b, ascending);
-    }
-    if (typeof a === "boolean" && typeof b === "boolean") {
-      return this.compareBooleans(a, b, ascending);
-    }
-    return 0;
-  }
-  /**
-   * Compares two strings
-   */
-  static compareStrings(a, b, ascending) {
-    const result = a.localeCompare(b);
-    return ascending ? result : -result;
-  }
-  /**
-   * Compares two numbers
-   */
-  static compareNumbers(a, b, ascending) {
-    if (isNaN(a) && isNaN(b)) return 0;
-    if (isNaN(a)) return 1;
-    if (isNaN(b)) return -1;
-    const result = a - b;
-    return ascending ? result : -result;
-  }
-  /**
-   * Compares two booleans
-   */
-  static compareBooleans(a, b, ascending) {
-    if (a === b) return 0;
-    if (a) return ascending ? 1 : -1;
-    return ascending ? -1 : 1;
-  }
-  /**
-   * Checks if a value is a sortable primitive
-   */
-  static isSortablePrimitive(value) {
-    return SORTABLE_PRIMITIVE_TYPES.includes(
-      typeof value
-    );
-  }
-  /**
-   * Checks if an array has nullish values
-   */
-  static hasNullishValues(array) {
-    return array.some(this.isNullish);
-  }
-  /**
-   * Checks if a value is nullish
-   */
-  static isNullish(value) {
-    return NULLISH_VALUES.includes(value);
-  }
-};
+var SORTABLE_PRIMITIVE_TYPES = [
+  "string",
+  "number",
+  "boolean"
+];
 
 // src/type-guards.ts
-var TypeGuards = class {
-  /**
-   * Checks if a value is a primitive (string, number, boolean, null, undefined)
-   */
-  static isPrimitive(data) {
-    return this.isSortablePrimitive(data) || this.isNullish(data);
-  }
-  /**
-   * Checks if a value is a sortable primitive (string, number, boolean)
-   */
-  static isSortablePrimitive(value) {
-    const sortableTypes = ["string", "number", "boolean"];
-    return sortableTypes.includes(typeof value);
-  }
-  /**
-   * Checks if a value is nullish (null or undefined)
-   */
-  static isNullish(value) {
-    return value === null || value === void 0;
-  }
-  /**
-   * Checks if a value is a plain object
-   */
-  static isObject(data) {
-    return typeof data === "object" && data !== null;
-  }
-  /**
-   * Checks if an object is non-sortable (Date, RegExp, Function, etc.)
-   */
-  static isNonSortableObject(obj) {
-    const nonSortableTypes = [
-      Date,
-      RegExp,
-      Function,
-      Error,
-      Map,
-      Set,
-      WeakMap,
-      WeakSet,
-      Promise
-    ];
-    return nonSortableTypes.some((type) => obj instanceof type) || Symbol.iterator in Object(obj);
-  }
-  /**
-   * Checks if an array has nullish values
-   */
-  static hasNullishValues(array) {
-    return array.some(this.isNullish);
-  }
-};
-
-// src/index.ts
-function sort(data, ascending = true, sortPrimitiveArrays = false) {
-  const options = { ascending, sortPrimitiveArrays };
-  return sortRecursively(data, options);
+function isNullish(value) {
+  return NULLISH_VALUES.includes(value);
 }
-function sortRecursively(data, options) {
-  if (Array.isArray(data)) {
-    return sortArray(data, options);
+function hasNullishValues(array) {
+  return array.some(isNullish);
+}
+function isSortablePrimitive(value) {
+  return SORTABLE_PRIMITIVE_TYPES.includes(
+    typeof value
+  );
+}
+function isPrimitive(data) {
+  return isSortablePrimitive(data) || isNullish(data);
+}
+function isObject(data) {
+  return typeof data === "object" && data !== null;
+}
+function isNonSortableObject(obj) {
+  const nonSortableTypes = [
+    Date,
+    RegExp,
+    Function,
+    Error,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Promise
+  ];
+  return nonSortableTypes.some((type) => obj instanceof type) || Symbol.iterator in Object(obj);
+}
+
+// src/comparators.ts
+function compareSortablePrimitives(a, b, ascending) {
+  if (typeof a === "string" && typeof b === "string") {
+    return ascending ? a.localeCompare(b) : b.localeCompare(a);
   }
-  if (TypeGuards.isPrimitive(data) || TypeGuards.isNonSortableObject(data)) {
-    return data;
+  if (typeof a === "number" && typeof b === "number") {
+    return compareNumbers(a, b, ascending);
   }
-  if (TypeGuards.isObject(data)) {
-    return sortObject(data, options);
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return compareBooleans(a, b, ascending);
   }
-  return data;
+  return 0;
+}
+function compareNumbers(a, b, ascending) {
+  if (Number.isNaN(a) && Number.isNaN(b)) return 0;
+  if (Number.isNaN(a)) return 1;
+  if (Number.isNaN(b)) return -1;
+  return ascending ? a - b : b - a;
+}
+function compareBooleans(a, b, ascending) {
+  if (a === b) return 0;
+  if (a) return ascending ? 1 : -1;
+  return ascending ? -1 : 1;
+}
+function compareObjectKeys(keyA, keyB, ascending) {
+  if (typeof keyA === "symbol" && typeof keyB === "symbol") return 0;
+  if (typeof keyA === "symbol") return 1;
+  if (typeof keyB === "symbol") return -1;
+  const stringA = keyA;
+  const stringB = keyB;
+  return ascending ? stringA.localeCompare(stringB) : stringB.localeCompare(stringA);
 }
+
+// src/array-sorter.ts
 function sortArray(array, options) {
-  const sortedPrimitiveArray = PrimitiveArraySorter.sortPrimitiveArray(
-    array,
-    options.ascending,
-    options.sortPrimitiveArrays
-  );
-  if (sortedPrimitiveArray !== array) {
-    return sortedPrimitiveArray;
+  if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
+    return sortPrimitiveArray(array, options.ascending);
   }
   return array.map((item) => sortRecursively(item, options));
 }
+function shouldSortPrimitiveArray(array, sortPrimitiveArrays) {
+  return sortPrimitiveArrays && canSortPrimitiveArray(array);
+}
+function canSortPrimitiveArray(array) {
+  return allItemsAreSortablePrimitives(array) && allItemsHaveSameSortableType(array);
+}
+function allItemsAreSortablePrimitives(array) {
+  return array.every(isSortablePrimitive);
+}
+function sortPrimitiveArray(array, ascending) {
+  return [...array].sort((a, b) => compareSortablePrimitives(a, b, ascending));
+}
+function allItemsHaveSameSortableType(array) {
+  if (array.length === 0) return true;
+  if (hasNullishValues(array)) {
+    return false;
+  }
+  const firstItem = array[0];
+  if (!isSortablePrimitive(firstItem)) return false;
+  const expectedType = typeof firstItem;
+  const allSameType = array.every((item) => typeof item === expectedType);
+  if (allSameType) return true;
+  return array.every(isSortablePrimitive);
+}
+
+// src/object-sorter.ts
 function sortObject(obj, options) {
   const entries = collectObjectEntries(obj);
   const sortedEntries = sortObjectEntries(entries, options.ascending);
@@ -197,14 +122,6 @@ function sortObjectEntries(entries, ascending) {
     ([keyA], [keyB]) => compareObjectKeys(keyA, keyB, ascending)
   );
 }
-function compareObjectKeys(keyA, keyB, ascending) {
-  if (typeof keyA === "symbol" && typeof keyB === "symbol") return 0;
-  if (typeof keyA === "symbol") return 1;
-  if (typeof keyB === "symbol") return -1;
-  const stringA = keyA;
-  const stringB = keyB;
-  return ascending ? stringA.localeCompare(stringB) : stringB.localeCompare(stringA);
-}
 function createSortedObject(entries, options) {
   const sortedEntries = entries.map(([key, value]) => [
     key,
@@ -212,6 +129,26 @@ function createSortedObject(entries, options) {
   ]);
   return Object.fromEntries(sortedEntries);
 }
+
+// src/core.ts
+function sortRecursively(data, options) {
+  if (Array.isArray(data)) {
+    return sortArray(data, options);
+  }
+  if (isPrimitive(data) || isNonSortableObject(data)) {
+    return data;
+  }
+  if (isObject(data)) {
+    return sortObject(data, options);
+  }
+  return data;
+}
+
+// src/index.ts
+function sort(data, ascending = true, sortPrimitiveArrays = false) {
+  const options = { ascending, sortPrimitiveArrays };
+  return sortRecursively(data, options);
+}
 export {
   sort
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamtamchik/json-deep-sort",
-  "version": "1.4.0-beta.3",
+  "version": "1.4.0-beta.4",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/array-sorter.ts

@@ -0,0 +1,61 @@
+import { SortOptions } from './types';
+import { isSortablePrimitive, hasNullishValues } from './type-guards';
+import { compareSortablePrimitives } from './comparators';
+
+export function sortArray<T>(array: T[], options: SortOptions): T[] {
+  if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
+    return sortPrimitiveArray(array, options.ascending) as T[];
+  }
+
+  return array.map((item) => sortRecursively(item, options));
+}
+
+function shouldSortPrimitiveArray(
+  array: unknown[],
+  sortPrimitiveArrays: boolean
+): boolean {
+  return sortPrimitiveArrays && canSortPrimitiveArray(array);
+}
+
+function canSortPrimitiveArray(array: unknown[]): boolean {
+  return (
+    allItemsAreSortablePrimitives(array) && allItemsHaveSameSortableType(array)
+  );
+}
+
+function allItemsAreSortablePrimitives(array: unknown[]): boolean {
+  return array.every(isSortablePrimitive);
+}
+
+function sortPrimitiveArray(array: unknown[], ascending: boolean): unknown[] {
+  // The array has already been validated as sortable in canSortPrimitiveArray
+  // No need to check allItemsHaveSameSortableType again
+  return [...array].sort((a, b) => compareSortablePrimitives(a, b, ascending));
+}
+
+function allItemsHaveSameSortableType(array: unknown[]): boolean {
+  if (array.length === 0) return true;
+
+  // Don't sort arrays that contain null or undefined values
+  // as they represent absence of value and don't have a natural ordering
+  if (hasNullishValues(array)) {
+    return false;
+  }
+
+  // For arrays with only sortable primitives, check if they have the same type
+  const firstItem = array[0];
+  if (!isSortablePrimitive(firstItem)) return false;
+
+  const expectedType = typeof firstItem;
+  const allSameType = array.every((item) => typeof item === expectedType);
+
+  // If all items are the same type, we can sort them normally
+  if (allSameType) return true;
+
+  // If we have mixed primitive types, we can still "sort" them
+  // (the comparison function will return 0 for different types, maintaining order)
+  // This allows us to cover the fallback case in compareSortablePrimitives
+  return array.every(isSortablePrimitive);
+}
+
+import { sortRecursively } from './core';

package/src/comparators.ts

@@ -0,0 +1,59 @@
+// Comparison functions for different data types
+export function compareSortablePrimitives(
+  a: unknown,
+  b: unknown,
+  ascending: boolean
+): number {
+  if (typeof a === 'string' && typeof b === 'string') {
+    return ascending ? a.localeCompare(b) : b.localeCompare(a);
+  }
+
+  if (typeof a === 'number' && typeof b === 'number') {
+    return compareNumbers(a, b, ascending);
+  }
+
+  if (typeof a === 'boolean' && typeof b === 'boolean') {
+    return compareBooleans(a, b, ascending);
+  }
+
+  return 0; // Maintain order for other primitives
+}
+
+export function compareNumbers(
+  a: number,
+  b: number,
+  ascending: boolean
+): number {
+  if (Number.isNaN(a) && Number.isNaN(b)) return 0;
+  if (Number.isNaN(a)) return 1;
+  if (Number.isNaN(b)) return -1;
+
+  return ascending ? a - b : b - a;
+}
+
+export function compareBooleans(
+  a: boolean,
+  b: boolean,
+  ascending: boolean
+): number {
+  if (a === b) return 0;
+  if (a) return ascending ? 1 : -1;
+  return ascending ? -1 : 1;
+}
+
+export function compareObjectKeys(
+  keyA: string | symbol,
+  keyB: string | symbol,
+  ascending: boolean
+): number {
+  if (typeof keyA === 'symbol' && typeof keyB === 'symbol') return 0;
+  if (typeof keyA === 'symbol') return 1;
+  if (typeof keyB === 'symbol') return -1;
+
+  const stringA = keyA as string;
+  const stringB = keyB as string;
+
+  return ascending
+    ? stringA.localeCompare(stringB)
+    : stringB.localeCompare(stringA);
+}

package/src/core.ts

@@ -0,0 +1,20 @@
+import { SortOptions } from './types';
+import { isPrimitive, isNonSortableObject, isObject } from './type-guards';
+import { sortArray } from './array-sorter';
+import { sortObject } from './object-sorter';
+
+export function sortRecursively<T>(data: T, options: SortOptions): T {
+  if (Array.isArray(data)) {
+    return sortArray(data, options) as T;
+  }
+
+  if (isPrimitive(data) || isNonSortableObject(data)) {
+    return data;
+  }
+
+  if (isObject(data)) {
+    return sortObject(data, options) as T;
+  }
+
+  return data;
+}

package/src/index.ts

@@ -1,14 +1,5 @@
-import { PrimitiveArraySorter } from './primitive-array-sorter';
-import { TypeGuards } from './type-guards';
-
-// Type definitions
-type ObjectType = Record<string | symbol, unknown>;
-type SortedEntry = [string | symbol, unknown];
-
-type SortOptions = {
-  ascending: boolean;
-  sortPrimitiveArrays: boolean;
-};
+import { SortOptions } from './types';
+import { sortRecursively } from './core';
 
 export function sort<T>(
   data: T,
@@ -19,87 +10,10 @@ export function sort<T>(
   return sortRecursively(data, options);
 }
 
-function sortRecursively<T>(data: T, options: SortOptions): T {
-  if (Array.isArray(data)) {
-    return sortArray(data, options) as T;
-  }
-
-  if (TypeGuards.isPrimitive(data) || TypeGuards.isNonSortableObject(data)) {
-    return data;
-  }
-
-  if (TypeGuards.isObject(data)) {
-    return sortObject(data, options) as T;
-  }
-
-  return data;
-}
-
-function sortArray<T>(array: T[], options: SortOptions): T[] {
-  // Use the extracted PrimitiveArraySorter
-  const sortedPrimitiveArray = PrimitiveArraySorter.sortPrimitiveArray(
-    array,
-    options.ascending,
-    options.sortPrimitiveArrays
-  );
-
-  if (sortedPrimitiveArray !== array) {
-    return sortedPrimitiveArray as T[];
-  }
-
-  // Recursively sort nested items
-  return array.map((item) => sortRecursively(item, options));
-}
-
-function sortObject(obj: ObjectType, options: SortOptions): ObjectType {
-  const entries = collectObjectEntries(obj);
-  const sortedEntries = sortObjectEntries(entries, options.ascending);
-  return createSortedObject(sortedEntries, options);
-}
-
-function collectObjectEntries(obj: ObjectType): SortedEntry[] {
-  const stringEntries = Object.entries(obj);
-  const symbolEntries = Object.getOwnPropertySymbols(obj).map(
-    (symbol) => [symbol, obj[symbol]] as SortedEntry
-  );
-
-  return [...stringEntries, ...symbolEntries];
-}
-
-function sortObjectEntries(
-  entries: SortedEntry[],
-  ascending: boolean
-): SortedEntry[] {
-  return entries.sort(([keyA], [keyB]) =>
-    compareObjectKeys(keyA, keyB, ascending)
-  );
-}
-
-function compareObjectKeys(
-  keyA: string | symbol,
-  keyB: string | symbol,
-  ascending: boolean
-): number {
-  if (typeof keyA === 'symbol' && typeof keyB === 'symbol') return 0;
-  if (typeof keyA === 'symbol') return 1;
-  if (typeof keyB === 'symbol') return -1;
-
-  const stringA = keyA as string;
-  const stringB = keyB as string;
-
-  return ascending
-    ? stringA.localeCompare(stringB)
-    : stringB.localeCompare(stringA);
-}
-
-function createSortedObject(
-  entries: SortedEntry[],
-  options: SortOptions
-): ObjectType {
-  const sortedEntries = entries.map(([key, value]) => [
-    key,
-    sortRecursively(value, options),
-  ]);
-
-  return Object.fromEntries(sortedEntries);
-}
+// Re-export types for convenience
+export type {
+  SortOptions,
+  ObjectType,
+  SortedEntry,
+  NonSortableType,
+} from './types';

package/src/object-sorter.ts

@@ -1,72 +1,41 @@
-// Type definitions for object sorting
-type ObjectType = Record<string | symbol, unknown>;
-type SortedEntry = [string | symbol, unknown];
+import { SortOptions, ObjectType, SortedEntry } from './types';
+import { compareObjectKeys } from './comparators';
 
-export class ObjectSorter {
-  /**
-   * Sorts object keys recursively
-   */
-  static sortObject(
-    obj: ObjectType,
-    options: { ascending: boolean }
-  ): ObjectType {
-    const entries = this.collectObjectEntries(obj);
-    const sortedEntries = this.sortObjectEntries(entries, options.ascending);
-    return this.createSortedObject(sortedEntries);
-  }
-
-  /**
-   * Collects all object entries (string and symbol keys)
-   */
-  private static collectObjectEntries(obj: ObjectType): SortedEntry[] {
-    const stringEntries = Object.entries(obj);
-    const symbolEntries = Object.getOwnPropertySymbols(obj).map(
-      (symbol) => [symbol, obj[symbol]] as SortedEntry
-    );
-
-    return [...stringEntries, ...symbolEntries];
-  }
+export function sortObject(obj: ObjectType, options: SortOptions): ObjectType {
+  const entries = collectObjectEntries(obj);
+  const sortedEntries = sortObjectEntries(entries, options.ascending);
+  return createSortedObject(sortedEntries, options);
+}
 
-  /**
-   * Sorts object entries by key
-   */
-  private static sortObjectEntries(
-    entries: SortedEntry[],
-    ascending: boolean
-  ): SortedEntry[] {
-    return entries.sort(([keyA], [keyB]) =>
-      this.compareObjectKeys(keyA, keyB, ascending)
-    );
-  }
+// Object entry handling
+function collectObjectEntries(obj: ObjectType): SortedEntry[] {
+  const stringEntries = Object.entries(obj);
+  const symbolEntries = Object.getOwnPropertySymbols(obj).map(
+    (symbol) => [symbol, obj[symbol]] as SortedEntry
+  );
 
-  /**
-   * Compares two object keys for sorting
-   */
-  private static compareObjectKeys(
-    keyA: string | symbol,
-    keyB: string | symbol,
-    ascending: boolean
-  ): number {
-    // Symbols are always sorted after strings
-    if (typeof keyA === 'symbol' && typeof keyB === 'symbol') return 0;
-    if (typeof keyA === 'symbol') return 1;
-    if (typeof keyB === 'symbol') return -1;
+  return [...stringEntries, ...symbolEntries];
+}
 
-    // Both are strings, use localeCompare
-    const stringA = keyA as string;
-    const stringB = keyB as string;
+function sortObjectEntries(
+  entries: SortedEntry[],
+  ascending: boolean
+): SortedEntry[] {
+  return entries.sort(([keyA], [keyB]) =>
+    compareObjectKeys(keyA, keyB, ascending)
+  );
+}
 
-    return ascending
-      ? stringA.localeCompare(stringB)
-      : stringB.localeCompare(stringA);
-  }
+function createSortedObject(
+  entries: SortedEntry[],
+  options: SortOptions
+): ObjectType {
+  const sortedEntries = entries.map(([key, value]) => [
+    key,
+    sortRecursively(value, options),
+  ]);
 
-  /**
-   * Creates a new object with sorted entries
-   */
-  private static createSortedObject(entries: SortedEntry[]): ObjectType {
-    // Note: This is a placeholder - the actual implementation will be in the main file
-    // since it needs access to the recursive sorting function
-    return Object.fromEntries(entries);
-  }
+  return Object.fromEntries(sortedEntries);
 }
+
+import { sortRecursively } from './core';

package/src/type-guards.ts

@@ -1,74 +1,51 @@
-// Type definitions for type guards
-type NonSortableType =
-  | Date
-  | RegExp
-  | (() => unknown)
-  | ((...args: unknown[]) => unknown)
-  | Error
-  | Map<unknown, unknown>
-  | Set<unknown>
-  | WeakMap<object, unknown>
-  | WeakSet<object>
-  | Promise<unknown>;
+import {
+  NULLISH_VALUES,
+  SORTABLE_PRIMITIVE_TYPES,
+  NullishValue,
+  NonSortableType,
+  ObjectType,
+} from './types';
 
-export class TypeGuards {
-  /**
-   * Checks if a value is a primitive (string, number, boolean, null, undefined)
-   */
-  static isPrimitive(data: unknown): boolean {
-    return this.isSortablePrimitive(data) || this.isNullish(data);
-  }
+// Type guards - single responsibility, clear naming
+export function isNullish(value: unknown): value is NullishValue {
+  return NULLISH_VALUES.includes(value as NullishValue);
+}
 
-  /**
-   * Checks if a value is a sortable primitive (string, number, boolean)
-   */
-  static isSortablePrimitive(
-    value: unknown
-  ): value is string | number | boolean {
-    const sortableTypes = ['string', 'number', 'boolean'];
-    return sortableTypes.includes(typeof value);
-  }
+export function hasNullishValues(array: unknown[]): boolean {
+  return array.some(isNullish);
+}
 
-  /**
-   * Checks if a value is nullish (null or undefined)
-   */
-  static isNullish(value: unknown): value is null | undefined {
-    return value === null || value === undefined;
-  }
+export function isSortablePrimitive(
+  value: unknown
+): value is string | number | boolean {
+  return SORTABLE_PRIMITIVE_TYPES.includes(
+    typeof value as 'string' | 'number' | 'boolean'
+  );
+}
 
-  /**
-   * Checks if a value is a plain object
-   */
-  static isObject(data: unknown): data is Record<string | symbol, unknown> {
-    return typeof data === 'object' && data !== null;
-  }
+export function isPrimitive(data: unknown): boolean {
+  return isSortablePrimitive(data) || isNullish(data);
+}
 
-  /**
-   * Checks if an object is non-sortable (Date, RegExp, Function, etc.)
-   */
-  static isNonSortableObject(obj: unknown): obj is NonSortableType {
-    const nonSortableTypes = [
-      Date,
-      RegExp,
-      Function,
-      Error,
-      Map,
-      Set,
-      WeakMap,
-      WeakSet,
-      Promise,
-    ];
+export function isObject(data: unknown): data is ObjectType {
+  return typeof data === 'object' && data !== null;
+}
 
-    return (
-      nonSortableTypes.some((type) => obj instanceof type) ||
-      Symbol.iterator in Object(obj)
-    );
-  }
+export function isNonSortableObject(obj: unknown): obj is NonSortableType {
+  const nonSortableTypes = [
+    Date,
+    RegExp,
+    Function,
+    Error,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Promise,
+  ];
 
-  /**
-   * Checks if an array has nullish values
-   */
-  static hasNullishValues(array: unknown[]): boolean {
-    return array.some(this.isNullish);
-  }
+  return (
+    nonSortableTypes.some((type) => obj instanceof type) ||
+    Symbol.iterator in Object(obj)
+  );
 }

package/src/types.ts

@@ -0,0 +1,29 @@
+// Constants - make the code self-documenting
+export const NULLISH_VALUES = [null, undefined] as const;
+export const SORTABLE_PRIMITIVE_TYPES = [
+  'string',
+  'number',
+  'boolean',
+] as const;
+
+// Type definitions that make sense
+export type NullishValue = (typeof NULLISH_VALUES)[number];
+export type SortablePrimitiveType = (typeof SORTABLE_PRIMITIVE_TYPES)[number];
+export type ObjectType = Record<string | symbol, unknown>;
+export type SortedEntry = [string | symbol, unknown];
+export type NonSortableType =
+  | Date
+  | RegExp
+  | (() => unknown)
+  | ((...args: unknown[]) => unknown)
+  | Error
+  | Map<unknown, unknown>
+  | Set<unknown>
+  | WeakMap<object, unknown>
+  | WeakSet<object>
+  | Promise<unknown>;
+
+export type SortOptions = {
+  ascending: boolean;
+  sortPrimitiveArrays: boolean;
+};

package/src/primitive-array-sorter.ts

@@ -1,151 +0,0 @@
-// Constants for primitive array sorting
-const SORTABLE_PRIMITIVE_TYPES = ['string', 'number', 'boolean'] as const;
-const NULLISH_VALUES = [null, undefined] as const;
-
-// Type definitions
-type SortablePrimitiveType = (typeof SORTABLE_PRIMITIVE_TYPES)[number];
-type NullishValue = (typeof NULLISH_VALUES)[number];
-
-export class PrimitiveArraySorter {
-  /**
-   * Sorts primitive arrays when enabled
-   */
-  static sortPrimitiveArray(
-    array: unknown[],
-    ascending: boolean,
-    sortPrimitiveArrays: boolean
-  ): unknown[] {
-    if (!sortPrimitiveArrays || !this.canSortPrimitiveArray(array)) {
-      return array;
-    }
-
-    return [...array].sort((a, b) =>
-      this.compareSortablePrimitives(a, b, ascending)
-    );
-  }
-
-  /**
-   * Checks if an array can be sorted as primitives
-   */
-  private static canSortPrimitiveArray(array: unknown[]): boolean {
-    return (
-      this.allItemsAreSortablePrimitives(array) &&
-      this.allItemsHaveSameSortableType(array)
-    );
-  }
-
-  /**
-   * Checks if all items are sortable primitives
-   */
-  private static allItemsAreSortablePrimitives(array: unknown[]): boolean {
-    return array.every((item) => this.isSortablePrimitive(item));
-  }
-
-  /**
-   * Checks if all items have the same sortable type
-   */
-  private static allItemsHaveSameSortableType(array: unknown[]): boolean {
-    if (array.length === 0) return true;
-
-    // Don't sort arrays with null/undefined values
-    if (this.hasNullishValues(array)) {
-      return false;
-    }
-
-    const firstItem = array[0];
-    if (!this.isSortablePrimitive(firstItem)) return false;
-
-    const firstType = typeof firstItem;
-    return array.every((item) => typeof item === firstType);
-  }
-
-  /**
-   * Compares two sortable primitive values
-   */
-  private static compareSortablePrimitives(
-    a: unknown,
-    b: unknown,
-    ascending: boolean
-  ): number {
-    if (typeof a === 'string' && typeof b === 'string') {
-      return this.compareStrings(a, b, ascending);
-    }
-
-    if (typeof a === 'number' && typeof b === 'number') {
-      return this.compareNumbers(a, b, ascending);
-    }
-
-    if (typeof a === 'boolean' && typeof b === 'boolean') {
-      return this.compareBooleans(a, b, ascending);
-    }
-
-    // Fallback for mixed types
-    return 0;
-  }
-
-  /**
-   * Compares two strings
-   */
-  private static compareStrings(
-    a: string,
-    b: string,
-    ascending: boolean
-  ): number {
-    const result = a.localeCompare(b);
-    return ascending ? result : -result;
-  }
-
-  /**
-   * Compares two numbers
-   */
-  private static compareNumbers(
-    a: number,
-    b: number,
-    ascending: boolean
-  ): number {
-    if (isNaN(a) && isNaN(b)) return 0;
-    if (isNaN(a)) return 1; // NaN always goes to the end
-    if (isNaN(b)) return -1; // NaN always goes to the end
-
-    const result = a - b;
-    return ascending ? result : -result;
-  }
-
-  /**
-   * Compares two booleans
-   */
-  private static compareBooleans(
-    a: boolean,
-    b: boolean,
-    ascending: boolean
-  ): number {
-    if (a === b) return 0;
-    if (a) return ascending ? 1 : -1;
-    return ascending ? -1 : 1;
-  }
-
-  /**
-   * Checks if a value is a sortable primitive
-   */
-  private static isSortablePrimitive(
-    value: unknown
-  ): value is string | number | boolean {
-    return SORTABLE_PRIMITIVE_TYPES.includes(
-      typeof value as SortablePrimitiveType
-    );
-  }
-
-  /**
-   * Checks if an array has nullish values
-   */
-  private static hasNullishValues(array: unknown[]): boolean {
-    return array.some(this.isNullish);
-  }
-
-  /**
-   * Checks if a value is nullish
-   */
-  private static isNullish(value: unknown): value is NullishValue {
-    return NULLISH_VALUES.includes(value as NullishValue);
-  }
-}