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

package/dist/index.js

@@ -23,35 +23,88 @@ __export(index_exports, {
   sort: () => sort
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
 var NULLISH_VALUES = [null, void 0];
-var SORTABLE_PRIMITIVE_TYPES = ["string", "number", "boolean"];
-function sort(data, ascending = true, sortPrimitiveArrays = false) {
-  const options = { ascending, sortPrimitiveArrays };
-  return sortRecursively(data, options);
+var SORTABLE_PRIMITIVE_TYPES = [
+  "string",
+  "number",
+  "boolean"
+];
+
+// src/type-guards.ts
+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 (isPrimitive(data) || isNonSortableObject(data)) {
-    return data;
+  if (typeof a === "number" && typeof b === "number") {
+    return compareNumbers(a, b, ascending);
   }
-  if (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) {
   if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
     return sortPrimitiveArray(array, options.ascending);
   }
   return array.map((item) => sortRecursively(item, options));
 }
-function sortObject(obj, options) {
-  const entries = collectObjectEntries(obj);
-  const sortedEntries = sortObjectEntries(entries, options.ascending);
-  return createSortedObject(sortedEntries, options);
-}
 function shouldSortPrimitiveArray(array, sortPrimitiveArrays) {
   return sortPrimitiveArrays && canSortPrimitiveArray(array);
 }
@@ -76,28 +129,12 @@ function allItemsHaveSameSortableType(array) {
   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;
+
+// src/object-sorter.ts
+function sortObject(obj, options) {
+  const entries = collectObjectEntries(obj);
+  const sortedEntries = sortObjectEntries(entries, options.ascending);
+  return createSortedObject(sortedEntries, options);
 }
 function collectObjectEntries(obj) {
   const stringEntries = Object.entries(obj);
@@ -111,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,
@@ -126,36 +155,25 @@ 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;
+
+// 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;
 }
-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/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 = {

package/dist/index.mjs

@@ -1,33 +1,84 @@
-// src/index.ts
+// src/types.ts
 var NULLISH_VALUES = [null, void 0];
-var SORTABLE_PRIMITIVE_TYPES = ["string", "number", "boolean"];
-function sort(data, ascending = true, sortPrimitiveArrays = false) {
-  const options = { ascending, sortPrimitiveArrays };
-  return sortRecursively(data, options);
+var SORTABLE_PRIMITIVE_TYPES = [
+  "string",
+  "number",
+  "boolean"
+];
+
+// src/type-guards.ts
+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 (isPrimitive(data) || isNonSortableObject(data)) {
-    return data;
+  if (typeof a === "number" && typeof b === "number") {
+    return compareNumbers(a, b, ascending);
   }
-  if (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) {
   if (shouldSortPrimitiveArray(array, options.sortPrimitiveArrays)) {
     return sortPrimitiveArray(array, options.ascending);
   }
   return array.map((item) => sortRecursively(item, options));
 }
-function sortObject(obj, options) {
-  const entries = collectObjectEntries(obj);
-  const sortedEntries = sortObjectEntries(entries, options.ascending);
-  return createSortedObject(sortedEntries, options);
-}
 function shouldSortPrimitiveArray(array, sortPrimitiveArrays) {
   return sortPrimitiveArrays && canSortPrimitiveArray(array);
 }
@@ -52,28 +103,12 @@ function allItemsHaveSameSortableType(array) {
   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;
+
+// src/object-sorter.ts
+function sortObject(obj, options) {
+  const entries = collectObjectEntries(obj);
+  const sortedEntries = sortObjectEntries(entries, options.ascending);
+  return createSortedObject(sortedEntries, options);
 }
 function collectObjectEntries(obj) {
   const stringEntries = Object.entries(obj);
@@ -87,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,
@@ -102,36 +129,25 @@ 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;
+
+// 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;
 }
-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/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.2",
+  "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,28 +1,5 @@
-// Constants - make the code self-documenting
-const NULLISH_VALUES = [null, undefined] as const;
-const SORTABLE_PRIMITIVE_TYPES = ['string', 'number', 'boolean'] as const;
-
-// Type definitions that make sense
-type NullishValue = (typeof NULLISH_VALUES)[number];
-type SortablePrimitiveType = (typeof SORTABLE_PRIMITIVE_TYPES)[number];
-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;
-  sortPrimitiveArrays: boolean;
-};
+import { SortOptions } from './types';
+import { sortRecursively } from './core';
 
 export function sort<T>(
   data: T,
@@ -33,206 +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 (isPrimitive(data) || isNonSortableObject(data)) {
-    return data;
-  }
-
-  if (isObject(data)) {
-    return sortObject(data, options) as T;
-  }
-
-  return data;
-}
-
-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 sortObject(obj: ObjectType, options: SortOptions): ObjectType {
-  const entries = collectObjectEntries(obj);
-  const sortedEntries = sortObjectEntries(entries, options.ascending);
-  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(
-    (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);
-}
-
-// 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)
-  );
-}
+// Re-export types for convenience
+export type {
+  SortOptions,
+  ObjectType,
+  SortedEntry,
+  NonSortableType,
+} from './types';

package/src/object-sorter.ts

@@ -0,0 +1,41 @@
+import { SortOptions, ObjectType, SortedEntry } from './types';
+import { compareObjectKeys } from './comparators';
+
+export function sortObject(obj: ObjectType, options: SortOptions): ObjectType {
+  const entries = collectObjectEntries(obj);
+  const sortedEntries = sortObjectEntries(entries, options.ascending);
+  return createSortedObject(sortedEntries, options);
+}
+
+// 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
+  );
+
+  return [...stringEntries, ...symbolEntries];
+}
+
+function sortObjectEntries(
+  entries: SortedEntry[],
+  ascending: boolean
+): SortedEntry[] {
+  return entries.sort(([keyA], [keyB]) =>
+    compareObjectKeys(keyA, keyB, ascending)
+  );
+}
+
+function createSortedObject(
+  entries: SortedEntry[],
+  options: SortOptions
+): ObjectType {
+  const sortedEntries = entries.map(([key, value]) => [
+    key,
+    sortRecursively(value, options),
+  ]);
+
+  return Object.fromEntries(sortedEntries);
+}
+
+import { sortRecursively } from './core';

package/src/type-guards.ts

@@ -0,0 +1,51 @@
+import {
+  NULLISH_VALUES,
+  SORTABLE_PRIMITIVE_TYPES,
+  NullishValue,
+  NonSortableType,
+  ObjectType,
+} from './types';
+
+// Type guards - single responsibility, clear naming
+export function isNullish(value: unknown): value is NullishValue {
+  return NULLISH_VALUES.includes(value as NullishValue);
+}
+
+export function hasNullishValues(array: unknown[]): boolean {
+  return array.some(isNullish);
+}
+
+export function isSortablePrimitive(
+  value: unknown
+): value is string | number | boolean {
+  return SORTABLE_PRIMITIVE_TYPES.includes(
+    typeof value as 'string' | 'number' | 'boolean'
+  );
+}
+
+export function isPrimitive(data: unknown): boolean {
+  return isSortablePrimitive(data) || isNullish(data);
+}
+
+export function isObject(data: unknown): data is ObjectType {
+  return typeof data === 'object' && data !== null;
+}
+
+export 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/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;
+};