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

package/commonjs/src/io/watch.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get WatchEvents () {
-        return WatchEvents;
-    },
-    get watch () {
-        return watch;
-    }
-});
-const _nodefs = require("node:fs");
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _picomatch = /*#__PURE__*/ _interop_require_default(require("picomatch"));
-const _file = require("./types/file.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const WatchEvents = {
-    add: "add",
-    change: "change",
-    addDir: "addDir",
-    unlink: "unlink",
-    unlinkDir: "unlinkDir"
-};
-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(_nodepath.default.resolve(directory, relativePath));
-        const matchesEitherPath = (patterns)=>_picomatch.default.isMatch(posixRelativePath, patterns) || _picomatch.default.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 = _nodepath.default.resolve(directory, relativePath);
-        for (const handler of handlers[event]){
-            handler(new _file.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 = (0, _nodefs.watch)(_nodepath.default.resolve(directory, relativeDir), (_eventType, fileName)=>{
-                if (fileName != null) {
-                    onFsEvent(_nodepath.default.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, _nodepath.default.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 = _nodepath.default.resolve(directory, relativePath);
-        const previous = snapshot.get(relativePath);
-        try {
-            const stat = (0, _nodefs.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 (0, _nodefs.readdirSync)(currentDirectoryPath, {
-        encoding: "utf8"
-    })){
-        const name = typeof entry === "string" ? entry : String(entry);
-        const fullPath = _nodepath.default.join(currentDirectoryPath, name);
-        if (UNWATCHED_DIRECTORIES.has(name)) {
-            continue;
-        }
-        const relativePath = toPosixPath(_nodepath.default.relative(rootDirectoryPath, fullPath));
-        const stat = (0, _nodefs.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(_nodepath.default.sep).join(_nodepath.default.posix.sep);
-}

package/commonjs/src/semver/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./semver.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/semver/semver.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get Semver () {
-        return Semver;
-    },
-    get SemverError () {
-        return SemverError;
-    },
-    get VersionTypes () {
-        return VersionTypes;
-    }
-});
-const VersionTypes = {
-    major: "major",
-    minor: "minor",
-    patch: "patch",
-    prerelease: "prerelease"
-};
-class SemverError extends Error {
-    constructor(message){
-        super(message);
-        this.name = SemverError.name;
-    }
-}
-const SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
-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/commonjs/src/testing/flush-promises.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "flushPromises", {
-    enumerable: true,
-    get: function() {
-        return flushPromises;
-    }
-});
-var scheduler = typeof setImmediate === "function" ? setImmediate : setTimeout;
-function flushPromises() {
-    return new Promise((resolve)=>{
-        scheduler(resolve);
-    });
-}

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

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "withMemfsFsForGlob", {
-    enumerable: true,
-    get: function() {
-        return withMemfsFsForGlob;
-    }
-});
-const _memfs = require("memfs");
-function withMemfsFsForGlob(actual) {
-    // Preserve all module exports, overriding only `glob` to force `{ fs: memfs }`.
-    const glob = (pattern, options)=>actual.glob(pattern, {
-            ...options,
-            fs: _memfs.fs
-        });
-    return {
-        ...actual,
-        glob
-    };
-}

package/commonjs/src/testing/index.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./flush-promises.js"), exports);
-_export_star(require("./glob-with-memfs.js"), exports);
-_export_star(require("./memfs.js"), exports);
-_export_star(require("./mock-logger.js"), exports);
-_export_star(require("./spy-on-constructor.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/testing/memfs.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createTestFile () {
-        return createTestFile;
-    },
-    get fileExists () {
-        return fileExists;
-    },
-    get readFile () {
-        return readFile;
-    },
-    get resetMemfs () {
-        return resetMemfs;
-    },
-    get seedMemfs () {
-        return seedMemfs;
-    }
-});
-const _memfs = require("memfs");
-function resetMemfs() {
-    _memfs.vol.reset();
-}
-function seedMemfs(files) {
-    _memfs.vol.fromJSON(files);
-}
-function createTestFile(filePath, content) {
-    _memfs.fs.mkdirSync(filePath.substring(0, filePath.lastIndexOf("/")), {
-        recursive: true
-    });
-    _memfs.fs.writeFileSync(filePath, content);
-}
-async function readFile(filePath) {
-    const response = await _memfs.fs.promises.readFile(filePath, "utf8");
-    return response;
-}
-function fileExists(filePath) {
-    try {
-        _memfs.vol.statSync(filePath);
-        return true;
-    } catch  {
-        return false;
-    }
-}

package/commonjs/src/testing/mock-logger.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createMockLogger", {
-    enumerable: true,
-    get: function() {
-        return createMockLogger;
-    }
-});
-const _vitest = require("vitest");
-const DefaultLogLevels = {
-    fatal: 60,
-    error: 50,
-    warn: 40,
-    info: 30,
-    debug: 20,
-    trace: 10
-};
-function createMockLogger() {
-    return {
-        error: _vitest.vi.fn(),
-        info: _vitest.vi.fn(),
-        warn: _vitest.vi.fn(),
-        debug: _vitest.vi.fn(),
-        trace: _vitest.vi.fn(),
-        fatal: _vitest.vi.fn(),
-        isLevelEnabled: _vitest.vi.fn().mockReturnValue(true),
-        get currentLevel () {
-            return "info";
-        },
-        get logLevels () {
-            return DefaultLogLevels;
-        }
-    };
-}

package/commonjs/src/testing/spy-on-constructor.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "spyOnConstructor", {
-    enumerable: true,
-    get: function() {
-        return spyOnConstructor;
-    }
-});
-const _vitest = require("vitest");
-function spyOnConstructor(Target) {
-    const spy = _vitest.vi.fn();
-    const ProxiedTarget = new Proxy(Target, {
-        construct (Ctor, args) {
-            spy(...args);
-            return Reflect.construct(Ctor, args);
-        }
-    });
-    for (const key of Reflect.getMetadataKeys(Target)){
-        Reflect.defineMetadata(key, Reflect.getMetadata(key, Target), ProxiedTarget);
-    }
-    return {
-        spy,
-        Proxy: ProxiedTarget
-    };
-}

package/es6/src/caching/node-cache-memoize.adapter.js

@@ -1,37 +0,0 @@
-import NodeCache from "@cacheable/node-cache";
-/**
- * NodeCache adapter configured for memoization (useClones: false)
- * This allows storing object references instead of clones for true memoization
- */ export class NodeCacheAdapter {
-    static create(options = {
-        enableMemoization: false
-    }) {
-        const nodeCache = new NodeCache({
-            useClones: !options.enableMemoization
-        });
-        return new NodeCacheAdapter(nodeCache);
-    }
-    supportsMemoization = true;
-    cache;
-    constructor(inst = new NodeCache()){
-        this.cache = inst;
-    }
-    get isMemoize() {
-        return !this.cache.options.useClones;
-    }
-    get(key) {
-        return this.cache.get(key);
-    }
-    set(key, value) {
-        this.cache.set(key, value);
-    }
-    has(key) {
-        return this.cache.has(key);
-    }
-    del(key) {
-        this.cache.del(key);
-    }
-    flushAll() {
-        this.cache.flushAll();
-    }
-}

package/es6/src/cli/action.js

@@ -1,47 +0,0 @@
-export const ActionMap = Symbol("ActionMap");
-export class ActionResponse {
-    static Success(name, data) {
-        return new ActionResponse({
-            name,
-            data,
-            succeeded: true
-        });
-    }
-    static Skipped(name) {
-        return new ActionResponse({
-            name,
-            skipped: true
-        });
-    }
-    static Blocking(name) {
-        return new ActionResponse({
-            name,
-            succeeded: true,
-            blocking: true
-        });
-    }
-    static Error(name, messageOrData, data) {
-        if (Array.isArray(messageOrData)) {
-            const message = messageOrData.filter((r)=>!r.succeeded).map((r)=>r.error ?? "Unknown error").join("\n");
-            return new ActionResponse({
-                name,
-                message,
-                data: messageOrData
-            });
-        }
-        return new ActionResponse({
-            name,
-            message: messageOrData,
-            data
-        });
-    }
-    constructor(data){
-        Object.assign(this, data);
-    }
-    name;
-    succeeded = false;
-    skipped = false;
-    blocking = false;
-    message;
-    data;
-}