@tamtamchik/json-deep-sort 1.1.3 → 1.2.0

package/dist/index.js

@@ -24,34 +24,27 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 function getType(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 */;
-  }
-}
-function isRecursiveType(data) {
-  return [0 /* OBJECT */, 1 /* ARRAY */].includes(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) {
-  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.");
+  const type = getType(data);
+  if (type === "array" /* ARRAY */) {
+    return data.map(
+      (item) => getType(item) !== "primitive" /* PRIMITIVE */ ? sort(item, asc) : item
+    );
+  }
+  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;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -1,33 +1,26 @@
 // src/index.ts
 function getType(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 */;
-  }
-}
-function isRecursiveType(data) {
-  return [0 /* OBJECT */, 1 /* ARRAY */].includes(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) {
-  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.");
+  const type = getType(data);
+  if (type === "array" /* ARRAY */) {
+    return data.map(
+      (item) => getType(item) !== "primitive" /* PRIMITIVE */ ? sort(item, asc) : item
+    );
+  }
+  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;
 }
 export {
   sort

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamtamchik/json-deep-sort",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "A comprehensive utility for sorting JSON objects by keys.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -33,11 +33,11 @@
   ],
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.12.8",
+    "@types/node": "^22.3.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
-    "tsup": "^8.0.2",
-    "typescript": "^5.4.5"
+    "ts-jest": "^29.2.4",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
   },
   "exports": {
     ".": {

package/src/index.ts

@@ -3,62 +3,47 @@
  * @enum {string}
  */
 enum DataType {
-  OBJECT,
-  ARRAY,
-  STRING,
-  OTHER,
+  OBJECT = 'object',
+  ARRAY = 'array',
+  PRIMITIVE = 'primitive'
 }
 
 /**
  * Function to determine the data type of the provided data.
- * @param {any} data - The data to be checked.
+ * @param {unknown} 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 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 {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)) {
+export function sort(data: unknown, asc: boolean = true): unknown {
+  const type = getType(data);
 
-    case DataType.ARRAY:
-      return data.map((d: any) => isRecursiveType(d) ? sort(d, asc) : d)
-
-    case DataType.OBJECT:
-      const keys = Object.keys(data).sort()
-
-      if (!asc) keys.reverse()
+  if (type === DataType.ARRAY) {
+    return (data as unknown[]).map(item =>
+      getType(item) !== DataType.PRIMITIVE ? sort(item, asc) : item
+    );
+  }
 
-      return keys.reduce((newData: any, key: string) => {
-        newData[key] = isRecursiveType(data[key]) ? sort(data[key], asc) : data[key]
-        return newData
-      }, {})
+  if (type === DataType.OBJECT) {
+    const sortedKeys = Object.keys(data as object).sort();
+    if (!asc) sortedKeys.reverse();
 
-    default:
-      throw new Error('Invalid data type: expected an object or array of objects.')
+    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;
+    }, {});
   }
+
+  return data;
 }