@tamtamchik/json-deep-sort 1.2.0 → 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,28 +23,23 @@ __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, asc = true) {
-  const type = getType(data);
-  if (type === "array" /* ARRAY */) {
-    return data.map(
-      (item) => getType(item) !== "primitive" /* PRIMITIVE */ ? sort(item, asc) : item
-    );
+  if (!data || typeof data !== "object") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => sort(item, asc));
   }
-  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;
-    }, {});
+  if (isNonSortableObject(data)) {
+    return 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,26 +1,21 @@
 // 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, asc = true) {
-  const type = getType(data);
-  if (type === "array" /* ARRAY */) {
-    return data.map(
-      (item) => getType(item) !== "primitive" /* PRIMITIVE */ ? sort(item, asc) : item
-    );
+  if (!data || typeof data !== "object") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => sort(item, asc));
   }
-  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;
-    }, {});
+  if (isNonSortableObject(data)) {
+    return 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.2.0",
+  "version": "1.2.1",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/index.ts

@@ -1,24 +1,3 @@
-/**
- * Enumeration of data types.
- * @enum {string}
- */
-enum DataType {
-  OBJECT = 'object',
-  ARRAY = 'array',
-  PRIMITIVE = 'primitive'
-}
-
-/**
- * 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;
-}
-
 /**
  * Function to sort JSON data.
  * @param {unknown} data - The data to be sorted.
@@ -26,24 +5,37 @@ function getType(data: unknown): DataType {
  * @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
-    );
+  if (!data || typeof data !== 'object') {
+    return data;
   }
 
-  if (type === DataType.OBJECT) {
-    const sortedKeys = Object.keys(data as object).sort();
-    if (!asc) sortedKeys.reverse();
+  if (Array.isArray(data)) {
+    return data.map(item => sort(item, asc));
+  }
 
-    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;
-    }, {});
+  if (isNonSortableObject(data)) {
+    return data;
   }
 
-  return data;
+  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)])
+  );
+}
+
+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)
+  );
 }