@decohere/core 0.0.1-dev.116

package/commonjs/src/io/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./directory.type.js"), exports);
+_export_star(require("./file.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/io/url-to-path.js

@@ -0,0 +1,33 @@
+"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 fileUrlToPath () {
+        return fileUrlToPath;
+    },
+    get pathToFileUrl () {
+        return pathToFileUrl;
+    }
+});
+const _nodeurl = require("node:url");
+const fileUrlToPath = (url)=>{
+    try {
+        return (0, _nodeurl.fileURLToPath)(url);
+    } catch  {
+        return url;
+    }
+};
+const pathToFileUrl = (path)=>{
+    try {
+        return (0, _nodeurl.pathToFileURL)(path).toString();
+    } catch  {
+        return path;
+    }
+};

package/commonjs/src/io/watch.js

@@ -0,0 +1,261 @@
+"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/io/write-file.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeFile", {
+    enumerable: true,
+    get: function() {
+        return writeFile;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function writeFile(filePath, content, options = {
+    encoding: "utf8",
+    mkdir: false
+}) {
+    const { encoding, mkdir } = options;
+    if (mkdir) {
+        const directory = _nodepath.default.dirname(filePath);
+        await _promises.default.mkdir(directory, {
+            recursive: true
+        });
+    }
+    await _promises.default.writeFile(filePath, content, encoding);
+}

package/commonjs/src/objects/deep-merge.js

@@ -0,0 +1,67 @@
+// Source https://github.com/voodoocreation/ts-deepmerge/blob/master/package.json
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "merge", {
+    enumerable: true,
+    get: function() {
+        return merge;
+    }
+});
+// istanbul ignore next
+const isObject = (obj)=>{
+    if (typeof obj === "object" && obj !== null) {
+        if (typeof Object.getPrototypeOf === "function") {
+            const prototype = Object.getPrototypeOf(obj);
+            return prototype === Object.prototype || prototype === null;
+        }
+        return Object.prototype.toString.call(obj) === "[object Object]";
+    }
+    return false;
+};
+const merge = (...objects)=>objects.reduce((result, current)=>{
+        if (current === undefined) {
+            return result;
+        }
+        if (Array.isArray(current)) {
+            throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
+        }
+        Object.keys(current).forEach((key)=>{
+            if ([
+                "__proto__",
+                "constructor",
+                "prototype"
+            ].includes(key)) {
+                return;
+            }
+            if (Array.isArray(result[key]) && Array.isArray(current[key])) {
+                result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [
+                    ...result[key],
+                    ...current[key]
+                ] : current[key];
+            } else if (isObject(result[key]) && isObject(current[key])) {
+                result[key] = merge(result[key], current[key]);
+            } else if (!isObject(result[key]) && isObject(current[key])) {
+                result[key] = merge(current[key], undefined);
+            } else {
+                result[key] = current[key] === undefined ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
+            }
+        });
+        return result;
+    }, {});
+const defaultOptions = {
+    allowUndefinedOverrides: true,
+    mergeArrays: true,
+    uniqueArrayItems: true
+};
+merge.options = defaultOptions;
+merge.withOptions = (options, ...objects)=>{
+    merge.options = {
+        ...defaultOptions,
+        ...options
+    };
+    const result = merge(...objects);
+    merge.options = defaultOptions;
+    return result;
+};

package/commonjs/src/objects/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "merge", {
+    enumerable: true,
+    get: function() {
+        return _deepmerge.merge;
+    }
+});
+const _deepmerge = require("./deep-merge.js");

package/commonjs/src/reflection/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("reflect-metadata");
+_export_star(require("./types/index.js"), exports);
+_export_star(require("./utilities.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/reflection/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./reflection.types.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/reflection/types/reflection.types.js

@@ -0,0 +1,26 @@
+"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 MetaDataOwners () {
+        return MetaDataOwners;
+    },
+    get ReflectionMeta () {
+        return ReflectionMeta;
+    }
+});
+const MetaDataOwners = {
+    Hearth: "hearth",
+    Reflect: "design"
+};
+const ReflectionMeta = {
+    paramtypes: `${MetaDataOwners.Reflect}:paramtypes`,
+    type: `${MetaDataOwners.Reflect}:type`
+};

package/commonjs/src/reflection/utilities.js

@@ -0,0 +1,118 @@
+"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 defineArgumentMeta () {
+        return defineArgumentMeta;
+    },
+    get defineMeta () {
+        return defineMeta;
+    },
+    get getArgumentMeta () {
+        return getArgumentMeta;
+    },
+    get getFieldType () {
+        return getFieldType;
+    },
+    get getFields () {
+        return getFields;
+    },
+    get getFunction () {
+        return getFunction;
+    },
+    get getFunctionArgs () {
+        return getFunctionArgs;
+    },
+    get getFunctionMetadata () {
+        return getFunctionMetadata;
+    },
+    get getFunctions () {
+        return getFunctions;
+    },
+    get getMeta () {
+        return getMeta;
+    },
+    get isArrayType () {
+        return isArrayType;
+    },
+    get isConstructable () {
+        return isConstructable;
+    },
+    get isDateType () {
+        return isDateType;
+    },
+    get isPrimitiveOrDateType () {
+        return isPrimitiveOrDateType;
+    }
+});
+const _reflectiontypes = require("./types/reflection.types.js");
+const Primitives = [
+    "string",
+    "number",
+    "bigint",
+    "boolean",
+    "undefined",
+    "symbol",
+    "null"
+];
+const isPrimitiveOrDateType = (type)=>{
+    return Primitives.includes(type.name.toLocaleLowerCase()) || isDateType(type);
+};
+const isDateType = (type)=>{
+    return type?.prototype === Date.prototype;
+};
+function isConstructable(type) {
+    const proto = type?.prototype;
+    const isConstructable = typeof type === "function" && typeof proto === "object";
+    return isConstructable;
+}
+const isArrayType = (type)=>{
+    return type?.prototype === Array.prototype;
+};
+function getMeta(key, target, propertyKey) {
+    const meta = Reflect.getMetadata(key, target, propertyKey);
+    return meta;
+}
+function getFunctions(object) {
+    const functions = Object.entries(Object.getOwnPropertyDescriptors(object.prototype)).filter(([key])=>key !== "constructor").map(([, value])=>value);
+    return functions;
+}
+function getFunction(object, functionName) {
+    const [, value] = Object.entries(Object.getOwnPropertyDescriptors(object.prototype)).find(([k])=>k !== "constructor" && k === functionName);
+    return value;
+}
+function getFunctionMetadata(key, target, func) {
+    const meta = Reflect.getMetadata(key, target, func.name);
+    return meta;
+}
+function getFunctionArgs(target, func) {
+    const meta = getFunctionMetadata(_reflectiontypes.ReflectionMeta.paramtypes, target, func);
+    return meta;
+}
+function getFields(object) {
+    const fields = Object.entries(Object.getOwnPropertyDescriptors(object)).filter(([, val])=>typeof val.value !== "function").map(([key, propertyDescriptor])=>({
+            key,
+            propertyDescriptor
+        }));
+    return fields;
+}
+function getFieldType(target, fieldName) {
+    return Reflect.getMetadata(_reflectiontypes.ReflectionMeta.type, target, fieldName);
+}
+function getArgumentMeta(key, target, argIndex) {
+    const meta = Reflect.getMetadata(key, target, argIndex.toString());
+    return meta;
+}
+function defineMeta(key, value, target) {
+    Reflect.defineMetadata(key, value, target);
+}
+function defineArgumentMeta(key, value, func, argIndex) {
+    Reflect.defineMetadata(key, value, func, argIndex.toString());
+}

package/commonjs/src/semver/index.js

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