@ibgib/ts-gib 0.5.21 → 0.5.23

package/src/helper.mts

@@ -75,38 +75,50 @@ export function getIbAndGib({
     }
 }
 
+
 /**
- * normalizes via sorting keys and removing values that are undefined.
- * values that are null or empty strings are not removed.
+ * Normalizes an object/value for consistent hashing.
+ * - Recursively processes objects and arrays.
+ * - For objects:
+ *   - Sorts keys alphabetically.
+ *   - Removes properties whose values are `undefined`.
+ *   - Keeps properties whose values are `null`.
+ * - For arrays:
+ *   - Preserves element order.
+ *   - Recursively normalizes each element.
+ * - Primitives (strings, numbers, booleans) and `null` are returned as is.
  *
- * this is DUPLICATED code in the respec file. any changes here must
- * manually be changed in the respec file!!!
+ * @param value The value to normalize.
+ * @returns The normalized value.
  *
- * @param obj to normalize (is not changed, e.g. keys aren't sorted in place)
+ * This has been adjusted due to conversation with Gemini and working on python
+ * port.  The main thing here is that we normalize array members, but not the
+ * array itself. This way the array's order is preserved, but any object members
+ * are themselves normalized.
  */
-export function toNormalizedForHashing(obj: any): any {
-    if (!obj) {
-        return obj; /* <<<< returns early */
-    } else if (typeof obj === 'string' || Array.isArray(obj)) {
-        return obj.concat(); /* <<<< returns early */
-    } else if (typeof obj !== 'object') {
-        // Return non-objects as is, we don't know how to concat/copy it...hmm...
-        return obj;  /* <<<< returns early */
+export function toNormalizedForHashing(value: any): any {
+    // Handle null, primitives (string, number, boolean) directly.
+    // `undefined` at the top level will be handled by the caller or become part of an object/array.
+    if (value === null || typeof value !== 'object') {
+        return value;
     }
 
-    // we have an object. we will create a new object and populate it.
-    const normalized = {};
+    // Handle Arrays: recursively normalize elements, preserve order
+    if (Array.isArray(value)) {
+        return value.map(element => toNormalizedForHashing(element));
+    }
 
-    // sort keys alphabetically
-    // NOTE: this does NOT mutate obj as Object.keys produces a new array
-    const keys = Object.keys(obj).sort();
+    // Handle Objects (plain objects)
+    const normalizedObject: { [key: string]: any } = {};
+    const sortedKeys = Object.keys(value).sort();
 
-    for (const key of keys) {
-        const value = obj[key];
-        if (value !== undefined) {
-            // Recursively normalize if the value is an object
-            normalized[key] = (typeof value === 'object' && value !== null) ? toNormalizedForHashing(value) : value;
+    for (const key of sortedKeys) {
+        const propertyValue = value[key];
+        if (propertyValue !== undefined) { // CRITICAL: Only omit if value is undefined
+            normalizedObject[key] = toNormalizedForHashing(propertyValue);
         }
+        // If propertyValue is undefined, it's omitted from normalizedObject.
+        // If propertyValue is null, it's included.
     }
-    return normalized;
+    return normalizedObject;
 }