@tamtamchik/json-deep-sort 1.2.0 → 1.3.0

package/README.md

@@ -8,9 +8,15 @@
 [![Software License][ico-license]](LICENSE)
 [![Total Downloads][ico-downloads]][link-downloads]
 
-JSON Deep Sort is a comprehensive package that provides flexible sorting of JSON objects by keys. This
-TypeScript-written package can handle deeply nested objects and arrays, and offers both synchronous and asynchronous
-operations.
+JSON Deep Sort is a powerful and versatile TypeScript package designed for efficient sorting of JSON objects by keys. It offers:
+
+- Comprehensive handling of deeply nested objects and arrays
+- Flexible sorting options, including ascending and descending order
+- Support for both synchronous and asynchronous operations
+- Preservation of non-sortable objects (e.g., Date, RegExp, Function)
+- Lightweight implementation with zero dependencies
+
+Whether you're working with simple flat objects or complex nested structures, JSON Deep Sort provides a reliable solution for organizing your data.
 
 ## Installation
 
@@ -37,19 +43,38 @@ import { sort } from '@tamtamchik/json-deep-sort';
 Here is an example of sorting a JSON object:
 
 ```typescript
-let data = {
+// Example 1: Sorting a simple object
+const simpleData = { b: 'b', a: 'a', c: 'c' };
+console.log(sort(simpleData));
+// Output: { a: 'a', b: 'b', c: 'c' }
+
+// Example 2: Sorting a nested object
+const nestedData = {
     b: 'b',
     a: 'a',
-    c: {
-        d: 'd',
-        c: 'c',
-        a: 'a',
-        b: 'b'
-    }
+    c: { d: 'd', c: 'c', a: 'a', b: 'b' }
 };
-
-let sortedData = sort(data, true);
-// { a: 'a', b: 'b', c: { a: 'a', b: 'b', c: 'c', d: 'd' } }
+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' }];
+console.log(sort(arrayData));
+// Output: [{ a: 'a', b: 'b' }, { c: 'c', d: 'd' }]
+
+// Example 4: Sorting in descending order
+const descendingData = { a: 'a', c: 'c', b: 'b' };
+console.log(sort(descendingData, false));
+// Output: { c: 'c', b: 'b', a: 'a' }
+
+// Example 5: Handling mixed data types
+const mixedData = {
+    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') }
 ```
 
 ## Contributing

package/dist/index.js

@@ -23,28 +23,31 @@ __export(src_exports, {
   sort: () => sort
 });
 module.exports = __toCommonJS(src_exports);
-function getType(data) {
-  if (Array.isArray(data)) return "array" /* ARRAY */;
-  if (data !== null && typeof data === "object") return "object" /* OBJECT */;
-  return "primitive" /* PRIMITIVE */;
+function sort(data, ascending = true) {
+  return sortRecursively(data, ascending);
 }
-function sort(data, asc = true) {
-  const type = getType(data);
-  if (type === "array" /* ARRAY */) {
-    return data.map(
-      (item) => getType(item) !== "primitive" /* PRIMITIVE */ ? sort(item, asc) : item
-    );
+function sortRecursively(data, ascending) {
+  if (!isObject(data) || Array.isArray(data) || isNonSortableObject(data)) {
+    return Array.isArray(data) ? data.map((item) => sortRecursively(item, ascending)) : data;
   }
-  if (type === "object" /* OBJECT */) {
-    const sortedKeys = Object.keys(data).sort();
-    if (!asc) sortedKeys.reverse();
-    return sortedKeys.reduce((result, key) => {
-      const value = data[key];
-      result[key] = getType(value) !== "primitive" /* PRIMITIVE */ ? sort(value, asc) : value;
-      return result;
-    }, {});
-  }
-  return data;
+  return sortObject(data, ascending);
+}
+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];
+  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 = {

package/dist/index.mjs

@@ -1,26 +1,29 @@
 // src/index.ts
-function getType(data) {
-  if (Array.isArray(data)) return "array" /* ARRAY */;
-  if (data !== null && typeof data === "object") return "object" /* OBJECT */;
-  return "primitive" /* PRIMITIVE */;
+function sort(data, ascending = true) {
+  return sortRecursively(data, ascending);
 }
-function sort(data, asc = true) {
-  const type = getType(data);
-  if (type === "array" /* ARRAY */) {
-    return data.map(
-      (item) => getType(item) !== "primitive" /* PRIMITIVE */ ? sort(item, asc) : item
-    );
+function sortRecursively(data, ascending) {
+  if (!isObject(data) || Array.isArray(data) || isNonSortableObject(data)) {
+    return Array.isArray(data) ? data.map((item) => sortRecursively(item, ascending)) : data;
   }
-  if (type === "object" /* OBJECT */) {
-    const sortedKeys = Object.keys(data).sort();
-    if (!asc) sortedKeys.reverse();
-    return sortedKeys.reduce((result, key) => {
-      const value = data[key];
-      result[key] = getType(value) !== "primitive" /* PRIMITIVE */ ? sort(value, asc) : value;
-      return result;
-    }, {});
-  }
-  return data;
+  return sortObject(data, ascending);
+}
+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];
+  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.2.0",
+  "version": "1.3.0",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -32,12 +32,12 @@
     "json-tools"
   ],
   "devDependencies": {
-    "@types/jest": "^29.5.12",
-    "@types/node": "^22.3.0",
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.7.5",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.4",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.3"
   },
   "exports": {
     ".": {

package/src/index.ts

@@ -1,49 +1,43 @@
-/**
- * Enumeration of data types.
- * @enum {string}
- */
-enum DataType {
-  OBJECT = 'object',
-  ARRAY = 'array',
-  PRIMITIVE = 'primitive'
-}
+// Type definitions for object types and non-sortable types
+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>;
 
-/**
- * Function to determine the data type of the provided data.
- * @param {unknown} data - The data to be checked.
- * @returns {DataType} The DataType value corresponding to the data's type.
- */
-function getType(data: unknown): DataType {
-  if (Array.isArray(data)) return DataType.ARRAY;
-  if (data !== null && typeof data === 'object') return DataType.OBJECT;
-  return DataType.PRIMITIVE;
+// Main sorting function that can handle various data types
+export function sort<T>(data: T, ascending = true): T {
+  return sortRecursively(data, ascending);
 }
 
-/**
- * Function to sort JSON data.
- * @param {unknown} data - The data to be sorted.
- * @param {boolean} [asc=true] - Whether to sort in ascending order.
- * @returns {unknown} The sorted data.
- */
-export function sort(data: unknown, asc: boolean = true): unknown {
-  const type = getType(data);
-
-  if (type === DataType.ARRAY) {
-    return (data as unknown[]).map(item =>
-      getType(item) !== DataType.PRIMITIVE ? sort(item, asc) : item
-    );
+// 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;
   }
 
-  if (type === DataType.OBJECT) {
-    const sortedKeys = Object.keys(data as object).sort();
-    if (!asc) sortedKeys.reverse();
+  return sortObject(data as ObjectType, ascending) as T;
+}
 
-    return sortedKeys.reduce((result: Record<string, unknown>, key) => {
-      const value = (data as Record<string, unknown>)[key];
-      result[key] = getType(value) !== DataType.PRIMITIVE ? sort(value, asc) : value;
-      return result;
-    }, {});
-  }
+// Helper function to check if a value is an object
+function isObject(data: unknown): data is ObjectType {
+  return typeof data === 'object' && data !== null;
+}
+
+// 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);
+  });
+
+  return Object.fromEntries(sortedEntries.map(([key, value]) => [key, sortRecursively(value, ascending)]));
+}
 
-  return data;
+// 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);
 }