@decohere/core 0.0.1-dev.116

package/commonjs/src/interop/pnpm/pnpm.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Pnpm", {
+    enumerable: true,
+    get: function() {
+        return Pnpm;
+    }
+});
+const _shell = require("../shell/shell.js");
+const Commands = {
+    install: "install"
+};
+class Pnpm extends _shell.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/commonjs/src/interop/pnpm/pnpm.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "shellArgv", {
+    enumerable: true,
+    get: function() {
+        return shellArgv;
+    }
+});
+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
+    };
+}
+const shellArgv = {
+    fields
+};

package/commonjs/src/interop/shell/shell.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Shell", {
+    enumerable: true,
+    get: function() {
+        return Shell;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _scribe = require("@decohere/scribe");
+const _interoperror = require("../errors/interop.error.js");
+const _shellargv = require("./shell.argv.js");
+class Shell {
+    async run(options, ...args) {
+        const logger = _scribe.scribe.logger(Shell.name);
+        const argv = args ?? [];
+        const argvFields = _shellargv.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 = (0, _nodechild_process.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.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/commonjs/src/interop/shell/shell.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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

@@ -0,0 +1,71 @@
+"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 detectPackageManager () {
+        return detectPackageManager;
+    },
+    get packageManagerFromString () {
+        return packageManagerFromString;
+    },
+    get promptForPackageManager () {
+        return promptForPackageManager;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _promises = require("node:readline/promises");
+const _npm = require("../npm/npm.js");
+const _pnpm = require("../pnpm/pnpm.js");
+const _yarn = require("../yarn/yarn.js");
+const LOCKFILES = [
+    [
+        "pnpm-lock.yaml",
+        ()=>new _pnpm.Pnpm()
+    ],
+    [
+        "yarn.lock",
+        ()=>new _yarn.Yarn()
+    ],
+    [
+        "package-lock.json",
+        ()=>new _npm.Npm()
+    ]
+];
+function fromLockfile(cwd) {
+    for (const [file, factory] of LOCKFILES){
+        if ((0, _nodefs.existsSync)((0, _nodepath.join)(cwd, file))) return factory();
+    }
+    return undefined;
+}
+function fromUserAgent() {
+    const agent = process.env.npm_config_user_agent ?? "";
+    if (agent.startsWith("pnpm")) return new _pnpm.Pnpm();
+    if (agent.startsWith("yarn")) return new _yarn.Yarn();
+    if (agent.startsWith("npm")) return new _npm.Npm();
+    return undefined;
+}
+function detectPackageManager(cwd) {
+    return fromLockfile(cwd) ?? fromUserAgent();
+}
+function packageManagerFromString(name) {
+    if (name === "yarn") return new _yarn.Yarn();
+    if (name === "npm") return new _npm.Npm();
+    return new _pnpm.Pnpm();
+}
+async function promptForPackageManager() {
+    const rl = (0, _promises.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/commonjs/src/interop/types/package-manager.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/commonjs/src/interop/yarn/yarn.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Yarn", {
+    enumerable: true,
+    get: function() {
+        return Yarn;
+    }
+});
+const _shell = require("../shell/shell.js");
+const Commands = {
+    install: "install"
+};
+class Yarn extends _shell.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/commonjs/src/interop/yarn/yarn.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "copyFile", {
+    enumerable: true,
+    get: function() {
+        return copyFile;
+    }
+});
+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 copyFile(src, dest, options = {}) {
+    if (options.mkdir) {
+        await _promises.default.mkdir(_nodepath.default.dirname(dest), {
+            recursive: true
+        });
+    }
+    await _promises.default.copyFile(src, dest);
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "deleteFile", {
+    enumerable: true,
+    get: function() {
+        return deleteFile;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function deleteFile(filePath) {
+    return _promises.default.rm(filePath, {
+        force: true
+    });
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "directoryExists", {
+    enumerable: true,
+    get: function() {
+        return directoryExists;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function directoryExists(path) {
+    try {
+        await _promises.default.access(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fileExists", {
+    enumerable: true,
+    get: function() {
+        return fileExists;
+    }
+});
+const _promises = require("node:fs/promises");
+async function fileExists(path) {
+    try {
+        const stats = await (0, _promises.stat)(path);
+        return stats.isFile();
+    } catch  {
+        return false;
+    }
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findDirectories", {
+    enumerable: true,
+    get: function() {
+        return findDirectories;
+    }
+});
+const _glob = require("glob");
+async function findDirectories(...pattern) {
+    const paths = await (0, _glob.glob)(pattern, {
+        withFileTypes: true
+    });
+    const dirs = paths.filter((p)=>p.isDirectory()).map((p)=>({
+            name: p.name,
+            parentPath: p.parentPath
+        }));
+    return dirs;
+}

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

@@ -0,0 +1,45 @@
+"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 findFile () {
+        return findFile;
+    },
+    get findFiles () {
+        return findFiles;
+    }
+});
+const _glob = require("glob");
+const _file = require("./types/file.js");
+async function findFile(pattern) {
+    const files = await (0, _glob.glob)(pattern, {
+        includeChildMatches: false
+    });
+    if (files.length === 0) {
+        return;
+    }
+    const file = {
+        relativePath: files.at(0)
+    };
+    return file;
+}
+async function findFiles(patterns, options) {
+    const paths = await (0, _glob.glob)(patterns, {
+        ...options,
+        withFileTypes: true
+    });
+    const files = paths.filter((p)=>p.isFile()).map((p)=>{
+        return new _file.FileEx({
+            relativePath: p.relative(),
+            fullPath: p.fullpath()
+        });
+    });
+    return files;
+}

package/commonjs/src/io/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "io", {
+    enumerable: true,
+    get: function() {
+        return _io;
+    }
+});
+const _io = /*#__PURE__*/ _interop_require_wildcard(require("./io.js"));
+_export_star(require("./types/index.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;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}

package/commonjs/src/io/io.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./copy-file.js"), exports);
+_export_star(require("./delete-file.js"), exports);
+_export_star(require("./directory-exists.js"), exports);
+_export_star(require("./file-exists.js"), exports);
+_export_star(require("./find-directories.js"), exports);
+_export_star(require("./find-file.js"), exports);
+_export_star(require("./read-file.js"), exports);
+_export_star(require("./remove-dir.js"), exports);
+_export_star(require("./url-to-path.js"), exports);
+_export_star(require("./watch.js"), exports);
+_export_star(require("./write-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/read-file.js

@@ -0,0 +1,39 @@
+"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 readFile () {
+        return readFile;
+    },
+    get readFiles () {
+        return readFiles;
+    },
+    get readJsonFile () {
+        return readJsonFile;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function readFiles(filePaths, encoding = "utf8") {
+    const data = await Promise.all(filePaths.map((file)=>readFile(file.fullPath, encoding)));
+    return data;
+}
+async function readFile(filePath, encoding = "utf8") {
+    const data = await _promises.default.readFile(filePath, encoding);
+    return data;
+}
+async function readJsonFile(filePath, encoding = "utf8") {
+    const data = await readFile(filePath, encoding);
+    return JSON.parse(data);
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeDir", {
+    enumerable: true,
+    get: function() {
+        return removeDir;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function removeDir(path, options = {
+    recursive: false,
+    force: false
+}) {
+    await _promises.default.rm(path, options);
+}

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FileEx", {
+    enumerable: true,
+    get: function() {
+        return FileEx;
+    }
+});
+const _readfile = require("../read-file.js");
+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 (0, _readfile.readFile)(this.fullPath);
+    }
+}