@decohere/core 0.0.1-dev.118 → 0.0.1-dev.120

package/es6/src/interop/npm/npm.types.js

@@ -1,6 +0,0 @@
-export const VersionTypes = {
-    major: "major",
-    minor: "minor",
-    patch: "patch",
-    prerelease: "prerelease"
-};

package/es6/src/interop/pnpm/pnpm.js

@@ -1,24 +0,0 @@
-import { Shell } from "../shell/shell.js";
-const Commands = {
-    install: "install"
-};
-export class Pnpm extends Shell {
-    name = "pnpm";
-    program = "pnpm";
-    async install(options = {
-        cwd: "./"
-    }) {
-        const { cwd } = options;
-        return this.run({
-            cwd
-        }, Commands.install);
-    }
-    async syncLockFile(options = {
-        cwd: "./"
-    }) {
-        const { cwd } = options;
-        return this.run({
-            cwd
-        }, Commands.install, "--lockfile-only", "--ignore-scripts");
-    }
-}

package/es6/src/interop/pnpm/pnpm.types.js

@@ -1 +0,0 @@
-export { };

package/es6/src/interop/shell/shell.argv.js

@@ -1,35 +0,0 @@
-function fields(args) {
-    const positional = [];
-    const flags = {};
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
-        if (arg === "--") {
-            positional.push(...args.slice(i + 1));
-            break;
-        }
-        if (arg.startsWith("--")) {
-            const body = arg.slice(2);
-            const eq = body.indexOf("=");
-            if (eq !== -1) {
-                flags[body.slice(0, eq)] = body.slice(eq + 1);
-                continue;
-            }
-            const next = args[i + 1];
-            if (next != null && !next.startsWith("-")) {
-                flags[body] = next;
-                i += 1;
-            } else {
-                flags[body] = true;
-            }
-            continue;
-        }
-        positional.push(arg);
-    }
-    return {
-        _: positional,
-        ...flags
-    };
-}
-export const shellArgv = {
-    fields
-};

package/es6/src/interop/shell/shell.js

@@ -1,95 +0,0 @@
-import { spawn } from "node:child_process";
-import { scribe } from "@decohere/scribe";
-import { InteropError } from "../errors/interop.error.js";
-import { shellArgv } from "./shell.argv.js";
-export class Shell {
-    async run(options, ...args) {
-        const logger = scribe.logger(Shell.name);
-        const argv = args ?? [];
-        const argvFields = shellArgv.fields(argv);
-        const positionals = Array.isArray(argvFields._) ? argvFields._ : [];
-        const commandName = [
-            this.program,
-            ...positionals
-        ].join(" ").trim();
-        logger.info("Running", {
-            program: this.program,
-            args: argvFields
-        });
-        return new Promise((resolve, reject)=>{
-            let settled = false;
-            const resolveOnce = (response)=>{
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                resolve(response);
-            };
-            const rejectOnce = (error)=>{
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                reject(error);
-            };
-            const { cwd, env } = options;
-            const spawnOpt = {
-                cwd: cwd ?? ".",
-                stdio: [
-                    "inherit",
-                    "pipe",
-                    "pipe"
-                ],
-                env: env ?? {
-                    ...process.env
-                }
-            };
-            const proc = spawn(this.program, argv, spawnOpt);
-            const responseData = [];
-            const errorData = [];
-            proc.on("close", (code, signal)=>{
-                if (code === 0) {
-                    resolveOnce({
-                        message: `${commandName} completed`,
-                        data: responseData
-                    });
-                    return;
-                }
-                const stderr = errorData.join("\n").trim();
-                const stdout = responseData.join("\n").trim();
-                const exitCodeText = code == null ? "unknown" : String(code);
-                const signalText = signal ? ` signal ${signal}` : "";
-                const base = `Running '${commandName}' failed with code ${exitCodeText}${signalText}`;
-                const details = [
-                    stderr ? `stderr:\n${stderr}` : "",
-                    !stderr && stdout ? `stdout:\n${stdout}` : ""
-                ].filter(Boolean).join("\n");
-                rejectOnce(new InteropError(details ? `${base}\n${details}` : base));
-            });
-            proc.on("error", (err)=>{
-                rejectOnce(err);
-            });
-            proc.stdout.on("error", (err)=>{
-                rejectOnce(err);
-            });
-            proc.stdout.on("data", (data)=>{
-                const lines = this.parseStream(data);
-                console.log(data.toString());
-                responseData.push(...lines);
-            });
-            proc.stderr?.on("error", (err)=>{
-                rejectOnce(err);
-            });
-            proc.stderr?.on("data", (data)=>{
-                const lines = this.parseStream(data);
-                console.error(data.toString());
-                errorData.push(...lines);
-            });
-        });
-    }
-    parseStream(data) {
-        const dataStr = data.toString();
-        const lines = dataStr.split("\n").filter((l)=>l !== "");
-        return lines;
-    }
-}

package/es6/src/interop/shell/shell.types.js

@@ -1 +0,0 @@
-export { };

package/es6/src/interop/types/detect-package-manager.js

@@ -1,50 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { createInterface } from "node:readline/promises";
-import { Npm } from "../npm/npm.js";
-import { Pnpm } from "../pnpm/pnpm.js";
-import { Yarn } from "../yarn/yarn.js";
-const LOCKFILES = [
-    [
-        "pnpm-lock.yaml",
-        ()=>new Pnpm()
-    ],
-    [
-        "yarn.lock",
-        ()=>new Yarn()
-    ],
-    [
-        "package-lock.json",
-        ()=>new Npm()
-    ]
-];
-function fromLockfile(cwd) {
-    for (const [file, factory] of LOCKFILES){
-        if (existsSync(join(cwd, file))) return factory();
-    }
-    return undefined;
-}
-function fromUserAgent() {
-    const agent = process.env.npm_config_user_agent ?? "";
-    if (agent.startsWith("pnpm")) return new Pnpm();
-    if (agent.startsWith("yarn")) return new Yarn();
-    if (agent.startsWith("npm")) return new Npm();
-    return undefined;
-}
-export function detectPackageManager(cwd) {
-    return fromLockfile(cwd) ?? fromUserAgent();
-}
-export function packageManagerFromString(name) {
-    if (name === "yarn") return new Yarn();
-    if (name === "npm") return new Npm();
-    return new Pnpm();
-}
-export async function promptForPackageManager() {
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    const answer = await rl.question("Package manager? [pnpm/yarn/npm] (default: pnpm): ");
-    rl.close();
-    return packageManagerFromString(answer.trim().toLowerCase());
-}

package/es6/src/interop/types/package-manager.js

@@ -1 +0,0 @@
-export { };

package/es6/src/interop/yarn/yarn.js

@@ -1,24 +0,0 @@
-import { Shell } from "../shell/shell.js";
-const Commands = {
-    install: "install"
-};
-export class Yarn extends Shell {
-    name = "yarn";
-    program = "yarn";
-    async install(options = {
-        cwd: "./"
-    }) {
-        const { cwd } = options;
-        return this.run({
-            cwd
-        }, Commands.install);
-    }
-    async syncLockFile(options = {
-        cwd: "./"
-    }) {
-        const { cwd } = options;
-        return this.run({
-            cwd
-        }, Commands.install, "--mode", "update-lockfile", "--ignore-scripts");
-    }
-}

package/es6/src/interop/yarn/yarn.types.js

@@ -1 +0,0 @@
-export { };

package/es6/src/io/find-directories.js

@@ -1,11 +0,0 @@
-import { glob } from "glob";
-export async function findDirectories(...pattern) {
-    const paths = await glob(pattern, {
-        withFileTypes: true
-    });
-    const dirs = paths.filter((p)=>p.isDirectory()).map((p)=>({
-            name: p.name,
-            parentPath: p.parentPath
-        }));
-    return dirs;
-}

package/es6/src/io/find-file.js

@@ -1,27 +0,0 @@
-import { glob } from "glob";
-import { FileEx } from "./types/file.js";
-export async function findFile(pattern) {
-    const files = await glob(pattern, {
-        includeChildMatches: false
-    });
-    if (files.length === 0) {
-        return;
-    }
-    const file = {
-        relativePath: files.at(0)
-    };
-    return file;
-}
-export async function findFiles(patterns, options) {
-    const paths = await glob(patterns, {
-        ...options,
-        withFileTypes: true
-    });
-    const files = paths.filter((p)=>p.isFile()).map((p)=>{
-        return new FileEx({
-            relativePath: p.relative(),
-            fullPath: p.fullpath()
-        });
-    });
-    return files;
-}

package/es6/src/io/watch.js

@@ -1,238 +0,0 @@
-import { watch as nativeWatch, readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import picomatch from "picomatch";
-import { FileEx } from "./types/file.js";
-export const WatchEvents = {
-    add: "add",
-    change: "change",
-    addDir: "addDir",
-    unlink: "unlink",
-    unlinkDir: "unlinkDir"
-};
-export function watch(directory, options = {
-    cwd: "."
-}) {
-    const { include, ignore, ignoreInitial = false } = options;
-    const changeCoalesceMs = 25;
-    const handlers = {
-        ready: new Set(),
-        add: new Set(),
-        change: new Set(),
-        addDir: new Set(),
-        unlink: new Set(),
-        unlinkDir: new Set()
-    };
-    let resolveReady;
-    const ready = new Promise((resolve)=>{
-        resolveReady = resolve;
-    });
-    const snapshot = buildSnapshot(directory);
-    const isFiltered = (relativePath)=>{
-        const posixRelativePath = toPosixPath(relativePath);
-        const posixFullPath = toPosixPath(path.resolve(directory, relativePath));
-        const matchesEitherPath = (patterns)=>picomatch.isMatch(posixRelativePath, patterns) || picomatch.isMatch(posixFullPath, patterns);
-        if (include && include.length > 0) {
-            return !matchesEitherPath(include);
-        }
-        if (ignore && ignore.length > 0) {
-            return matchesEitherPath(ignore);
-        }
-        return false;
-    };
-    const emit = (event, relativePath)=>{
-        if (isFiltered(relativePath)) {
-            return;
-        }
-        const fullPath = path.resolve(directory, relativePath);
-        for (const handler of handlers[event]){
-            handler(new FileEx({
-                fullPath,
-                relativePath
-            }));
-        }
-    };
-    const pendingChangeTimers = new Map();
-    const emitChange = (relativePath)=>{
-        const existing = pendingChangeTimers.get(relativePath);
-        if (existing != null) {
-            clearTimeout(existing);
-        }
-        const timer = setTimeout(()=>{
-            pendingChangeTimers.delete(relativePath);
-            emit("change", relativePath);
-        }, changeCoalesceMs);
-        pendingChangeTimers.set(relativePath, timer);
-    };
-    const emitReady = ()=>{
-        for (const handler of handlers.ready){
-            handler();
-        }
-    };
-    queueMicrotask(()=>{
-        if (!ignoreInitial) {
-            for (const [relativePath, entry] of snapshot){
-                emit(entry.isDirectory ? "addDir" : "add", relativePath);
-            }
-        }
-        emitReady();
-        resolveReady?.();
-        resolveReady = undefined;
-    });
-    // One non-recursive watcher per directory. Node's recursive mode on Linux tracks files
-    // individually and goes silent for a file once an editor replaces it with an atomic save
-    // (write temp file, rename over the original); directory watchers keep seeing it (#505).
-    const directoryWatchers = new Map();
-    const watchDirectory = (relativeDir)=>{
-        if (directoryWatchers.has(relativeDir)) {
-            return;
-        }
-        try {
-            const watcher = nativeWatch(path.resolve(directory, relativeDir), (_eventType, fileName)=>{
-                if (fileName != null) {
-                    onFsEvent(path.posix.join(relativeDir, toPosixPath(fileName.toString())));
-                }
-            });
-            watcher.on("error", ()=>unwatchDirectory(relativeDir));
-            directoryWatchers.set(relativeDir, watcher);
-        } catch  {
-        // The directory vanished before we could watch it; its unlink event covers it.
-        }
-    };
-    const unwatchDirectory = (relativeDir)=>{
-        for (const [watchedDir, watcher] of directoryWatchers){
-            if (watchedDir === relativeDir || watchedDir.startsWith(`${relativeDir}/`)) {
-                watcher.close();
-                directoryWatchers.delete(watchedDir);
-            }
-        }
-    };
-    /** A directory appeared: watch it, and report what was created in it before we were watching. */ const addDirectory = (relativeDir)=>{
-        watchDirectory(relativeDir);
-        const found = new Map();
-        try {
-            collectSnapshotEntries(directory, path.resolve(directory, relativeDir), found);
-        } catch  {
-            return;
-        }
-        for (const [relativePath, entry] of found){
-            if (snapshot.has(relativePath)) continue;
-            snapshot.set(relativePath, entry);
-            if (entry.isDirectory) watchDirectory(relativePath);
-            emit(entry.isDirectory ? "addDir" : "add", relativePath);
-        }
-    };
-    /** A directory went away: stop watching it and forget everything that was under it. */ const removeDirectoryContents = (relativeDir)=>{
-        unwatchDirectory(relativeDir);
-        // oxlint-disable-next-line unicorn/no-useless-spread -- iterate a copy: the loop deletes from the snapshot
-        for (const [relativePath, entry] of [
-            ...snapshot
-        ]){
-            if (relativePath.startsWith(`${relativeDir}/`)) {
-                snapshot.delete(relativePath);
-                emit(entry.isDirectory ? "unlinkDir" : "unlink", relativePath);
-            }
-        }
-    };
-    const onFsEvent = (eventPath)=>{
-        const relativePath = eventPath === "." ? "" : eventPath;
-        if (relativePath.length === 0) {
-            return;
-        }
-        const fullPath = path.resolve(directory, relativePath);
-        const previous = snapshot.get(relativePath);
-        try {
-            const stat = statSync(fullPath);
-            const current = toSnapshotEntry(stat);
-            snapshot.set(relativePath, current);
-            if (previous == null) {
-                emit(current.isDirectory ? "addDir" : "add", relativePath);
-                if (current.isDirectory) addDirectory(relativePath);
-                return;
-            }
-            if (previous.isDirectory !== current.isDirectory) {
-                if (previous.isDirectory) removeDirectoryContents(relativePath);
-                emit(previous.isDirectory ? "unlinkDir" : "unlink", relativePath);
-                emit(current.isDirectory ? "addDir" : "add", relativePath);
-                return;
-            }
-            if (!current.isDirectory && previous.fingerprint !== current.fingerprint) {
-                emitChange(relativePath);
-            }
-        } catch  {
-            if (previous == null) {
-                return;
-            }
-            snapshot.delete(relativePath);
-            const pending = pendingChangeTimers.get(relativePath);
-            if (pending != null) {
-                clearTimeout(pending);
-                pendingChangeTimers.delete(relativePath);
-            }
-            emit(previous.isDirectory ? "unlinkDir" : "unlink", relativePath);
-        }
-    };
-    watchDirectory("");
-    for (const [relativePath, entry] of snapshot){
-        if (entry.isDirectory) watchDirectory(relativePath);
-    }
-    const watchApi = {
-        ready,
-        on (event, handler) {
-            if (event === "ready") {
-                handlers.ready.add(handler);
-                return watchApi;
-            }
-            handlers[event].add(handler);
-            return watchApi;
-        },
-        close: ()=>{
-            for (const pending of pendingChangeTimers.values()){
-                clearTimeout(pending);
-            }
-            pendingChangeTimers.clear();
-            for (const watcher of directoryWatchers.values()){
-                watcher.close();
-            }
-            directoryWatchers.clear();
-        }
-    };
-    return watchApi;
-}
-function buildSnapshot(directoryPath) {
-    const snapshot = new Map();
-    collectSnapshotEntries(directoryPath, directoryPath, snapshot);
-    return snapshot;
-}
-/** Never source, and huge: watching every folder inside them could exhaust OS watch limits. */ const UNWATCHED_DIRECTORIES = new Set([
-    "node_modules",
-    ".git"
-]);
-function collectSnapshotEntries(rootDirectoryPath, currentDirectoryPath, snapshot) {
-    for (const entry of readdirSync(currentDirectoryPath, {
-        encoding: "utf8"
-    })){
-        const name = typeof entry === "string" ? entry : String(entry);
-        const fullPath = path.join(currentDirectoryPath, name);
-        if (UNWATCHED_DIRECTORIES.has(name)) {
-            continue;
-        }
-        const relativePath = toPosixPath(path.relative(rootDirectoryPath, fullPath));
-        const stat = statSync(fullPath);
-        const snapshotEntry = toSnapshotEntry(stat);
-        snapshot.set(relativePath, snapshotEntry);
-        if (!snapshotEntry.isDirectory) {
-            continue;
-        }
-        collectSnapshotEntries(rootDirectoryPath, fullPath, snapshot);
-    }
-}
-function toSnapshotEntry(stat) {
-    const isDirectory = stat.isDirectory();
-    return {
-        isDirectory,
-        fingerprint: isDirectory ? `dir:${stat.mtimeMs}` : `file:${stat.mtimeMs}:${stat.size}`
-    };
-}
-function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
-}

package/es6/src/semver/index.js

@@ -1 +0,0 @@
-export * from "./semver.js";

package/es6/src/semver/semver.js

@@ -1,71 +0,0 @@
-export const VersionTypes = {
-    major: "major",
-    minor: "minor",
-    patch: "patch",
-    prerelease: "prerelease"
-};
-export class SemverError extends Error {
-    constructor(message){
-        super(message);
-        this.name = SemverError.name;
-    }
-}
-const SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
-export class Semver {
-    version;
-    constructor(version){
-        this.ensureValid(version);
-        this.version = version;
-    }
-    increment(versionType, preid = "pre") {
-        const { major, minor, patch, prerelease } = this.parse(this.version);
-        if (versionType === "major") {
-            this.version = `${major + 1}.0.0`;
-            return this;
-        }
-        if (versionType === "minor") {
-            this.version = `${major}.${minor + 1}.0`;
-            return this;
-        }
-        if (versionType === "patch") {
-            this.version = `${major}.${minor}.${patch + 1}`;
-            return this;
-        }
-        if (prerelease == null) {
-            this.version = `${major}.${minor}.${patch + 1}-${preid}.0`;
-            return this;
-        }
-        const [identifier, ...rest] = prerelease.split(".");
-        const maybeCounter = rest.at(-1);
-        const counter = maybeCounter != null ? Number.parseInt(maybeCounter, 10) : Number.NaN;
-        if (identifier === preid && Number.isFinite(counter)) {
-            const nextCounter = counter + 1;
-            const prefix = rest.length > 1 ? `${rest.slice(0, -1).join(".")}.` : "";
-            this.version = `${major}.${minor}.${patch}-${preid}.${prefix}${nextCounter}`;
-            return this;
-        }
-        this.version = `${major}.${minor}.${patch}-${preid}.0`;
-        return this;
-    }
-    toString() {
-        return this.version;
-    }
-    ensureValid(version) {
-        if (SEMVER_REGEX.test(version)) {
-            return;
-        }
-        throw new SemverError(`Invalid semantic version: ${version}`);
-    }
-    parse(version) {
-        const match = version.match(SEMVER_REGEX);
-        if (match == null) {
-            throw new SemverError(`Invalid semantic version: ${version}`);
-        }
-        return {
-            major: Number.parseInt(match[1], 10),
-            minor: Number.parseInt(match[2], 10),
-            patch: Number.parseInt(match[3], 10),
-            prerelease: match[4]
-        };
-    }
-}

package/es6/src/testing/flush-promises.js

@@ -1,6 +0,0 @@
-var scheduler = typeof setImmediate === "function" ? setImmediate : setTimeout;
-export function flushPromises() {
-    return new Promise((resolve)=>{
-        scheduler(resolve);
-    });
-}

package/es6/src/testing/glob-with-memfs.js

@@ -1,20 +0,0 @@
-import { fs } from "memfs";
-// Wraps a real `glob` module so all file-system access is routed through memfs.
-//
-// Why this exists:
-// - Integration tests often need real glob matching semantics.
-// - Vitest `vi.mock` factories are hoisted, so directly importing and patching
-//   `glob` inside helper modules can trigger initialization-order issues.
-// - Passing the already-loaded `actual` module keeps the helper pure and
-//   hoist-safe while still allowing us to inject memfs.
-export function withMemfsFsForGlob(actual) {
-    // Preserve all module exports, overriding only `glob` to force `{ fs: memfs }`.
-    const glob = (pattern, options)=>actual.glob(pattern, {
-            ...options,
-            fs
-        });
-    return {
-        ...actual,
-        glob
-    };
-}

package/es6/src/testing/index.js

@@ -1,5 +0,0 @@
-export * from "./flush-promises.js";
-export * from "./glob-with-memfs.js";
-export * from "./memfs.js";
-export * from "./mock-logger.js";
-export * from "./spy-on-constructor.js";

package/es6/src/testing/memfs.js

@@ -1,25 +0,0 @@
-import { fs, vol } from "memfs";
-export function resetMemfs() {
-    vol.reset();
-}
-export function seedMemfs(files) {
-    vol.fromJSON(files);
-}
-export function createTestFile(filePath, content) {
-    fs.mkdirSync(filePath.substring(0, filePath.lastIndexOf("/")), {
-        recursive: true
-    });
-    fs.writeFileSync(filePath, content);
-}
-export async function readFile(filePath) {
-    const response = await fs.promises.readFile(filePath, "utf8");
-    return response;
-}
-export function fileExists(filePath) {
-    try {
-        vol.statSync(filePath);
-        return true;
-    } catch  {
-        return false;
-    }
-}