@unrift/core 0.0.0 → 0.2.1

package/dist/esm/utils/compareEngine.js

@@ -0,0 +1,222 @@
+import { isObjectLike, isPrimitive, isTypedArray, sameValue, } from "./helpers.js";
+export function compareInternal(left, right, options, leftToRightSeen, rightToLeftSeen) {
+    const worklist = [[left, right]];
+    while (worklist.length) {
+        const [currentLeft, currentRight] = worklist.pop();
+        if (sameValue(currentLeft, currentRight))
+            continue;
+        if (typeof currentLeft !== typeof currentRight)
+            return false;
+        if (isPrimitive(currentLeft) || isPrimitive(currentRight))
+            return false;
+        if (!isObjectLike(currentLeft) || !isObjectLike(currentRight))
+            return false;
+        const leftObj = currentLeft;
+        const rightObj = currentRight;
+        // Cycle detection
+        const mappedRight = leftToRightSeen.get(leftObj);
+        if (mappedRight !== undefined) {
+            if (mappedRight !== rightObj)
+                return false;
+            continue;
+        }
+        if (options.bijectiveCycleCheck && rightToLeftSeen) {
+            const mappedLeft = rightToLeftSeen.get(rightObj);
+            if (mappedLeft !== undefined) {
+                if (mappedLeft !== leftObj)
+                    return false;
+                continue;
+            }
+            rightToLeftSeen.set(rightObj, leftObj);
+        }
+        leftToRightSeen.set(leftObj, rightObj);
+        // Arrays
+        const leftIsArray = Array.isArray(currentLeft);
+        const rightIsArray = Array.isArray(currentRight);
+        if (leftIsArray || rightIsArray) {
+            if (!leftIsArray || !rightIsArray)
+                return false;
+            const leftArr = currentLeft;
+            const rightArr = currentRight;
+            if (leftArr.length !== rightArr.length)
+                return false;
+            for (let index = 0; index < leftArr.length; index++) {
+                if (options.treatSparseAsUndefined) {
+                    const leftValue = Object.hasOwn(leftArr, index)
+                        ? leftArr[index]
+                        : undefined;
+                    const rightValue = Object.hasOwn(rightArr, index)
+                        ? rightArr[index]
+                        : undefined;
+                    worklist.push([leftValue, rightValue]);
+                }
+                else {
+                    worklist.push([leftArr[index], rightArr[index]]);
+                }
+            }
+            continue;
+        }
+        // Typed arrays
+        const leftIsTyped = isTypedArray(currentLeft);
+        const rightIsTyped = isTypedArray(currentRight);
+        if (leftIsTyped || rightIsTyped) {
+            if (!leftIsTyped || !rightIsTyped)
+                return false;
+            const leftTA = currentLeft;
+            const rightTA = currentRight;
+            if (leftTA.constructor !== rightTA.constructor)
+                return false;
+            if (leftTA.length !== rightTA.length)
+                return false;
+            for (let index = 0; index < leftTA.length; index++) {
+                if (!sameValue(leftTA[index], rightTA[index]))
+                    return false;
+            }
+            continue;
+        }
+        // ArrayBuffer
+        const leftIsBuffer = currentLeft instanceof ArrayBuffer;
+        const rightIsBuffer = currentRight instanceof ArrayBuffer;
+        if (leftIsBuffer || rightIsBuffer) {
+            if (!leftIsBuffer || !rightIsBuffer)
+                return false;
+            const leftBuf = currentLeft;
+            const rightBuf = currentRight;
+            if (leftBuf.byteLength !== rightBuf.byteLength)
+                return false;
+            const leftBytes = new Uint8Array(leftBuf);
+            const rightBytes = new Uint8Array(rightBuf);
+            for (let index = 0; index < leftBytes.length; index++) {
+                if (leftBytes[index] !== rightBytes[index])
+                    return false;
+            }
+            continue;
+        }
+        // DataView
+        const leftIsView = currentLeft instanceof DataView;
+        const rightIsView = currentRight instanceof DataView;
+        if (leftIsView || rightIsView) {
+            if (!leftIsView || !rightIsView)
+                return false;
+            const leftView = currentLeft;
+            const rightView = currentRight;
+            if (leftView.byteLength !== rightView.byteLength)
+                return false;
+            for (let offset = 0; offset < leftView.byteLength; offset++) {
+                if (leftView.getUint8(offset) !== rightView.getUint8(offset))
+                    return false;
+            }
+            continue;
+        }
+        // Date
+        const leftIsDate = currentLeft instanceof Date;
+        const rightIsDate = currentRight instanceof Date;
+        if (leftIsDate || rightIsDate) {
+            if (!leftIsDate || !rightIsDate)
+                return false;
+            if (currentLeft.getTime() !== currentRight.getTime())
+                return false;
+            continue;
+        }
+        // RegExp
+        const leftIsRegExp = currentLeft instanceof RegExp;
+        const rightIsRegExp = currentRight instanceof RegExp;
+        if (leftIsRegExp || rightIsRegExp) {
+            if (!leftIsRegExp || !rightIsRegExp)
+                return false;
+            const leftRe = currentLeft;
+            const rightRe = currentRight;
+            if (leftRe.source !== rightRe.source)
+                return false;
+            if (leftRe.flags !== rightRe.flags)
+                return false;
+            continue;
+        }
+        // Set (order-insensitive)
+        const leftIsSet = currentLeft instanceof Set;
+        const rightIsSet = currentRight instanceof Set;
+        if (leftIsSet || rightIsSet) {
+            if (!leftIsSet || !rightIsSet)
+                return false;
+            const leftSet = currentLeft;
+            const rightSet = currentRight;
+            if (leftSet.size !== rightSet.size)
+                return false;
+            const remaining = new Set(rightSet);
+            outer: for (const leftValue of leftSet) {
+                for (const rightValue of remaining) {
+                    if (compareInternal(leftValue, rightValue, options, leftToRightSeen, rightToLeftSeen)) {
+                        remaining.delete(rightValue);
+                        continue outer;
+                    }
+                }
+                return false;
+            }
+            continue;
+        }
+        // Map (order-insensitive)
+        const leftIsMap = currentLeft instanceof Map;
+        const rightIsMap = currentRight instanceof Map;
+        if (leftIsMap || rightIsMap) {
+            if (!leftIsMap || !rightIsMap)
+                return false;
+            const leftMap = currentLeft;
+            const rightMap = currentRight;
+            if (leftMap.size !== rightMap.size)
+                return false;
+            const remainingEntries = new Set(rightMap.entries());
+            outer: for (const [leftKey, leftValue] of leftMap.entries()) {
+                for (const candidate of remainingEntries) {
+                    const [rightKey, rightValue] = candidate;
+                    if (compareInternal(leftKey, rightKey, options, leftToRightSeen, rightToLeftSeen) &&
+                        compareInternal(leftValue, rightValue, options, leftToRightSeen, rightToLeftSeen)) {
+                        remainingEntries.delete(candidate);
+                        continue outer;
+                    }
+                }
+                return false;
+            }
+            continue;
+        }
+        // Fallback: plain objects / custom class instances
+        if (options.checkPrototype) {
+            // Prototype-sensitive (deepEqual)
+            const leftProto = Object.getPrototypeOf(currentLeft);
+            const rightProto = Object.getPrototypeOf(currentRight);
+            if (leftProto !== rightProto)
+                return false;
+            const leftKeys = Object.keys(currentLeft);
+            const rightKeys = Object.keys(currentRight);
+            if (leftKeys.length !== rightKeys.length)
+                return false;
+            const leftRecord = currentLeft;
+            const rightRecord = currentRight;
+            for (let i = 0; i < leftKeys.length; i++) {
+                const key = leftKeys[i];
+                if (!Object.hasOwn(rightRecord, key))
+                    return false;
+                worklist.push([leftRecord[key], rightRecord[key]]);
+            }
+        }
+        else {
+            // Prototype-insensitive (looseEqual) — union-of-keys, missing ≈ undefined
+            const leftKeys = Object.keys(currentLeft);
+            const rightKeys = Object.keys(currentRight);
+            const allKeys = new Set([...leftKeys, ...rightKeys]);
+            const leftRecord = currentLeft;
+            const rightRecord = currentRight;
+            for (const key of allKeys) {
+                const leftHasKey = Object.hasOwn(leftRecord, key);
+                const rightHasKey = Object.hasOwn(rightRecord, key);
+                const leftValue = leftHasKey ? leftRecord[key] : undefined;
+                const rightValue = rightHasKey ? rightRecord[key] : undefined;
+                if (leftHasKey !== rightHasKey) {
+                    if (leftValue !== undefined || rightValue !== undefined)
+                        return false;
+                }
+                worklist.push([leftValue, rightValue]);
+            }
+        }
+    }
+    return true;
+}

package/dist/esm/utils/deepEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/deepEqual.ts"],"names":[],"mappings":"AA+OA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAShD"}
+{"version":3,"file":"deepEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/deepEqual.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAkBhD"}

package/dist/esm/utils/deepEqual.js

@@ -1,187 +1,5 @@
-import { isObjectLike, isPrimitive, isTypedArray, sameValue, } from "./helpers.js";
-function deepEqualInternal(left, right, leftToRightSeen) {
-    const worklist = [[left, right]];
-    while (worklist.length) {
-        const [currentLeft, currentRight] = worklist.pop();
-        if (sameValue(currentLeft, currentRight))
-            continue;
-        // Types must match at this point
-        if (typeof currentLeft !== typeof currentRight)
-            return false;
-        // Primitive mismatch - we already handled equality above
-        if (isPrimitive(currentLeft) || isPrimitive(currentRight))
-            return false;
-        // Functions, etc. – only ever equal by reference, which we've already checked
-        if (!isObjectLike(currentLeft) || !isObjectLike(currentRight))
-            return false;
-        const leftObj = currentLeft;
-        const rightObj = currentRight;
-        // Cycle detection: require consistent mapping for left-side objects
-        const previouslyMappedRight = leftToRightSeen.get(leftObj);
-        if (previouslyMappedRight !== undefined) {
-            if (previouslyMappedRight !== rightObj)
-                return false;
-            continue;
-        }
-        leftToRightSeen.set(leftObj, rightObj);
-        // Arrays - prototype-sensitive handled by prototype check later
-        const leftIsArray = Array.isArray(currentLeft);
-        const rightIsArray = Array.isArray(currentRight);
-        if (leftIsArray || rightIsArray) {
-            if (!leftIsArray || !rightIsArray)
-                return false;
-            const leftArr = currentLeft;
-            const rightArr = currentRight;
-            if (leftArr.length !== rightArr.length)
-                return false;
-            // Preserve sparseness by reading indexed values directly.
-            for (let index = 0; index < leftArr.length; index++) {
-                worklist.push([leftArr[index], rightArr[index]]);
-            }
-            continue;
-        }
-        // Typed arrays
-        const leftIsTyped = isTypedArray(currentLeft);
-        const rightIsTyped = isTypedArray(currentRight);
-        if (leftIsTyped || rightIsTyped) {
-            if (!leftIsTyped || !rightIsTyped)
-                return false;
-            const leftTA = currentLeft;
-            const rightTA = currentRight;
-            if (leftTA.constructor !== rightTA.constructor)
-                return false;
-            if (leftTA.length !== rightTA.length)
-                return false;
-            for (let index = 0; index < leftTA.length; index++) {
-                if (!sameValue(leftTA[index], rightTA[index]))
-                    return false;
-            }
-            continue;
-        }
-        // ArrayBuffer
-        const leftIsBuffer = currentLeft instanceof ArrayBuffer;
-        const rightIsBuffer = currentRight instanceof ArrayBuffer;
-        if (leftIsBuffer || rightIsBuffer) {
-            if (!leftIsBuffer || !rightIsBuffer)
-                return false;
-            const leftBuf = currentLeft;
-            const rightBuf = currentRight;
-            if (leftBuf.byteLength !== rightBuf.byteLength)
-                return false;
-            const leftBytes = new Uint8Array(leftBuf);
-            const rightBytes = new Uint8Array(rightBuf);
-            for (let index = 0; index < leftBytes.length; index++) {
-                if (leftBytes[index] !== rightBytes[index])
-                    return false;
-            }
-            continue;
-        }
-        // DataView
-        const leftIsView = currentLeft instanceof DataView;
-        const rightIsView = currentRight instanceof DataView;
-        if (leftIsView || rightIsView) {
-            if (!leftIsView || !rightIsView)
-                return false;
-            const leftView = currentLeft;
-            const rightView = currentRight;
-            if (leftView.byteLength !== rightView.byteLength)
-                return false;
-            for (let offset = 0; offset < leftView.byteLength; offset++) {
-                if (leftView.getUint8(offset) !== rightView.getUint8(offset))
-                    return false;
-            }
-            continue;
-        }
-        // Date
-        const leftIsDate = currentLeft instanceof Date;
-        const rightIsDate = currentRight instanceof Date;
-        if (leftIsDate || rightIsDate) {
-            if (!leftIsDate || !rightIsDate)
-                return false;
-            if (currentLeft.getTime() !== currentRight.getTime())
-                return false;
-            continue;
-        }
-        // RegExp
-        const leftIsRegExp = currentLeft instanceof RegExp;
-        const rightIsRegExp = currentRight instanceof RegExp;
-        if (leftIsRegExp || rightIsRegExp) {
-            if (!leftIsRegExp || !rightIsRegExp)
-                return false;
-            const leftRe = currentLeft;
-            const rightRe = currentRight;
-            if (leftRe.source !== rightRe.source)
-                return false;
-            if (leftRe.flags !== rightRe.flags)
-                return false;
-            continue;
-        }
-        // Set
-        const leftIsSet = currentLeft instanceof Set;
-        const rightIsSet = currentRight instanceof Set;
-        if (leftIsSet || rightIsSet) {
-            if (!leftIsSet || !rightIsSet)
-                return false;
-            const leftSet = currentLeft;
-            const rightSet = currentRight;
-            if (leftSet.size !== rightSet.size)
-                return false;
-            const unmatchedRightValues = new Set(rightSet);
-            outer: for (const leftValue of leftSet) {
-                for (const rightValue of unmatchedRightValues) {
-                    if (deepEqualInternal(leftValue, rightValue, leftToRightSeen)) {
-                        unmatchedRightValues.delete(rightValue);
-                        continue outer;
-                    }
-                }
-                return false;
-            }
-            continue;
-        }
-        // Map
-        const leftIsMap = currentLeft instanceof Map;
-        const rightIsMap = currentRight instanceof Map;
-        if (leftIsMap || rightIsMap) {
-            if (!leftIsMap || !rightIsMap)
-                return false;
-            const leftMap = currentLeft;
-            const rightMap = currentRight;
-            if (leftMap.size !== rightMap.size)
-                return false;
-            const unmatchedRightEntries = new Set(rightMap.entries());
-            outer: for (const [leftKey, leftValue] of leftMap.entries()) {
-                for (const candidate of unmatchedRightEntries) {
-                    const [rightKey, rightValue] = candidate;
-                    if (deepEqualInternal(leftKey, rightKey, leftToRightSeen) &&
-                        deepEqualInternal(leftValue, rightValue, leftToRightSeen)) {
-                        unmatchedRightEntries.delete(candidate);
-                        continue outer;
-                    }
-                }
-                return false;
-            }
-            continue;
-        }
-        // Fallback: plain objects / custom class instances (prototype-sensitive)
-        const leftProto = Object.getPrototypeOf(currentLeft);
-        const rightProto = Object.getPrototypeOf(currentRight);
-        if (leftProto !== rightProto)
-            return false;
-        const leftKeys = Object.keys(currentLeft);
-        const rightKeys = Object.keys(currentRight);
-        if (leftKeys.length !== rightKeys.length)
-            return false;
-        const leftRecord = currentLeft;
-        const rightRecord = currentRight;
-        for (let i = 0; i < leftKeys.length; i++) {
-            const key = leftKeys[i];
-            if (!Object.hasOwn(rightRecord, key))
-                return false;
-            worklist.push([leftRecord[key], rightRecord[key]]);
-        }
-    }
-    return true;
-}
+import { isObjectLike, isPrimitive, sameValue } from "./helpers.js";
+import { compareInternal } from "./compareEngine.js";
 /**
  * Deep structural equality with:
  * - Value semantics for primitives (+ NaN equal, +0/-0 equal)
@@ -197,5 +15,9 @@ export function deepEqual(a, b) {
         return false;
     if (!isObjectLike(a) || !isObjectLike(b))
         return false;
-    return deepEqualInternal(a, b, new WeakMap());
+    return compareInternal(a, b, {
+        checkPrototype: true,
+        treatSparseAsUndefined: false,
+        bijectiveCycleCheck: false,
+    }, new WeakMap());
 }

package/dist/esm/utils/diff.d.ts

@@ -0,0 +1,2 @@
+export declare function formatDiff(received: unknown, expected: unknown): string;
+//# sourceMappingURL=diff.d.ts.map

package/dist/esm/utils/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/utils/diff.ts"],"names":[],"mappings":"AA2EA,wBAAgB,UAAU,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CA6BvE"}

package/dist/esm/utils/diff.js

@@ -0,0 +1,84 @@
+import { colors } from "./colors.js";
+function formatValue(value, indent = 2) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (typeof value === "bigint")
+        return `${value}n`;
+    if (typeof value === "symbol")
+        return value.toString();
+    if (typeof value === "function")
+        return `[Function: ${value.name || "anonymous"}]`;
+    if (value instanceof Date)
+        return `Date(${value.toISOString()})`;
+    if (value instanceof RegExp)
+        return String(value);
+    if (value instanceof Error)
+        return `${value.name}: ${value.message}`;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        const padding = " ".repeat(indent);
+        const items = value.map((v) => `${padding}${formatValue(v, indent + 2)}`);
+        return `[\n${items.join(",\n")}\n${" ".repeat(indent - 2)}]`;
+    }
+    if (typeof value === "object") {
+        const keys = Object.keys(value);
+        if (keys.length === 0)
+            return "{}";
+        const padding = " ".repeat(indent);
+        const entries = keys.map((k) => `${padding}${k}: ${formatValue(value[k], indent + 2)}`);
+        return `{\n${entries.join(",\n")}\n${" ".repeat(indent - 2)}}`;
+    }
+    return String(value);
+}
+function diffObjects(received, expected) {
+    const allKeys = new Set([...Object.keys(received), ...Object.keys(expected)]);
+    const lines = [];
+    for (const key of allKeys) {
+        const inReceived = Object.hasOwn(received, key);
+        const inExpected = Object.hasOwn(expected, key);
+        if (inReceived && inExpected) {
+            const rv = formatValue(received[key]);
+            const ev = formatValue(expected[key]);
+            if (rv !== ev) {
+                lines.push(colors.red(`  - ${key}: ${rv}`));
+                lines.push(colors.green(`  + ${key}: ${ev}`));
+            }
+            else {
+                lines.push(`    ${key}: ${rv}`);
+            }
+        }
+        else if (inReceived) {
+            lines.push(colors.red(`  - ${key}: ${formatValue(received[key])}`));
+        }
+        else {
+            lines.push(colors.green(`  + ${key}: ${formatValue(expected[key])}`));
+        }
+    }
+    return lines.join("\n");
+}
+export function formatDiff(received, expected) {
+    // For objects, provide a structural diff
+    if (received !== null &&
+        expected !== null &&
+        typeof received === "object" &&
+        typeof expected === "object" &&
+        !Array.isArray(received) &&
+        !Array.isArray(expected) &&
+        !(received instanceof Date) &&
+        !(expected instanceof Date) &&
+        !(received instanceof RegExp) &&
+        !(expected instanceof RegExp)) {
+        const diff = diffObjects(received, expected);
+        return (`\n${colors.red("- Received")} / ${colors.green("+ Expected")}\n\n` + diff);
+    }
+    // Default: simple received/expected display
+    return (`\n  ${colors.red("Received:")} ${formatValue(received)}` +
+        `\n  ${colors.green("Expected:")} ${formatValue(expected)}`);
+}

package/dist/esm/utils/discoverTestFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discoverTestFiles.d.ts","sourceRoot":"","sources":["../../../src/utils/discoverTestFiles.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAqBvD"}
+{"version":3,"file":"discoverTestFiles.d.ts","sourceRoot":"","sources":["../../../src/utils/discoverTestFiles.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAqCvD"}

package/dist/esm/utils/discoverTestFiles.js

@@ -1,7 +1,7 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 export function isTestFileName(name) {
-    return /\.(spec|test)\.(ts|js)$/.test(name);
+    return /\.(spec|test)\.(ts|js|mts|cts|tsx|jsx|mjs|cjs)$/.test(name);
 }
 export function discoverTestFiles(dir) {
     if (!existsSync(dir))
@@ -10,6 +10,21 @@ export function discoverTestFiles(dir) {
     const files = [];
     for (const entry of entries) {
         const fullPath = join(dir, entry.name);
+        if (entry.isSymbolicLink()) {
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    files.push(...discoverTestFiles(fullPath));
+                }
+                else if (stat.isFile() && isTestFileName(entry.name)) {
+                    files.push(fullPath);
+                }
+            }
+            catch {
+                // Broken symlink — skip silently
+            }
+            continue;
+        }
         if (entry.isDirectory()) {
             files.push(...discoverTestFiles(fullPath));
             continue;

package/dist/esm/utils/looseEqual.d.ts

@@ -1,2 +1,11 @@
+/**
+ * Loose structural equality with:
+ * - Value semantics for primitives (+ NaN equal, +0/-0 equal)
+ * - Prototype-insensitive object comparison
+ * - Sparse array holes treated as undefined
+ * - Missing keys ≈ undefined (union-of-keys approach)
+ * - Bidirectional cycle tracking
+ * - Order-insensitive Set/Map comparison
+ */
 export declare function looseEqual<T>(left: T, right: T): boolean;
 //# sourceMappingURL=looseEqual.d.ts.map

package/dist/esm/utils/looseEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"looseEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/looseEqual.ts"],"names":[],"mappings":"AAuRA,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAWxD"}
+{"version":3,"file":"looseEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/looseEqual.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAgBxD"}