@decohere/core 0.0.1-dev.116

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

@@ -0,0 +1,50 @@
+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

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

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

@@ -0,0 +1,24 @@
+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

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

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

@@ -0,0 +1,10 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function copyFile(src, dest, options = {}) {
+    if (options.mkdir) {
+        await fs.mkdir(path.dirname(dest), {
+            recursive: true
+        });
+    }
+    await fs.copyFile(src, dest);
+}

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

@@ -0,0 +1,6 @@
+import fs from "node:fs/promises";
+export async function deleteFile(filePath) {
+    return fs.rm(filePath, {
+        force: true
+    });
+}

package/es6/src/io/directory-exists.js

@@ -0,0 +1,9 @@
+import fs from "node:fs/promises";
+export async function directoryExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { stat } from "node:fs/promises";
+export async function fileExists(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isFile();
+    } catch  {
+        return false;
+    }
+}

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,27 @@
+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/index.js

@@ -0,0 +1,2 @@
+export * as io from "./io.js";
+export * from "./types/index.js";

package/es6/src/io/io.js

@@ -0,0 +1,11 @@
+export * from "./copy-file.js";
+export * from "./delete-file.js";
+export * from "./directory-exists.js";
+export * from "./file-exists.js";
+export * from "./find-directories.js";
+export * from "./find-file.js";
+export * from "./read-file.js";
+export * from "./remove-dir.js";
+export * from "./url-to-path.js";
+export * from "./watch.js";
+export * from "./write-file.js";

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

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises";
+export async function readFiles(filePaths, encoding = "utf8") {
+    const data = await Promise.all(filePaths.map((file)=>readFile(file.fullPath, encoding)));
+    return data;
+}
+export async function readFile(filePath, encoding = "utf8") {
+    const data = await fs.readFile(filePath, encoding);
+    return data;
+}
+export async function readJsonFile(filePath, encoding = "utf8") {
+    const data = await readFile(filePath, encoding);
+    return JSON.parse(data);
+}

package/es6/src/io/remove-dir.js

@@ -0,0 +1,7 @@
+import fs from "node:fs/promises";
+export async function removeDir(path, options = {
+    recursive: false,
+    force: false
+}) {
+    await fs.rm(path, options);
+}

package/es6/src/io/types/directory.type.js

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

package/es6/src/io/types/file.js

@@ -0,0 +1,18 @@
+import { readFile } from "../read-file.js";
+export class FileEx {
+    constructor(data){
+        this.fullPath = data.fullPath;
+        this.relativePath = data.relativePath ?? data.fullPath;
+        this.#content = data.content;
+    }
+    #content;
+    fullPath;
+    relativePath;
+    toString() {
+        return this.relativePath;
+    }
+    async getContent() {
+        if (this.#content != null) return this.#content;
+        return readFile(this.fullPath);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./directory.type.js";
+export * from "./file.js";

package/es6/src/io/url-to-path.js

@@ -0,0 +1,15 @@
+import { fileURLToPath, pathToFileURL } from "node:url";
+export const fileUrlToPath = (url)=>{
+    try {
+        return fileURLToPath(url);
+    } catch  {
+        return url;
+    }
+};
+export const pathToFileUrl = (path)=>{
+    try {
+        return pathToFileURL(path).toString();
+    } catch  {
+        return path;
+    }
+};

package/es6/src/io/watch.js

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

@@ -0,0 +1,15 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function writeFile(filePath, content, options = {
+    encoding: "utf8",
+    mkdir: false
+}) {
+    const { encoding, mkdir } = options;
+    if (mkdir) {
+        const directory = path.dirname(filePath);
+        await fs.mkdir(directory, {
+            recursive: true
+        });
+    }
+    await fs.writeFile(filePath, content, encoding);
+}

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

@@ -0,0 +1,57 @@
+// Source https://github.com/voodoocreation/ts-deepmerge/blob/master/package.json
+// 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;
+};
+export 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/es6/src/objects/index.js

@@ -0,0 +1 @@
+export { merge } from "./deep-merge.js";

package/es6/src/reflection/index.js

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export * from "./types/index.js";
+export * from "./utilities.js";

package/es6/src/reflection/types/index.js

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

package/es6/src/reflection/types/reflection.types.js

@@ -0,0 +1,8 @@
+export const MetaDataOwners = {
+    Hearth: "hearth",
+    Reflect: "design"
+};
+export const ReflectionMeta = {
+    paramtypes: `${MetaDataOwners.Reflect}:paramtypes`,
+    type: `${MetaDataOwners.Reflect}:type`
+};

package/es6/src/reflection/utilities.js

@@ -0,0 +1,74 @@
+import { ReflectionMeta } from "./types/reflection.types.js";
+const Primitives = [
+    "string",
+    "number",
+    "bigint",
+    "boolean",
+    "undefined",
+    "symbol",
+    "null"
+];
+export const isPrimitiveOrDateType = (type)=>{
+    return Primitives.includes(type.name.toLocaleLowerCase()) || isDateType(type);
+};
+export const isDateType = (type)=>{
+    return type?.prototype === Date.prototype;
+};
+export function isConstructable(type) {
+    const proto = type?.prototype;
+    const isConstructable = typeof type === "function" && typeof proto === "object";
+    return isConstructable;
+}
+export const isArrayType = (type)=>{
+    return type?.prototype === Array.prototype;
+};
+export function getMeta(key, target, propertyKey) {
+    const meta = Reflect.getMetadata(key, target, propertyKey);
+    return meta;
+}
+export function getFunctions(object) {
+    const functions = Object.entries(Object.getOwnPropertyDescriptors(object.prototype)).filter(([key])=>key !== "constructor").map(([, value])=>value);
+    return functions;
+}
+export function getFunction(object, functionName) {
+    const [, value] = Object.entries(Object.getOwnPropertyDescriptors(object.prototype)).find(([k])=>k !== "constructor" && k === functionName);
+    return value;
+}
+export function getFunctionMetadata(key, target, func) {
+    const meta = Reflect.getMetadata(key, target, func.name);
+    return meta;
+}
+export function getFunctionArgs(target, func) {
+    const meta = getFunctionMetadata(ReflectionMeta.paramtypes, target, func);
+    return meta;
+}
+/**
+ * @description Gets the fields from an object
+ * @param object
+ * @returns
+ */ export function getFields(object) {
+    const fields = Object.entries(Object.getOwnPropertyDescriptors(object)).filter(([, val])=>typeof val.value !== "function").map(([key, propertyDescriptor])=>({
+            key,
+            propertyDescriptor
+        }));
+    return fields;
+}
+export function getFieldType(target, fieldName) {
+    return Reflect.getMetadata(ReflectionMeta.type, target, fieldName);
+}
+export function getArgumentMeta(key, target, argIndex) {
+    const meta = Reflect.getMetadata(key, target, argIndex.toString());
+    return meta;
+}
+export function defineMeta(key, value, target) {
+    Reflect.defineMetadata(key, value, target);
+}
+/**
+ * @description Facade function to define metadata for a function argument
+ * @param key
+ * @param value
+ * @param func
+ * @param argIndex
+ */ export function defineArgumentMeta(key, value, func, argIndex) {
+    Reflect.defineMetadata(key, value, func, argIndex.toString());
+}

package/es6/src/semver/index.js

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