@unrift/core 0.0.0 → 0.2.1

package/dist/esm/utils/looseEqual.js

@@ -1,199 +1,14 @@
-import { isObjectLike, isPrimitive, isTypedArray, sameValue, } from "./helpers.js";
-function looseEqualInternal(left, right, 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 / aliasing consistency (bijection-ish)
-        const mappedRight = leftToRightSeen.get(leftObj);
-        if (mappedRight !== undefined) {
-            if (mappedRight !== rightObj)
-                return false;
-            continue;
-        }
-        const mappedLeft = rightToLeftSeen.get(rightObj);
-        if (mappedLeft !== undefined) {
-            if (mappedLeft !== leftObj)
-                return false;
-            continue;
-        }
-        leftToRightSeen.set(leftObj, rightObj);
-        rightToLeftSeen.set(rightObj, leftObj);
-        // Arrays: sparse holes treated as undefined
-        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++) {
-                const leftValue = Object.hasOwn(leftArr, index)
-                    ? leftArr[index]
-                    : undefined;
-                const rightValue = Object.hasOwn(rightArr, index)
-                    ? rightArr[index]
-                    : undefined;
-                worklist.push([leftValue, rightValue]);
-            }
-            continue;
-        }
-        // Typed arrays
-        const leftIsTypedArray = isTypedArray(currentLeft);
-        const rightIsTypedArray = isTypedArray(currentRight);
-        if (leftIsTypedArray || rightIsTypedArray) {
-            if (!leftIsTypedArray || !rightIsTypedArray)
-                return false;
-            const leftTypedArray = currentLeft;
-            const rightTypedArray = currentRight;
-            if (leftTypedArray.constructor !== rightTypedArray.constructor)
-                return false;
-            if (leftTypedArray.length !== rightTypedArray.length)
-                return false;
-            for (let index = 0; index < leftTypedArray.length; index++) {
-                if (!sameValue(leftTypedArray[index], rightTypedArray[index]))
-                    return false;
-            }
-            continue;
-        }
-        // ArrayBuffer
-        const leftIsBuffer = currentLeft instanceof ArrayBuffer;
-        const rightIsBuffer = currentRight instanceof ArrayBuffer;
-        if (leftIsBuffer || rightIsBuffer) {
-            if (!leftIsBuffer || !rightIsBuffer)
-                return false;
-            const leftBuffer = currentLeft;
-            const rightBuffer = currentRight;
-            if (leftBuffer.byteLength !== rightBuffer.byteLength)
-                return false;
-            const leftBytes = new Uint8Array(leftBuffer);
-            const rightBytes = new Uint8Array(rightBuffer);
-            for (let index = 0; index < leftBytes.length; index++) {
-                if (leftBytes[index] !== rightBytes[index])
-                    return false;
-            }
-            continue;
-        }
-        // DataView
-        const leftIsDataView = currentLeft instanceof DataView;
-        const rightIsDataView = currentRight instanceof DataView;
-        if (leftIsDataView || rightIsDataView) {
-            if (!leftIsDataView || !rightIsDataView)
-                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 remainingRight = new Set(rightSet);
-            outer: for (const leftValue of leftSet) {
-                for (const rightValue of remainingRight) {
-                    if (looseEqualInternal(leftValue, rightValue, leftToRightSeen, rightToLeftSeen)) {
-                        remainingRight.delete(rightValue);
-                        continue outer;
-                    }
-                }
-                return false;
-            }
-            continue;
-        }
-        // Map (order-insensitive by entries; keys compared via looseEqual)
-        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 remainingRightEntries = new Set(rightMap.entries());
-            outer: for (const [leftKey, leftValue] of leftMap.entries()) {
-                for (const candidate of remainingRightEntries) {
-                    const [rightKey, rightValue] = candidate;
-                    if (looseEqualInternal(leftKey, rightKey, leftToRightSeen, rightToLeftSeen) &&
-                        looseEqualInternal(leftValue, rightValue, leftToRightSeen, rightToLeftSeen)) {
-                        remainingRightEntries.delete(candidate);
-                        continue outer;
-                    }
-                }
-                return false;
-            }
-            continue;
-        }
-        // Fallback: compare by enumerable shape (prototype-insensitive).
-        // Missing ≈ undefined via union-of-keys comparison.
-        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 one side is missing and the other side is present-but-not-undefined, fail.
-            if (leftHasKey !== rightHasKey) {
-                if (leftValue !== undefined || rightValue !== undefined)
-                    return false;
-            }
-            worklist.push([leftValue, rightValue]);
-        }
-    }
-    return true;
-}
+import { isObjectLike, isPrimitive, sameValue } from "./helpers.js";
+import { compareInternal } from "./compareEngine.js";
+/**
+ * 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 function looseEqual(left, right) {
     if (sameValue(left, right))
         return true;
@@ -201,5 +16,9 @@ export function looseEqual(left, right) {
         return false;
     if (!isObjectLike(left) || !isObjectLike(right))
         return false;
-    return looseEqualInternal(left, right, new WeakMap(), new WeakMap());
+    return compareInternal(left, right, {
+        checkPrototype: false,
+        treatSparseAsUndefined: true,
+        bijectiveCycleCheck: true,
+    }, new WeakMap(), new WeakMap());
 }

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

@@ -0,0 +1,2 @@
+export declare function normalizePath(p: string): string;
+//# sourceMappingURL=normalizePath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalizePath.d.ts","sourceRoot":"","sources":["../../../src/utils/normalizePath.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/C"}

package/dist/esm/utils/normalizePath.js

@@ -0,0 +1,4 @@
+export function normalizePath(p) {
+    // Stable for matching/reporting across platforms
+    return p.replace(/\\/g, "/");
+}

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

@@ -0,0 +1,2 @@
+export declare function toError(err: unknown): Error;
+//# sourceMappingURL=toError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toError.d.ts","sourceRoot":"","sources":["../../../src/utils/toError.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,CAE3C"}

package/dist/esm/utils/toError.js

@@ -0,0 +1,3 @@
+export function toError(err) {
+    return err instanceof Error ? err : new Error(String(err));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"toThrow.d.ts","sourceRoot":"","sources":["../../../src/utils/toThrow.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,MAAM,GACN,MAAM,GACN,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,GACnC;IAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB;AAgED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,OAAO,EACjB,QAAQ,CAAC,EAAE,eAAe,EAC1B,KAAK,UAAQ,GACZ,WAAW,CAgDb"}
+{"version":3,"file":"toThrow.d.ts","sourceRoot":"","sources":["../../../src/utils/toThrow.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,MAAM,GACN,MAAM,GACN,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,GACnC;IAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB;AAgED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,OAAO,EACjB,QAAQ,CAAC,EAAE,eAAe,EAC1B,KAAK,UAAQ,GACZ,WAAW,CAgEb"}

package/dist/esm/utils/toThrow.js

@@ -60,13 +60,24 @@ export function toThrow(received, expected, isNot = false) {
     }
     let threw = false;
     let thrown;
+    let result;
     try {
-        received();
+        result = received();
     }
     catch (e) {
         threw = true;
         thrown = e;
     }
+    if (!threw &&
+        result != null &&
+        typeof result.then === "function") {
+        // Suppress the unhandled rejection from the returned promise
+        result.catch(() => { });
+        return {
+            pass: false,
+            message: () => "toThrow() received an async function. Use expect(fn).rejects.toThrow() for async errors.",
+        };
+    }
     const matched = threw && matchThrown(thrown, expected);
     const pass = isNot ? !matched : matched;
     return {

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

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/utils/transform.ts"],"names":[],"mappings":"AAuIA,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAgBA;AAED,KAAK,IAAI,GAAG,eAAe,GAAG,aAAa,CAAC;AAqE5C,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,IAAoB,GACzB,MAAM,CAyDR"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/utils/transform.ts"],"names":[],"mappings":"AAuIA,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAgBA;AAED,KAAK,IAAI,GAAG,eAAe,GAAG,aAAa,CAAC;AAqE5C,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,IAAoB,GACzB,MAAM,CAwER"}

package/dist/esm/utils/transform.js

@@ -88,7 +88,7 @@ function projectNodeModulesCacheRoot(projectRoot) {
 }
 function tempCacheRootForProject(projectRoot) {
     const projectKey = hashString(resolve(projectRoot));
-    return getTmpCacheRoot(projectKey);
+    return join(os.tmpdir(), "unrift", projectKey);
 }
 function rmDirIfExists(dir) {
     try {
@@ -187,26 +187,36 @@ export function toImportUrl(filePath, mode = "bundle-test") {
     const outDir = cacheDirForMode(cacheRoot, mode);
     ensureDir(outDir);
     const outFile = cacheOutPath(outDir, filePath, hashStr);
-    buildSync({
-        entryPoints: [filePath],
-        outfile: outFile,
-        bundle: true,
-        format: "esm",
-        platform: "node",
-        target: "node18",
-        packages: "external",
-        external: ["@unrift/*", "@unrift/core", "@unrift/core/*"],
-        absWorkingDir: projectRoot,
-        inject: [resolveInjectedGlobals()],
-        define: {
-            __dirname: "injectedDirname",
-            __filename: "injectedFilename",
-            require: "injectedRequire",
-        },
-        sourcemap: "inline",
-        sourcesContent: true,
-        logLevel: "silent",
-    });
+    try {
+        buildSync({
+            entryPoints: [filePath],
+            outfile: outFile,
+            bundle: true,
+            format: "esm",
+            platform: "node",
+            target: "node18",
+            packages: "external",
+            external: ["@unrift/*", "@unrift/core", "@unrift/core/*"],
+            absWorkingDir: projectRoot,
+            inject: [resolveInjectedGlobals()],
+            define: {
+                __dirname: "injectedDirname",
+                __filename: "injectedFilename",
+                require: "injectedRequire",
+            },
+            sourcemap: "inline",
+            sourcesContent: true,
+            logLevel: "silent",
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("Cannot find module") ||
+            msg.includes("MODULE_NOT_FOUND")) {
+            throw new Error(`esbuild is required but could not be loaded. Run: npm install esbuild\n\nOriginal error: ${msg}`);
+        }
+        throw err;
+    }
     const outUrl = pathToFileURL(outFile).href;
     cache.set(key, { hash: hashStr, outUrl });
     return outUrl;

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@unrift/core",
-  "version": "0.0.0",
+  "version": "0.2.1",
   "description": "unrift core package",
   "private": false,
   "main": "./dist/cjs/index.cjs",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
   "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
   "files": [
     "dist",
     "bin"
@@ -29,12 +32,26 @@
   "bin": {
     "unrift": "./bin/unrift.mjs"
   },
-  "keywords": [],
+  "keywords": [
+    "testing",
+    "test",
+    "test-runner",
+    "typescript",
+    "javascript",
+    "esm",
+    "assert",
+    "expect",
+    "matchers"
+  ],
   "author": "elijah kotyluk <elijah@elijahkotyluk.com>",
   "repository": {
     "type": "git",
     "url": "https://github.com/elijahkotyluk/unrift"
   },
+  "bugs": {
+    "url": "https://github.com/elijahkotyluk/unrift/issues"
+  },
+  "homepage": "https://unrift.pages.dev",
   "license": "MIT",
   "dependencies": {
     "esbuild": "^0.27.2"
@@ -48,12 +65,13 @@
     "build:esm": "tsc -p tsconfig.build.esm.json && node scripts/patch-esm-extensions.js",
     "clean": "rm -rf ./dist",
     "compile": "tsc -p tsconfig.build.json && node scripts/patch-esm-extensions.js",
-    "test": "pnpm test:internal && pnpm test:fail && pnpm test:bail && pnpm test:only",
+    "test": "pnpm test:internal && pnpm test:fail && pnpm test:bail && pnpm test:only && pnpm test:todo && pnpm test:hooks",
     "test:bail": "node bin/unrift.mjs --config ./test/bail/unrift.outer.config.ts",
     "test:fail": "node bin/unrift.mjs --config ./test/fail/unrift.outer.config.ts",
     "test:hooks": "node bin/unrift.mjs --config ./test/hooks/unrift.outer.config.ts",
     "test:internal": "node bin/unrift.mjs --config ./test/internal/unrift.config.ts",
     "test:only": "node bin/unrift.mjs --config ./test/only/unrift.outer.config.ts",
+    "test:todo": "node bin/unrift.mjs --config ./test/todo/unrift.outer.config.ts",
     "test:publish": "pnpm clean && pnpm build && pnpm pack --pack-destination ./dist-pack",
     "typecheck": "tsc -p tsconfig.build.esm.json --noEmit"
   }