@decohere/devkit 0.0.1-dev.119

package/commonjs/src/interop/git/git.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Git", {
+    enumerable: true,
+    get: function() {
+        return Git;
+    }
+});
+const _interoperror = require("../errors/interop.error.js");
+const _shell = require("../shell/shell.js");
+const Commands = {
+    stage: "stage",
+    tag: "tag",
+    add: "add",
+    commit: "commit",
+    push: "push",
+    listFiles: "ls-files"
+};
+const defaultOptions = {
+    cwd: "./"
+};
+class Git extends _shell.Shell {
+    program = "git";
+    async getModifiedFiles(options = defaultOptions) {
+        const args = [
+            Commands.listFiles,
+            "--modified"
+        ];
+        const { cwd } = options;
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result.data;
+    }
+    async getBranchName(options = defaultOptions) {
+        const { cwd } = options;
+        const args = [
+            "rev-parse",
+            "--symbolic-full-name",
+            "--abbrev-ref",
+            "HEAD"
+        ];
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result.data[0];
+    }
+    async tag(tag, options = defaultOptions) {
+        const args = [
+            Commands.tag,
+            tag
+        ];
+        const { cwd } = options;
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result;
+    }
+    async pushTag(tag, options = defaultOptions) {
+        const { cwd, remote = "origin" } = options;
+        const result = await this.run({
+            cwd
+        }, Commands.push, remote, tag);
+        return result;
+    }
+    async commit(message, options) {
+        const optionsAndDefaults = {
+            ...defaultOptions,
+            ...options
+        };
+        const { cwd, files = [], all } = optionsAndDefaults;
+        const args = [
+            Commands.commit
+        ];
+        if (files.length > 0 && all) {
+            throw new _interoperror.InteropError("Cannot commit all and files at the same time");
+        }
+        if (files.length > 0) {
+            await this.stage({
+                files
+            });
+        }
+        if (options.all) {
+            args.push("-a");
+        }
+        args.push("-m", message);
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result;
+    }
+    async push(branch, options) {
+        const optionsAndDefaults = {
+            ...defaultOptions,
+            ...options
+        };
+        const { cwd, setUpstream } = optionsAndDefaults;
+        const args = [
+            Commands.push
+        ];
+        args.push("--set-upstream", setUpstream ?? "origin");
+        args.push(branch);
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result;
+    }
+    async pull(branch, options = defaultOptions) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, "pull", "--rebase", "origin", branch);
+    }
+    async stage(options) {
+        const optionsAndDefaults = {
+            ...defaultOptions,
+            ...options
+        };
+        const { cwd, files = [], all } = optionsAndDefaults;
+        if (all) {
+            await this.run({
+                cwd
+            }, Commands.stage, "-a");
+            return;
+        }
+        for (const file of files){
+            await this.run({
+                cwd
+            }, Commands.stage, file);
+        }
+    }
+}

package/commonjs/src/interop/git/git.types.js

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

package/commonjs/src/interop/index.js

@@ -0,0 +1,97 @@
+// << Git >>
+// << Docker >>
+"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 git () {
+        return _gittypes;
+    },
+    get npm () {
+        return _npmtypes;
+    },
+    get pnpm () {
+        return _pnpmtypes;
+    },
+    get shell () {
+        return _shelltypes;
+    },
+    get yarn () {
+        return _yarntypes;
+    }
+});
+_export_star(require("./docker/docker.js"), exports);
+_export_star(require("./git/git.js"), exports);
+const _gittypes = /*#__PURE__*/ _interop_require_wildcard(require("./git/git.types.js"));
+_export_star(require("./node/node.js"), exports);
+_export_star(require("./npm/npm.js"), exports);
+const _npmtypes = /*#__PURE__*/ _interop_require_wildcard(require("./npm/npm.types.js"));
+_export_star(require("./pnpm/pnpm.js"), exports);
+const _pnpmtypes = /*#__PURE__*/ _interop_require_wildcard(require("./pnpm/pnpm.types.js"));
+_export_star(require("./shell/shell.js"), exports);
+const _shelltypes = /*#__PURE__*/ _interop_require_wildcard(require("./shell/shell.types.js"));
+_export_star(require("./types/detect-package-manager.js"), exports);
+_export_star(require("./types/package-manager.js"), exports);
+_export_star(require("./yarn/yarn.js"), exports);
+const _yarntypes = /*#__PURE__*/ _interop_require_wildcard(require("./yarn/yarn.types.js"));
+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/interop/node/index.js

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Node", {
+    enumerable: true,
+    get: function() {
+        return Node;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _shell = require("../shell/shell.js");
+class Node extends _shell.Shell {
+    program = "node";
+    async runScript(script, ...args) {
+        const spawnOpt = {
+            cwd: ".",
+            stdio: "inherit",
+            env: {
+                ...process.env
+            }
+        };
+        return new Promise((resolve, reject)=>{
+            const proc = (0, _nodechild_process.spawn)("node", [
+                script,
+                ...args
+            ], spawnOpt);
+            proc.on("exit", (code)=>{
+                if (code !== 0) {
+                    reject();
+                }
+                resolve(null);
+            });
+            proc.on("close", (code)=>{
+                resolve(null);
+                if (code === 0) {
+                    resolve({
+                        message: `${script} completed`
+                    });
+                }
+                reject(`Running '${script}' failed with code ${code}`);
+            });
+        });
+    }
+}

package/commonjs/src/interop/npm/npm.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Npm", {
+    enumerable: true,
+    get: function() {
+        return Npm;
+    }
+});
+const _interoperror = require("../errors/interop.error.js");
+const _shell = require("../shell/shell.js");
+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;
+}
+const Commands = {
+    publish: "publish",
+    version: "version",
+    link: "link",
+    install: "install"
+};
+class Npm extends _shell.Shell {
+    name = "npm";
+    program = "npm";
+    async publish(directory, options = {
+        channel: "beta"
+    }) {
+        const { cwd, dryRun, skipIfPublished, channel, authToken, otp, provenance } = options;
+        if (directory == null) {
+            throw new _interoperror.InteropError("Directory is required");
+        }
+        if (skipIfPublished && !dryRun) {
+            const alreadyPublished = await this.isPublished(directory, {
+                cwd
+            });
+            if (alreadyPublished) {
+                return {
+                    message: `Skipping publish — version already exists on registry`,
+                    data: []
+                };
+            }
+        }
+        const args = [
+            Commands.publish,
+            directory
+        ];
+        let tmpUserConfigPath;
+        args.push("--tag", channel ?? "beta");
+        if (provenance) {
+            args.push("--provenance");
+        }
+        // Explicit --token (local bootstrap). OIDC publish must not inherit cwd .npmrc / NODE_AUTH_TOKEN.
+        if (authToken?.trim()) {
+            tmpUserConfigPath = await this.createTempUserConfig(authToken.trim());
+            args.push("--userconfig", tmpUserConfigPath);
+        }
+        if (dryRun) {
+            args.push("--dry-run");
+        }
+        const env = {
+            ...process.env
+        };
+        if (!authToken?.trim()) {
+            delete env.NODE_AUTH_TOKEN;
+            delete env.NPM_TOKEN;
+            env.NPM_CONFIG_USERCONFIG = "/dev/null";
+        }
+        if (otp) {
+            env.NPM_CONFIG_OTP = otp;
+        }
+        try {
+            return await this.run({
+                cwd,
+                env
+            }, ...args);
+        } catch (error) {
+            if (skipIfPublished && !dryRun && isAlreadyPublishedError(error)) {
+                return {
+                    message: `Skipping publish — version already exists on registry`,
+                    data: []
+                };
+            }
+            throw error;
+        } finally{
+            if (tmpUserConfigPath) {
+                await this.removeTempUserConfig(tmpUserConfigPath);
+            }
+        }
+    }
+    /**
+	 * @description Runs in the directory of the package
+	 * @param options
+	 * @returns
+	 */ async version(versionType, options) {
+        const { cwd, noTag, preid } = options;
+        const args = [
+            Commands.version,
+            versionType
+        ];
+        if (noTag) {
+            args.push("--no-git-tag-version");
+        }
+        if (preid) {
+            args.push("--preid", preid);
+        }
+        return this.run({
+            cwd
+        }, ...args);
+    }
+    async link(directory, options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        const args = [
+            Commands.link,
+            directory
+        ];
+        return this.run({
+            cwd
+        }, ...args);
+    }
+    async install(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install);
+    }
+    /**
+	 * Install only `dependencies` as real folders: `--omit=dev` skips devDependencies and
+	 * `--no-bin-links` skips the `.bin` symlinks, so the result holds no symlinks at all.
+	 */ async installProduction(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install, "--omit=dev", "--no-bin-links", "--no-audit", "--no-fund", "--loglevel=error");
+    }
+    async syncLockFile(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install, "--package-lock-only", "--ignore-scripts");
+    }
+    /**
+	 * True when package@version exists on the registry.
+	 * Uses ambient npm config (cwd `.npmrc`); do not pass tokens on argv.
+	 */ async isPublished(directory, options) {
+        const { readFileSync } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:fs")));
+        const { join } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:path")));
+        try {
+            const pkgJson = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+            const spec = `${pkgJson.name}@${pkgJson.version}`;
+            await this.run(options, "view", spec, "version");
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async createTempUserConfig(authToken) {
+        const { mkdtemp, writeFile } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises")));
+        const { tmpdir } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:os")));
+        const { join } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:path")));
+        const tempDir = await mkdtemp(join(tmpdir(), "decohere-npmrc-"));
+        const npmrcPath = join(tempDir, ".npmrc");
+        const npmrc = [
+            "registry=https://registry.npmjs.org/",
+            "always-auth=true",
+            `//registry.npmjs.org/:_authToken=${authToken}`
+        ].join("\n");
+        await writeFile(npmrcPath, `${npmrc}\n`, {
+            mode: 0o600
+        });
+        return npmrcPath;
+    }
+    async removeTempUserConfig(npmrcPath) {
+        const { rm } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises")));
+        const { dirname } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:path")));
+        const dir = dirname(npmrcPath);
+        await rm(dir, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+function isAlreadyPublishedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /cannot publish over the previously published versions/i.test(message);
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VersionTypes", {
+    enumerable: true,
+    get: function() {
+        return VersionTypes;
+    }
+});
+const VersionTypes = {
+    major: "major",
+    minor: "minor",
+    patch: "patch",
+    prerelease: "prerelease"
+};

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
+};