utilitish 0.0.7 → 0.0.8

package/dist/array/array-constructor.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface ArrayConstructor {
         /**
@@ -97,3 +96,4 @@ declare global {
 }
 type MultiDimensionalArray<T, Dims extends number[]> = Dims extends [number, ...infer Rest extends number[]] ? MultiDimensionalArray<T[], Rest> : T;
 type WidenLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+export {};

package/dist/array/array-prototype.d.ts

@@ -1,5 +1,4 @@
 import { Selector } from '../utils/core.utils';
-export {};
 declare global {
     interface Array<T> {
         /**

package/dist/map/map-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Map<K, V> {
         /**
@@ -83,3 +82,4 @@ declare global {
         ensureArray<L extends Array<any>>(this: Map<K, L>, key: K): L;
     }
 }
+export {};

package/dist/object/object-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Object {
         /**
@@ -71,5 +70,44 @@ declare global {
          * - null and undefined are handled correctly
          */
         deepEquals(other: unknown): boolean;
+        /**
+         * Converts the object to a stable string representation with sorted keys.
+         * The resulting string is deterministic: the same object will always produce the same string.
+         *
+         * @returns {string} A stable string representation of the object
+         *
+         * @example
+         * const obj = { b: 2, a: 1 };
+         * obj.stableStringify(); // '{"a":1,"b":2}'
+         *
+         * const obj2 = { a: 1, b: 2 };
+         * obj2.stableStringify(); // '{"a":1,"b":2}' (same result, different key order)
+         *
+         * @remarks
+         * - Object keys are sorted alphabetically to ensure stable output
+         * - Arrays maintain their element order
+         * - Null and primitives are handled using JSON.stringify
+         */
+        stableStringify(): string;
+        /**
+         * Generates a stable hash of the object using FNV-1a algorithm.
+         * The hash is deterministic: the same object will always produce the same hash.
+         *
+         * @returns {string} A hexadecimal string representing the hash of the object
+         *
+         * @example
+         * const obj = { b: 2, a: 1 };
+         * obj.stableHash(); // '7a8c9f2b'
+         *
+         * const obj2 = { a: 1, b: 2 };
+         * obj2.stableHash(); // '7a8c9f2b' (same hash, different key order)
+         *
+         * @remarks
+         * - Uses FNV-1a (Fowler–Noll–Vo) hashing algorithm
+         * - The object is first converted to a stable string using stableStringify()
+         * - The hash is returned as a hexadecimal string
+         */
+        stableHash(): string;
     }
 }
+export {};

package/dist/object/object-prototype.js

@@ -1,26 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const defineIfNotExists = (name, fn) => {
-    const descriptor = Object.getOwnPropertyDescriptor(Object.prototype, name);
-    if (!descriptor || descriptor.writable || descriptor.configurable) {
-        Object.defineProperty(Object.prototype, name, {
-            value: fn,
-            enumerable: false,
-            configurable: true,
-            writable: true,
-        });
-    }
-};
+const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Object.prototype.deepClone
  */
-defineIfNotExists('deepClone', function () {
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepClone', function () {
     return structuredClone(this);
 });
 /**
  * @see Object.prototype.deepMerge
  */
-defineIfNotExists('deepMerge', function (source) {
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepMerge', function (source) {
     if (typeof source !== 'object' || source === null) {
         throw new TypeError('Source must be a non-null object');
     }
@@ -43,7 +33,7 @@ defineIfNotExists('deepMerge', function (source) {
 /**
  * @see Object.prototype.deepEquals
  */
-defineIfNotExists('deepEquals', function (other) {
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepEquals', function (other) {
     function eq(a, b) {
         // Functions: always false (even if code is the same)
         if (typeof a === 'function' || typeof b === 'function') {
@@ -95,3 +85,33 @@ defineIfNotExists('deepEquals', function (other) {
     }
     return eq(this, other);
 });
+/**
+ * @see Object.prototype.stableStringify
+ */
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'stableStringify', function () {
+    const stringify = (v) => {
+        if (v === null || typeof v !== 'object') {
+            return JSON.stringify(v);
+        }
+        if (Array.isArray(v)) {
+            return '[' + v.map(stringify).join(',') + ']';
+        }
+        const obj = v;
+        const keys = Object.keys(obj).sort();
+        const entries = keys.map((key) => JSON.stringify(key) + ':' + stringify(obj[key]));
+        return '{' + entries.join(',') + '}';
+    };
+    return stringify(this);
+});
+/**
+ * @see Object.prototype.stableHash
+ */
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'stableHash', function () {
+    const str = this.stableStringify();
+    let hash = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+});

package/dist/object/object-prototype.spec.js

@@ -107,4 +107,78 @@ describe('Object.prototype', () => {
             });
         });
     });
+    describe('stableStringify()', () => {
+        it('should stringify plain objects with sorted keys', () => {
+            const obj = { b: 2, a: 1 };
+            expect(obj.stableStringify()).toBe('{"a":1,"b":2}');
+        });
+        it('should produce same string regardless of key order', () => {
+            const obj1 = { b: 2, a: 1, c: 3 };
+            const obj2 = { c: 3, a: 1, b: 2 };
+            expect(obj1.stableStringify()).toBe(obj2.stableStringify());
+        });
+        it('should stringify arrays with element order preserved', () => {
+            const arr = [1, 2, 3];
+            expect(arr.stableStringify()).toBe('[1,2,3]');
+        });
+        it('should handle nested objects', () => {
+            const obj = { b: { d: 4, c: 3 }, a: 1 };
+            expect(obj.stableStringify()).toBe('{"a":1,"b":{"c":3,"d":4}}');
+        });
+        it('should handle arrays within objects', () => {
+            const obj = { a: [1, 2], b: 2 };
+            expect(obj.stableStringify()).toBe('{"a":[1,2],"b":2}');
+        });
+        it('should handle empty objects and arrays', () => {
+            expect({}.stableStringify()).toBe('{}');
+            expect([].stableStringify()).toBe('[]');
+        });
+        it('should handle undefined values in objects', () => {
+            const obj = { a: undefined, b: 1 };
+            expect(obj.stableStringify()).toBe('{"a":undefined,"b":1}');
+        });
+    });
+    describe('stableHash()', () => {
+        it('should generate same hash for objects with different key order', () => {
+            const obj1 = { b: 2, a: 1 };
+            const obj2 = { a: 1, b: 2 };
+            expect(obj1.stableHash()).toBe(obj2.stableHash());
+        });
+        it('should generate different hashes for different objects', () => {
+            const obj1 = { a: 1, b: 2 };
+            const obj2 = { a: 1, b: 3 };
+            expect(obj1.stableHash()).not.toBe(obj2.stableHash());
+        });
+        it('should generate consistent hashes', () => {
+            const obj = { a: 1, b: 2 };
+            const hash1 = obj.stableHash();
+            const hash2 = obj.stableHash();
+            expect(hash1).toBe(hash2);
+        });
+        it('should generate hex string', () => {
+            const obj = { a: 1 };
+            const hash = obj.stableHash();
+            expect(/^[0-9a-f]+$/.test(hash)).toBe(true);
+        });
+        it('should handle arrays', () => {
+            const arr1 = [1, 2, 3];
+            const arr2 = [1, 2, 3];
+            expect(arr1.stableHash()).toBe(arr2.stableHash());
+        });
+        it('should handle different arrays', () => {
+            const arr1 = [1, 2, 3];
+            const arr2 = [3, 2, 1];
+            expect(arr1.stableHash()).not.toBe(arr2.stableHash());
+        });
+        it('should handle nested structures', () => {
+            const obj1 = { a: [1, { b: 2 }], c: 3 };
+            const obj2 = { c: 3, a: [1, { b: 2 }] };
+            expect(obj1.stableHash()).toBe(obj2.stableHash());
+        });
+        it('should handle empty objects', () => {
+            const obj1 = {};
+            const obj2 = {};
+            expect(obj1.stableHash()).toBe(obj2.stableHash());
+        });
+    });
 });

package/dist/set/set-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Set<T> {
         /**
@@ -103,3 +102,4 @@ declare global {
         intersection(...others: Set<T>[]): Set<T>;
     }
 }
+export {};

package/dist/string/string-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface String {
         /**
@@ -179,3 +178,4 @@ declare global {
         replaceRange(start: number, end: number, replaceString?: string): string;
     }
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utilitish",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",