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

package/README.md

@@ -50,15 +50,18 @@ console.log(sort(simpleData));
 
 // Example 2: Sorting a nested object
 const nestedData = {
-    b: 'b',
-    a: 'a',
-    c: { d: 'd', c: 'c', a: 'a', b: 'b' }
+  b: 'b',
+  a: 'a',
+  c: { d: 'd', c: 'c', a: 'a', b: 'b' },
 };
 console.log(sort(nestedData));
 // Output: { a: 'a', b: 'b', c: { a: 'a', b: 'b', c: 'c', d: 'd' } }
 
 // Example 3: Sorting an array of objects
-const arrayData = [{ b: 'b', a: 'a' }, { d: 'd', c: 'c' }];
+const arrayData = [
+  { b: 'b', a: 'a' },
+  { d: 'd', c: 'c' },
+];
 console.log(sort(arrayData));
 // Output: [{ a: 'a', b: 'b' }, { c: 'c', d: 'd' }]
 
@@ -69,14 +72,35 @@ console.log(sort(descendingData, false));
 
 // Example 5: Handling mixed data types
 const mixedData = {
-    b: [3, 1, 2],
-    a: { z: 'z', y: 'y' },
-    c: new Date('2023-01-01')
+  b: [3, 1, 2],
+  a: { z: 'z', y: 'y' },
+  c: new Date('2023-01-01'),
 };
 console.log(sort(mixedData));
 // Output: { a: { y: 'y', z: 'z' }, b: [3, 1, 2], c: Date('2023-01-01') }
+
+// Example 6: Sorting arrays of primitives
+const primitiveArrayData = ['b', 'a', 'c'];
+console.log(sort(primitiveArrayData, true, true));
+// Output: ['a', 'b', 'c']
 ```
 
+## API Reference
+
+### `sort(data, ascending?, sortPrimitiveArrays?)`
+
+Sorts a JSON object or array by keys in a specified order.
+
+**Parameters:**
+
+- `data` (required): The data to sort. Can be an object, array, or primitive value.
+- `ascending` (optional): Boolean flag to determine sort order. Defaults to `true` (ascending).
+- `sortPrimitiveArrays` (optional): Boolean flag to enable sorting of arrays containing primitive values (strings, numbers, booleans). Defaults to `false` to maintain backward compatibility.
+
+**Returns:** The sorted data with the same structure and type as the input.
+
+**Note:** When `sortPrimitiveArrays` is `false` (default), arrays of primitives are not modified, preserving the original behavior. When `true`, primitive arrays are sorted according to the `ascending` parameter.
+
 ## Contributing
 
 Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
@@ -92,7 +116,6 @@ JSON Deep Sort is [MIT licensed](./LICENSE).
 [ico-scrutinizer-build]: https://img.shields.io/scrutinizer/build/g/tamtamchik/json-deep-sort/main.svg?style=flat-square
 [ico-scrutinizer-quality]: https://img.shields.io/scrutinizer/quality/g/tamtamchik/json-deep-sort/main.svg?style=flat-square
 [ico-scrutinizer-coverage]: https://img.shields.io/scrutinizer/coverage/g/tamtamchik/json-deep-sort/main.svg?style=flat-square
-
 [link-coffee]: https://www.buymeacoffee.com/tamtamchik
 [link-npm]: https://www.npmjs.com/package/@tamtamchik/json-deep-sort
 [link-downloads]: https://www.npmjs.com/package/@tamtamchik/json-deep-sort

package/dist/index.js

@@ -18,35 +18,143 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   sort: () => sort
 });
-module.exports = __toCommonJS(src_exports);
-function sort(data, ascending = true) {
-  return sortRecursively(data, ascending);
+module.exports = __toCommonJS(index_exports);
+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);
 }
-function sortRecursively(data, ascending) {
-  if (!isObject(data) || Array.isArray(data) || isNonSortableObject(data)) {
-    return Array.isArray(data) ? data.map((item) => sortRecursively(item, ascending)) : data;
+function sortRecursively(data, options) {
+  if (Array.isArray(data)) {
+    return sortArray(data, options);
   }
-  return sortObject(data, ascending);
+  if (isPrimitive(data) || isNonSortableObject(data)) {
+    return data;
+  }
+  if (isObject(data)) {
+    return sortObject(data, options);
+  }
+  return data;
+}
+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);
+}
+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(
+    (symbol) => [symbol, obj[symbol]]
+  );
+  return [...stringEntries, ...symbolEntries];
+}
+function sortObjectEntries(entries, ascending) {
+  return entries.sort(
+    ([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,
+    sortRecursively(value, 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 sortObject(obj, ascending) {
-  const entries = [...Object.entries(obj), ...Object.getOwnPropertySymbols(obj).map((sym) => [sym, obj[sym]])];
-  const sortedEntries = entries.sort(([keyA], [keyB]) => {
-    if (typeof keyA === "symbol" && typeof keyB === "symbol") return 0;
-    if (typeof keyA === "symbol") return 1;
-    if (typeof keyB === "symbol") return -1;
-    return ascending ? keyA.localeCompare(keyB) : keyB.localeCompare(keyA);
-  });
-  return Object.fromEntries(sortedEntries.map(([key, value]) => [key, sortRecursively(value, ascending)]));
-}
 function isNonSortableObject(obj) {
-  const nonSortableTypes = [Date, RegExp, Function, Error, Map, Set, WeakMap, WeakSet, Promise];
+  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:

package/dist/index.mjs

@@ -1,28 +1,136 @@
 // src/index.ts
-function sort(data, ascending = true) {
-  return sortRecursively(data, ascending);
+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);
 }
-function sortRecursively(data, ascending) {
-  if (!isObject(data) || Array.isArray(data) || isNonSortableObject(data)) {
-    return Array.isArray(data) ? data.map((item) => sortRecursively(item, ascending)) : data;
+function sortRecursively(data, options) {
+  if (Array.isArray(data)) {
+    return sortArray(data, options);
   }
-  return sortObject(data, ascending);
+  if (isPrimitive(data) || isNonSortableObject(data)) {
+    return data;
+  }
+  if (isObject(data)) {
+    return sortObject(data, options);
+  }
+  return data;
+}
+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);
+}
+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(
+    (symbol) => [symbol, obj[symbol]]
+  );
+  return [...stringEntries, ...symbolEntries];
+}
+function sortObjectEntries(entries, ascending) {
+  return entries.sort(
+    ([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,
+    sortRecursively(value, 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 sortObject(obj, ascending) {
-  const entries = [...Object.entries(obj), ...Object.getOwnPropertySymbols(obj).map((sym) => [sym, obj[sym]])];
-  const sortedEntries = entries.sort(([keyA], [keyB]) => {
-    if (typeof keyA === "symbol" && typeof keyB === "symbol") return 0;
-    if (typeof keyA === "symbol") return 1;
-    if (typeof keyB === "symbol") return -1;
-    return ascending ? keyA.localeCompare(keyB) : keyB.localeCompare(keyA);
-  });
-  return Object.fromEntries(sortedEntries.map(([key, value]) => [key, sortRecursively(value, ascending)]));
-}
 function isNonSortableObject(obj) {
-  const nonSortableTypes = [Date, RegExp, Function, Error, Map, Set, WeakMap, WeakSet, Promise];
+  const nonSortableTypes = [
+    Date,
+    RegExp,
+    Function,
+    Error,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Promise
+  ];
   return nonSortableTypes.some((type) => obj instanceof type) || Symbol.iterator in Object(obj);
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamtamchik/json-deep-sort",
-  "version": "1.3.0",
+  "version": "1.4.0-beta.1",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -34,16 +34,24 @@
   "devDependencies": {
     "@types/jest": "^29.5.13",
     "@types/node": "^22.7.5",
+    "@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",
+    "jiti": "^2.5.1",
+    "prettier": "^3.6.2",
     "ts-jest": "^29.2.4",
+    "ts-node": "^10.9.2",
     "tsup": "^8.3.0",
     "typescript": "^5.6.3"
   },
   "exports": {
     ".": {
+      "types": "./src/index.ts",
       "require": "./dist/index.js",
-      "import": "./dist/index.mjs",
-      "types": "./src/index.ts"
+      "import": "./dist/index.mjs"
     }
   },
   "scripts": {
@@ -51,6 +59,9 @@
     "dev": "npm run build -- --watch src",
     "prepublishOnly": "npm run build",
     "test": "jest",
-    "coverage": "jest --coverage"
+    "coverage": "jest --coverage",
+    "format": "prettier --write .",
+    "lint": "eslint . --ext .ts,.js",
+    "lint:fix": "eslint . --ext .ts,.js --fix"
   }
 }

package/src/index.ts

@@ -1,43 +1,238 @@
-// Type definitions for object types and non-sortable types
+// 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 | Function | Error | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<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;
+};
 
-// Main sorting function that can handle various data types
-export function sort<T>(data: T, ascending = true): T {
-  return sortRecursively(data, ascending);
+export function sort<T>(
+  data: T,
+  ascending = true,
+  sortPrimitiveArrays = false
+): T {
+  const options: SortOptions = { ascending, sortPrimitiveArrays };
+  return sortRecursively(data, options);
 }
 
-// Recursive function to sort nested structures
-function sortRecursively<T>(data: T, ascending: boolean): T {
-  if (!isObject(data) || Array.isArray(data) || isNonSortableObject(data)) {
-    return Array.isArray(data) ? data.map(item => sortRecursively(item, ascending)) as T : data;
+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;
   }
 
-  return sortObject(data as ObjectType, ascending) as T;
+  if (isObject(data)) {
+    return sortObject(data, options) as T;
+  }
+
+  return data;
 }
 
-// Helper function to check if a value is an object
-function isObject(data: unknown): data is ObjectType {
-  return typeof data === 'object' && data !== null;
+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 to sort object properties
-function sortObject(obj: ObjectType, ascending: boolean): ObjectType {
-  const entries = [...Object.entries(obj), ...Object.getOwnPropertySymbols(obj).map(sym => [sym, obj[sym]] as SortedEntry)];
-  
-  const sortedEntries = entries.sort(([keyA], [keyB]) => {
-    if (typeof keyA === 'symbol' && typeof keyB === 'symbol') return 0;
-    if (typeof keyA === 'symbol') return 1;
-    if (typeof keyB === 'symbol') return -1;
-    return ascending ? (keyA as string).localeCompare(keyB as string) : (keyB as string).localeCompare(keyA as string);
-  });
+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);
 
-  return Object.fromEntries(sortedEntries.map(([key, value]) => [key, sortRecursively(value, ascending)]));
+  // 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;
 }
 
-// Helper function to check if an object is of a non-sortable type
 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);
+  const nonSortableTypes = [
+    Date,
+    RegExp,
+    Function,
+    Error,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Promise,
+  ];
+
+  return (
+    nonSortableTypes.some((type) => obj instanceof type) ||
+    Symbol.iterator in Object(obj)
+  );
 }