@tamtamchik/json-deep-sort 1.1.4 → 1.2.1

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,34 +23,23 @@ __export(src_exports, {
   sort: () => sort
 });
 module.exports = __toCommonJS(src_exports);
-function getType(data) {
+function sort(data, asc = true) {
+  if (!data || typeof data !== "object") {
+    return data;
+  }
   if (Array.isArray(data)) {
-    return 1 /* ARRAY */;
-  } else if (typeof data === "object" && data !== null) {
-    return 0 /* OBJECT */;
-  } else if (typeof data === "string") {
-    return 2 /* STRING */;
-  } else {
-    return 3 /* OTHER */;
+    return data.map((item) => sort(item, asc));
   }
-}
-function isRecursiveType(data) {
-  return [0 /* OBJECT */, 1 /* ARRAY */].includes(getType(data));
-}
-function sort(data, asc = true) {
-  switch (getType(data)) {
-    case 1 /* ARRAY */:
-      return data.map((d) => isRecursiveType(d) ? sort(d, asc) : d);
-    case 0 /* OBJECT */:
-      const keys = Object.keys(data).sort();
-      if (!asc) keys.reverse();
-      return keys.reduce((newData, key) => {
-        newData[key] = isRecursiveType(data[key]) ? sort(data[key], asc) : data[key];
-        return newData;
-      }, {});
-    default:
-      throw new Error("Invalid data type: expected an object or array of objects.");
+  if (isNonSortableObject(data)) {
+    return data;
   }
+  const sortedEntries = Object.entries(data).sort(([a], [b]) => asc ? a.localeCompare(b) : b.localeCompare(a));
+  return Object.fromEntries(
+    sortedEntries.map(([key, value]) => [key, sort(value, asc)])
+  );
+}
+function isNonSortableObject(obj) {
+  return obj instanceof Date || obj instanceof RegExp || obj instanceof Function || obj instanceof Error || obj instanceof Map || obj instanceof Set || obj instanceof WeakMap || obj instanceof WeakSet || obj instanceof Promise || Symbol.iterator in Object(obj);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -1,32 +1,21 @@
 // src/index.ts
-function getType(data) {
+function sort(data, asc = true) {
+  if (!data || typeof data !== "object") {
+    return data;
+  }
   if (Array.isArray(data)) {
-    return 1 /* ARRAY */;
-  } else if (typeof data === "object" && data !== null) {
-    return 0 /* OBJECT */;
-  } else if (typeof data === "string") {
-    return 2 /* STRING */;
-  } else {
-    return 3 /* OTHER */;
+    return data.map((item) => sort(item, asc));
   }
-}
-function isRecursiveType(data) {
-  return [0 /* OBJECT */, 1 /* ARRAY */].includes(getType(data));
-}
-function sort(data, asc = true) {
-  switch (getType(data)) {
-    case 1 /* ARRAY */:
-      return data.map((d) => isRecursiveType(d) ? sort(d, asc) : d);
-    case 0 /* OBJECT */:
-      const keys = Object.keys(data).sort();
-      if (!asc) keys.reverse();
-      return keys.reduce((newData, key) => {
-        newData[key] = isRecursiveType(data[key]) ? sort(data[key], asc) : data[key];
-        return newData;
-      }, {});
-    default:
-      throw new Error("Invalid data type: expected an object or array of objects.");
+  if (isNonSortableObject(data)) {
+    return data;
   }
+  const sortedEntries = Object.entries(data).sort(([a], [b]) => asc ? a.localeCompare(b) : b.localeCompare(a));
+  return Object.fromEntries(
+    sortedEntries.map(([key, value]) => [key, sort(value, asc)])
+  );
+}
+function isNonSortableObject(obj) {
+  return obj instanceof Date || obj instanceof RegExp || obj instanceof Function || obj instanceof Error || obj instanceof Map || obj instanceof Set || obj instanceof WeakMap || obj instanceof WeakSet || obj instanceof Promise || Symbol.iterator in Object(obj);
 }
 export {
   sort

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamtamchik/json-deep-sort",
-  "version": "1.1.4",
+  "version": "1.2.1",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -33,10 +33,10 @@
   ],
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.11",
+    "@types/node": "^22.3.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.3",
-    "tsup": "^8.2.2",
+    "ts-jest": "^29.2.4",
+    "tsup": "^8.2.4",
     "typescript": "^5.5.4"
   },
   "exports": {

package/src/index.ts

@@ -1,64 +1,41 @@
-/**
- * Enumeration of data types.
- * @enum {string}
- */
-enum DataType {
-  OBJECT,
-  ARRAY,
-  STRING,
-  OTHER,
-}
-
-/**
- * Function to determine the data type of the provided data.
- * @param {any} data - The data to be checked.
- * @returns {DataType} The DataType value corresponding to the data's type.
- */
-function getType (data: any): DataType {
-  if (Array.isArray(data)) {
-    return DataType.ARRAY
-  } else if (typeof data === 'object' && data !== null) {
-    return DataType.OBJECT
-  } else if (typeof data === 'string') {
-    return DataType.STRING
-  } else {
-    return DataType.OTHER
-  }
-}
-
-/**
- * Function to determine whether the provided data is a recursive type.
- * @param {any} data - The data to be checked.
- * @returns {boolean} Whether the data is a recursive type.
- */
-function isRecursiveType (data: any): boolean {
-  return [DataType.OBJECT, DataType.ARRAY].includes(getType(data))
-}
-
 /**
  * Function to sort JSON data.
- * @param {any} data - The data to be sorted.
+ * @param {unknown} data - The data to be sorted.
  * @param {boolean} [asc=true] - Whether to sort in ascending order.
- * @returns {any} The sorted data.
- * @throws {Error} If the data is not an object or array.
+ * @returns {unknown} The sorted data.
  */
-export function sort (data: any, asc: boolean = true): any {
-  switch (getType(data)) {
-
-    case DataType.ARRAY:
-      return data.map((d: any) => isRecursiveType(d) ? sort(d, asc) : d)
+export function sort(data: unknown, asc: boolean = true): unknown {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
 
-    case DataType.OBJECT:
-      const keys = Object.keys(data).sort()
+  if (Array.isArray(data)) {
+    return data.map(item => sort(item, asc));
+  }
 
-      if (!asc) keys.reverse()
+  if (isNonSortableObject(data)) {
+    return data;
+  }
 
-      return keys.reduce((newData: any, key: string) => {
-        newData[key] = isRecursiveType(data[key]) ? sort(data[key], asc) : data[key]
-        return newData
-      }, {})
+  const sortedEntries = Object.entries(data as Record<string, unknown>)
+    .sort(([a], [b]) => asc ? a.localeCompare(b) : b.localeCompare(a));
+  
+  return Object.fromEntries(
+    sortedEntries.map(([key, value]) => [key, sort(value, asc)])
+  );
+}
 
-    default:
-      throw new Error('Invalid data type: expected an object or array of objects.')
-  }
+function isNonSortableObject(obj: object): boolean {
+  return (
+    obj instanceof Date ||
+    obj instanceof RegExp ||
+    obj instanceof Function ||
+    obj instanceof Error ||
+    obj instanceof Map ||
+    obj instanceof Set ||
+    obj instanceof WeakMap ||
+    obj instanceof WeakSet ||
+    obj instanceof Promise ||
+    Symbol.iterator in Object(obj)
+  );
 }