@unrift/core 0.0.0

package/dist/esm/utils/toThrow.js

@@ -0,0 +1,93 @@
+function isErrorConstructor(err) {
+    return typeof err === "function";
+}
+function formatThrown(thrown) {
+    if (thrown instanceof Error) {
+        const name = thrown.name || "Error";
+        const msg = thrown.message ?? "";
+        return msg ? `${name}: ${msg}` : name;
+    }
+    try {
+        return typeof thrown === "string" ? thrown : JSON.stringify(thrown);
+    }
+    catch {
+        return String(thrown);
+    }
+}
+function matchThrown(thrown, expected) {
+    if (expected === undefined)
+        return true;
+    const msg = thrown instanceof Error ? thrown.message : String(thrown);
+    // toThrow("substring")
+    if (typeof expected === "string") {
+        return msg.includes(expected);
+    }
+    // toThrow(/regex/)
+    if (expected instanceof RegExp) {
+        return expected.test(msg);
+    }
+    // toThrow(ErrorClass)
+    if (isErrorConstructor(expected)) {
+        return thrown instanceof expected;
+    }
+    // toThrow({ name?, message? })
+    if (expected && typeof expected === "object") {
+        if (expected.name) {
+            const thrownName = thrown instanceof Error ? thrown.name : undefined;
+            if (thrownName !== expected.name)
+                return false;
+        }
+        if (expected.message !== undefined) {
+            if (typeof expected.message === "string") {
+                if (!msg.includes(expected.message))
+                    return false;
+            }
+            else {
+                if (!expected.message.test(msg))
+                    return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+export function toThrow(received, expected, isNot = false) {
+    if (typeof received !== "function") {
+        return {
+            pass: false,
+            message: () => `toThrow() expects a function as the received value, but got ${typeof received}.`,
+        };
+    }
+    let threw = false;
+    let thrown;
+    try {
+        received();
+    }
+    catch (e) {
+        threw = true;
+        thrown = e;
+    }
+    const matched = threw && matchThrown(thrown, expected);
+    const pass = isNot ? !matched : matched;
+    return {
+        pass,
+        message: () => {
+            const expectation = isNot ? "not to throw" : "to throw";
+            if (!threw) {
+                return `Expected function ${expectation}, but it did not throw.`;
+            }
+            const thrownStr = formatThrown(thrown);
+            if (expected === undefined) {
+                return `Expected function ${expectation}, but it threw: ${thrownStr}`;
+            }
+            const expectedStr = typeof expected === "string"
+                ? `"${expected}"`
+                : expected instanceof RegExp
+                    ? expected.toString()
+                    : isErrorConstructor(expected)
+                        ? expected.name || "[AnonymousErrorConstructor]"
+                        : JSON.stringify(expected);
+            return `Expected function ${expectation} ${expectedStr}, but it threw: ${thrownStr}`;
+        },
+    };
+}

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

@@ -0,0 +1,10 @@
+export declare function cleanUnriftCaches(projectRoot: string): {
+    projectCacheDir: string;
+    tempCacheDir: string;
+    projectCacheDeleted: boolean;
+    tempCacheDeleted: boolean;
+};
+type Mode = "bundle-config" | "bundle-test";
+export declare function toImportUrl(filePath: string, mode?: Mode): string;
+export {};
+//# sourceMappingURL=transform.d.ts.map

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

@@ -0,0 +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"}

package/dist/esm/utils/transform.js

@@ -0,0 +1,213 @@
+import { buildSync } from "esbuild";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, symlinkSync, lstatSync, realpathSync, rmSync, } from "node:fs";
+import os from "node:os";
+import { join, basename, extname, resolve, dirname, sep } from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+const injectedFilename = fileURLToPath(import.meta.url);
+const injectedDirname = dirname(injectedFilename);
+function resolveInjectedGlobals() {
+    return resolve(injectedDirname, "../injected/globals.js");
+}
+function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+}
+function hashString(input) {
+    return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function isTsLike(file) {
+    return (file.endsWith(".ts") ||
+        file.endsWith(".tsx") ||
+        file.endsWith(".mts") ||
+        file.endsWith(".cts"));
+}
+// Find the nearest package.json upward from a file’s folder
+function findProjectRoot(startDir) {
+    let dir = resolve(startDir);
+    while (true) {
+        if (existsSync(join(dir, "package.json")))
+            return dir;
+        const parent = resolve(dir, "..");
+        if (parent === dir)
+            return resolve(startDir);
+        dir = parent;
+    }
+}
+function readPackageName(projectRoot) {
+    try {
+        const raw = readFileSync(join(projectRoot, "package.json"), "utf8");
+        const json = JSON.parse(raw);
+        return typeof json.name === "string" ? json.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tryProjectCacheRoot(projectRoot) {
+    const nodeModulesCache = projectNodeModulesCacheRoot(projectRoot);
+    try {
+        ensureDir(nodeModulesCache);
+        return nodeModulesCache;
+    }
+    catch {
+        return null;
+    }
+}
+function getTmpCacheRoot(projectRoot) {
+    const projectKey = hashString(resolve(projectRoot));
+    const tmpCache = join(os.tmpdir(), "unrift", projectKey);
+    ensureDir(tmpCache);
+    return tmpCache;
+}
+function pathExists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// True if child is inside parent (after resolving symlinks when possible).
+function isSubpath(child, parent) {
+    const parentReal = safeRealpath(parent);
+    const childReal = safeRealpath(child);
+    const p = parentReal.endsWith(sep) ? parentReal : parentReal + sep;
+    return childReal === parentReal || childReal.startsWith(p);
+}
+function safeRealpath(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    }
+}
+function projectNodeModulesCacheRoot(projectRoot) {
+    return join(projectRoot, "node_modules", ".unrift", "cache");
+}
+function tempCacheRootForProject(projectRoot) {
+    const projectKey = hashString(resolve(projectRoot));
+    return getTmpCacheRoot(projectKey);
+}
+function rmDirIfExists(dir) {
+    try {
+        if (!existsSync(dir))
+            return false;
+        rmSync(dir, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        // Don’t fail test runs because cleanup failed
+        return false;
+    }
+}
+export function cleanUnriftCaches(projectRoot) {
+    const projectCacheDir = projectNodeModulesCacheRoot(projectRoot);
+    const tempCacheDir = tempCacheRootForProject(projectRoot);
+    const projectCacheDeleted = rmDirIfExists(projectCacheDir);
+    const tempCacheDeleted = rmDirIfExists(tempCacheDir);
+    // Clear in-memory cache
+    cache.clear();
+    return {
+        projectCacheDir,
+        tempCacheDir,
+        projectCacheDeleted,
+        tempCacheDeleted,
+    };
+}
+const cache = new Map();
+function cacheDirForMode(cacheRoot, mode) {
+    return join(cacheRoot, mode === "bundle-config" ? "config" : "tests");
+}
+function cacheOutPath(cacheDir, filePath, h) {
+    const base = basename(filePath, extname(filePath));
+    const pathHash = hashString(resolve(filePath));
+    return join(cacheDir, `${base}.${pathHash}.${h}.mjs`);
+}
+/**
+ * Create <cacheRoot>/node_modules/@unrift/core -> <projectRoot>
+ * so cached bundles can resolve @unrift/core when self-hosting.
+ */
+function ensureSelfLink(cacheRoot, projectRoot) {
+    // HARD SAFETY: never allow a self-link inside a cacheRoot that lives in the project
+    if (isSubpath(cacheRoot, projectRoot)) {
+        throw new Error(`Unrift internal: refusing to create self-host link because cacheRoot is inside projectRoot.\n` +
+            `cacheRoot: ${cacheRoot}\nprojectRoot: ${projectRoot}\n` +
+            `This would create a recursive directory cycle. Use temp cache for self-hosting.`);
+    }
+    const nodeModules = join(cacheRoot, "node_modules");
+    const scopeDir = join(nodeModules, "@unrift");
+    const linkPath = join(scopeDir, "core");
+    ensureDir(scopeDir);
+    if (pathExists(linkPath))
+        return;
+    const type = process.platform === "win32" ? "junction" : "dir";
+    symlinkSync(projectRoot, linkPath, type);
+}
+function pickCacheRoot(projectRoot, selfHost) {
+    const fromEnv = process.env.UNRIFT_CACHE_DIR;
+    if (fromEnv) {
+        const envPath = resolve(fromEnv);
+        // If self-hosting and env points inside project, ignore it to prevent cycles.
+        if (selfHost && isSubpath(envPath, projectRoot)) {
+            return getTmpCacheRoot(projectRoot);
+        }
+        return envPath;
+    }
+    // Normal users: prefer project-local cache
+    const projectCache = tryProjectCacheRoot(projectRoot);
+    // Self-host: need to avoid project-local cache if we need the self-link bridge
+    if (selfHost) {
+        return getTmpCacheRoot(projectRoot);
+    }
+    if (projectCache)
+        return projectCache;
+    return getTmpCacheRoot(projectRoot);
+}
+export function toImportUrl(filePath, mode = "bundle-test") {
+    if (!isTsLike(filePath))
+        return pathToFileURL(filePath).href;
+    const source = readFileSync(filePath, "utf8");
+    const hashStr = hashString(source);
+    const key = `${mode}:${filePath}`;
+    const existing = cache.get(key);
+    if (existing && existing.hash === hashStr)
+        return existing.outUrl;
+    const projectRoot = findProjectRoot(dirname(filePath));
+    const selfHost = readPackageName(projectRoot) === "@unrift/core";
+    const cacheRoot = pickCacheRoot(projectRoot, selfHost);
+    if (process.env.UNRIFT_DEBUG === "1") {
+        console.log("[unrift] cacheRoot:", cacheRoot, "selfHost:", selfHost);
+    }
+    // Only create the self-link in safe cache roots (temp/env outside project)
+    if (selfHost) {
+        ensureSelfLink(cacheRoot, projectRoot);
+    }
+    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",
+    });
+    const outUrl = pathToFileURL(outFile).href;
+    cache.set(key, { hash: hashStr, outUrl });
+    return outUrl;
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@unrift/core",
+  "version": "0.0.0",
+  "description": "unrift core package",
+  "private": false,
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs",
+      "types": "./dist/esm/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/esm/cli.js",
+      "types": "./dist/esm/cli.d.ts"
+    },
+    "./run": {
+      "import": "./dist/esm/run.js",
+      "types": "./dist/esm/run.d.ts"
+    }
+  },
+  "bin": {
+    "unrift": "./bin/unrift.mjs"
+  },
+  "keywords": [],
+  "author": "elijah kotyluk <elijah@elijahkotyluk.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elijahkotyluk/unrift"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "esbuild": "^0.27.2"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "pnpm build:esm && node scripts/write-cjs-shim.js",
+    "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: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:publish": "pnpm clean && pnpm build && pnpm pack --pack-destination ./dist-pack",
+    "typecheck": "tsc -p tsconfig.build.esm.json --noEmit"
+  }
+}