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

package/dist/index.js

@@ -23,8 +23,162 @@ __export(index_exports, {
   sort: () => sort
 });
 module.exports = __toCommonJS(index_exports);
-var NULLISH_VALUES = [null, void 0];
+
+// src/primitive-array-sorter.ts
 var SORTABLE_PRIMITIVE_TYPES = ["string", "number", "boolean"];
+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);
+  }
+};
+
+// 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);
@@ -33,17 +187,22 @@ function sortRecursively(data, options) {
   if (Array.isArray(data)) {
     return sortArray(data, options);
   }
-  if (isPrimitive(data) || isNonSortableObject(data)) {
+  if (TypeGuards.isPrimitive(data) || TypeGuards.isNonSortableObject(data)) {
     return data;
   }
-  if (isObject(data)) {
+  if (TypeGuards.isObject(data)) {
     return sortObject(data, options);
   }
   return data;
 }
 function sortArray(array, options) {
-  if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
-    return sortPrimitiveArray(array, options.ascending);
+  const sortedPrimitiveArray = PrimitiveArraySorter.sortPrimitiveArray(
+    array,
+    options.ascending,
+    options.sortPrimitiveArrays
+  );
+  if (sortedPrimitiveArray !== array) {
+    return sortedPrimitiveArray;
   }
   return array.map((item) => sortRecursively(item, options));
 }
@@ -52,53 +211,6 @@ function sortObject(obj, options) {
   const sortedEntries = sortObjectEntries(entries, options.ascending);
   return createSortedObject(sortedEntries, 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);
-}
-function compareSortablePrimitives(a, b, ascending) {
-  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;
-}
-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 collectObjectEntries(obj) {
   const stringEntries = Object.entries(obj);
   const symbolEntries = Object.getOwnPropertySymbols(obj).map(
@@ -126,37 +238,6 @@ function createSortedObject(entries, options) {
   ]);
   return Object.fromEntries(sortedEntries);
 }
-function isNullish(value) {
-  return NULLISH_VALUES.includes(value);
-}
-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);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   sort

package/dist/index.mjs

@@ -1,6 +1,158 @@
-// src/index.ts
-var NULLISH_VALUES = [null, void 0];
+// src/primitive-array-sorter.ts
 var SORTABLE_PRIMITIVE_TYPES = ["string", "number", "boolean"];
+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);
+  }
+};
+
+// 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);
@@ -9,17 +161,22 @@ function sortRecursively(data, options) {
   if (Array.isArray(data)) {
     return sortArray(data, options);
   }
-  if (isPrimitive(data) || isNonSortableObject(data)) {
+  if (TypeGuards.isPrimitive(data) || TypeGuards.isNonSortableObject(data)) {
     return data;
   }
-  if (isObject(data)) {
+  if (TypeGuards.isObject(data)) {
     return sortObject(data, options);
   }
   return data;
 }
 function sortArray(array, options) {
-  if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
-    return sortPrimitiveArray(array, options.ascending);
+  const sortedPrimitiveArray = PrimitiveArraySorter.sortPrimitiveArray(
+    array,
+    options.ascending,
+    options.sortPrimitiveArrays
+  );
+  if (sortedPrimitiveArray !== array) {
+    return sortedPrimitiveArray;
   }
   return array.map((item) => sortRecursively(item, options));
 }
@@ -28,53 +185,6 @@ function sortObject(obj, options) {
   const sortedEntries = sortObjectEntries(entries, options.ascending);
   return createSortedObject(sortedEntries, 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);
-}
-function compareSortablePrimitives(a, b, ascending) {
-  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;
-}
-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 collectObjectEntries(obj) {
   const stringEntries = Object.entries(obj);
   const symbolEntries = Object.getOwnPropertySymbols(obj).map(
@@ -102,37 +212,6 @@ function createSortedObject(entries, options) {
   ]);
   return Object.fromEntries(sortedEntries);
 }
-function isNullish(value) {
-  return NULLISH_VALUES.includes(value);
-}
-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);
-}
 export {
   sort
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamtamchik/json-deep-sort",
-  "version": "1.4.0-beta.1",
+  "version": "1.4.0-beta.3",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -32,14 +32,14 @@
     "json-tools"
   ],
   "devDependencies": {
-    "@types/jest": "^29.5.13",
-    "@types/node": "^22.7.5",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.2.1",
     "@typescript-eslint/eslint-plugin": "^8.39.0",
     "@typescript-eslint/parser": "^8.39.0",
     "eslint": "^9.33.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
-    "jest": "^29.7.0",
+    "jest": "^30.0.5",
     "jiti": "^2.5.1",
     "prettier": "^3.6.2",
     "ts-jest": "^29.2.4",

package/src/index.ts

@@ -1,23 +1,9 @@
-// Constants - make the code self-documenting
-const NULLISH_VALUES = [null, undefined] as const;
-const SORTABLE_PRIMITIVE_TYPES = ['string', 'number', 'boolean'] as const;
+import { PrimitiveArraySorter } from './primitive-array-sorter';
+import { TypeGuards } from './type-guards';
 
-// Type definitions that make sense
-type NullishValue = (typeof NULLISH_VALUES)[number];
-type SortablePrimitiveType = (typeof SORTABLE_PRIMITIVE_TYPES)[number];
+// Type definitions
 type ObjectType = Record<string | symbol, unknown>;
 type SortedEntry = [string | symbol, unknown];
-type NonSortableType =
-  | Date
-  | RegExp
-  | (() => unknown)
-  | ((...args: unknown[]) => unknown)
-  | Error
-  | Map<unknown, unknown>
-  | Set<unknown>
-  | WeakMap<object, unknown>
-  | WeakSet<object>
-  | Promise<unknown>;
 
 type SortOptions = {
   ascending: boolean;
@@ -38,11 +24,11 @@ function sortRecursively<T>(data: T, options: SortOptions): T {
     return sortArray(data, options) as T;
   }
 
-  if (isPrimitive(data) || isNonSortableObject(data)) {
+  if (TypeGuards.isPrimitive(data) || TypeGuards.isNonSortableObject(data)) {
     return data;
   }
 
-  if (isObject(data)) {
+  if (TypeGuards.isObject(data)) {
     return sortObject(data, options) as T;
   }
 
@@ -50,10 +36,18 @@ function sortRecursively<T>(data: T, options: SortOptions): T {
 }
 
 function sortArray<T>(array: T[], options: SortOptions): T[] {
-  if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
-    return sortPrimitiveArray(array, options.ascending) as 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));
 }
 
@@ -63,89 +57,6 @@ function sortObject(obj: ObjectType, options: SortOptions): ObjectType {
   return createSortedObject(sortedEntries, 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);
-}
-
-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
-}
-
-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;
-}
-
-function compareBooleans(a: boolean, b: boolean, ascending: boolean): number {
-  if (a === b) return 0;
-  if (a) return ascending ? 1 : -1;
-  return ascending ? -1 : 1;
-}
-
-// Object entry handling
 function collectObjectEntries(obj: ObjectType): SortedEntry[] {
   const stringEntries = Object.entries(obj);
   const symbolEntries = Object.getOwnPropertySymbols(obj).map(
@@ -192,47 +103,3 @@ function createSortedObject(
 
   return Object.fromEntries(sortedEntries);
 }
-
-// Type guards - single responsibility, clear naming
-function isNullish(value: unknown): value is NullishValue {
-  return NULLISH_VALUES.includes(value as NullishValue);
-}
-
-function hasNullishValues(array: unknown[]): boolean {
-  return array.some(isNullish);
-}
-
-function isSortablePrimitive(
-  value: unknown
-): value is string | number | boolean {
-  return SORTABLE_PRIMITIVE_TYPES.includes(
-    typeof value as SortablePrimitiveType
-  );
-}
-
-function isPrimitive(data: unknown): boolean {
-  return isSortablePrimitive(data) || isNullish(data);
-}
-
-function isObject(data: unknown): data is ObjectType {
-  return typeof data === 'object' && data !== null;
-}
-
-function isNonSortableObject(obj: unknown): obj is NonSortableType {
-  const nonSortableTypes = [
-    Date,
-    RegExp,
-    Function,
-    Error,
-    Map,
-    Set,
-    WeakMap,
-    WeakSet,
-    Promise,
-  ];
-
-  return (
-    nonSortableTypes.some((type) => obj instanceof type) ||
-    Symbol.iterator in Object(obj)
-  );
-}

package/src/object-sorter.ts

@@ -0,0 +1,72 @@
+// Type definitions for object sorting
+type ObjectType = Record<string | symbol, unknown>;
+type SortedEntry = [string | symbol, unknown];
+
+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];
+  }
+
+  /**
+   * Sorts object entries by key
+   */
+  private static sortObjectEntries(
+    entries: SortedEntry[],
+    ascending: boolean
+  ): SortedEntry[] {
+    return entries.sort(([keyA], [keyB]) =>
+      this.compareObjectKeys(keyA, keyB, ascending)
+    );
+  }
+
+  /**
+   * 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;
+
+    // Both are strings, use localeCompare
+    const stringA = keyA as string;
+    const stringB = keyB as string;
+
+    return ascending
+      ? stringA.localeCompare(stringB)
+      : stringB.localeCompare(stringA);
+  }
+
+  /**
+   * 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);
+  }
+}

package/src/primitive-array-sorter.ts

@@ -0,0 +1,151 @@
+// 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);
+  }
+}

package/src/type-guards.ts

@@ -0,0 +1,74 @@
+// 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>;
+
+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);
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * Checks if a value is nullish (null or undefined)
+   */
+  static isNullish(value: unknown): value is null | undefined {
+    return value === null || value === undefined;
+  }
+
+  /**
+   * Checks if a value is a plain object
+   */
+  static isObject(data: unknown): data is Record<string | symbol, unknown> {
+    return typeof data === 'object' && data !== null;
+  }
+
+  /**
+   * 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,
+    ];
+
+    return (
+      nonSortableTypes.some((type) => obj instanceof type) ||
+      Symbol.iterator in Object(obj)
+    );
+  }
+
+  /**
+   * Checks if an array has nullish values
+   */
+  static hasNullishValues(array: unknown[]): boolean {
+    return array.some(this.isNullish);
+  }
+}