@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/packages/docker/df.js

@@ -0,0 +1,395 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Dockerfile_instances, _Dockerfile_lines, _Dockerfile_fileInstruction, _Dockerfile_blankAfterInstruction, _Dockerfile_pushInstruction;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dockerfile = void 0;
+/* eslint-disable max-lines */
+const case_anything_1 = require("case-anything");
+const fs_1 = require("fs");
+class Dockerfile {
+    /**
+     * Merge multiple Dockerfile instances into one.
+     *
+     * Returns a new Dockerfile instance.
+     */
+    static merge(dockerfiles) {
+        const allLines = dockerfiles.flatMap((df) => __classPrivateFieldGet(df, _Dockerfile_lines, "f"));
+        const dockerfile = new Dockerfile();
+        __classPrivateFieldGet(dockerfile, _Dockerfile_lines, "f").push(...allLines);
+        return dockerfile;
+    }
+    constructor(df) {
+        _Dockerfile_instances.add(this);
+        _Dockerfile_lines.set(this, []);
+        _Dockerfile_blankAfterInstruction.set(this, true);
+        if (df) {
+            __classPrivateFieldSet(this, _Dockerfile_lines, __classPrivateFieldGet(df, _Dockerfile_lines, "f"), "f");
+        }
+    }
+    /**
+     * Instruction that initializes a new build stage and sets the base image for
+     * subsequent instructions.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#from)
+     */
+    FROM(
+    /**
+     * Image name.
+     *
+     * Formats: `<image>`, `<image>[:<tag>]`, `<image>[@<digest>]`
+     */
+    image, options) {
+        const platform = options?.platform
+            ? `--platform=${options?.platform}`
+            : undefined;
+        const as = options?.as ? `AS ${options.as}` : undefined;
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, ["FROM", platform, image, as].filter(filterUndefined).join(" "));
+        return this;
+    }
+    /**
+     * Sets the environment variable `<key>` to the value `<value>`.
+     * This value will be in the environment for all subsequent instructions
+     * in the build stage.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#env)
+     */
+    ENV(key, value, options) {
+        const keyVal = value.match(/^\${.+}$/)
+            ? `${key}=${value}`
+            : `${key}="${value}"`;
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [buildOption(options), "ENV", keyVal].filter(filterUndefined).join(" "));
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    LABEL(...args) {
+        const pairs = [args[0]]
+            .flatMap((p) => p)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .map((p) => `"${p.key}"="${p.value}"`)
+            .join(" \\\n      ");
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [buildOption(args[1]), "LABEL", pairs].filter(filterUndefined).join(" "));
+        return this;
+    }
+    /**
+     * Sets the working directory for any `RUN`, `CMD`, `ENTRYPOINT`, `COPY` and `ADD` instructions
+     * that follow it in the Dockerfile.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#workdir)
+     */
+    WORKDIR(dir, options) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [buildOption(options), "WORKDIR", `${dir}`]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    /**
+     * Execute any commands to create a new layer on top of the current image.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#run)
+     */
+    RUN(command, options) {
+        let base = [buildOption(options), "RUN"].filter(filterUndefined).join(" ");
+        if (options?.mount) {
+            base += ` ${mountOpts(options?.mount)}${Array.isArray(command) ? "" : " \\\n   "}`;
+        }
+        const instruction = `${base} ${Array.isArray(command)
+            ? ["", ...command].join(" \\\n  ").trimStart()
+            : command}`;
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, instruction);
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    COPY(...args) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_fileInstruction).call(this, args, [buildOption(args[2]), "COPY"].filter(filterUndefined).join(" "));
+        return this;
+    }
+    CMD(...args) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, `CMD [${args
+            .flatMap((e) => e)
+            .map((e) => `"${e}"`)
+            .join(", ")}]`);
+        return this;
+    }
+    /**
+     * Configures a container that will run as an executable.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#entrypoint)
+     */
+    ENTRYPOINT(executable, parameters) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, `ENTRYPOINT [${[executable, ...(parameters ?? [])].map((e) => `"${e}"`).join(", ")}]`);
+        return this;
+    }
+    /**
+     * Overrides the default shell used for the shell form of commands.
+     *
+     * The default shell on Linux is `["/bin/sh", "-c"]`,
+     * and on Windows is `["cmd", "/S", "/C"]`.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#shell)
+     */
+    SHELL(executable, parameters, options) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [
+            buildOption(options),
+            `SHELL [${[executable, ...(parameters ?? [])].map((e) => `"${e}"`).join(", ")}]`,
+        ]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    EXPOSE(...args) {
+        const portAndProtocol = [args[0]]
+            .flatMap((p) => p)
+            .map((port) => {
+            switch (typeof port) {
+                case "number":
+                case "string":
+                    return String(port);
+                default:
+                    return `${port.port}/${port.protocol}`;
+            }
+        })
+            .join(" ");
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [buildOption(args[1]), `EXPOSE ${portAndProtocol}`]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    /**
+     * Sets the user name (or UID) and optionally the user group (or GID) to use
+     * as the default user and group for the remainder of the current stage.
+     *
+     * The specified user is used for RUN instructions and at runtime,
+     * runs the relevant `ENTRYPOINT` and `CMD` commands.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#user)
+     */
+    USER(user, options) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [
+            buildOption(options),
+            "USER",
+            `${Object.values(user).filter(filterUndefined).join(":")}`,
+        ]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    /**
+     * Creates a mount point with the specified name and
+     * marks it as holding externally mounted volumes from native host or other containers.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#volume)
+     */
+    VOLUME(names, options) {
+        const volumes = [names]
+            .flatMap((v) => v)
+            .map((v) => `"${v}"`)
+            .join(", ");
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [buildOption(options), "VOLUME", `[${volumes}]`]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    /**
+     * Sets the system call signal that will be sent to the container to exit.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#stopsignal)
+     */
+    STOPSIGNAL(signal, options) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [buildOption(options), `STOPSIGNAL ${signal}`]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    /**
+     * Defines a variable that users can pass at build-time to the builder
+     * with the docker build command using the `--build-arg <varname>=<value>` flag.
+     *
+     * @see
+     *
+     * [Docker Docs](https://docs.docker.com/engine/reference/builder/#arg)
+     */
+    ARG(name, options) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [
+            buildOption(options),
+            `ARG ${[name, options?.default ? `"${options.default}"` : undefined].filter((c) => c !== undefined).join("=")}`,
+        ]
+            .filter(filterUndefined)
+            .join(" "));
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ADD(...args) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_fileInstruction).call(this, args, [buildOption(args[2]), "ADD"].filter(filterUndefined).join(" "));
+        return this;
+    }
+    HEALTHCHECK(command, options) {
+        switch (command) {
+            case "NONE":
+                __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, `HEALTHCHECK NONE`);
+                break;
+            default:
+                __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, [
+                    buildOption(options),
+                    `HEALTHCHECK ${optionsToString(options)}`.trim(),
+                    `CMD ${command}`,
+                ]
+                    .filter(filterUndefined)
+                    .join(" "));
+        }
+        return this;
+    }
+    /**
+     * Adds a comment.
+     */
+    comment(content) {
+        __classPrivateFieldGet(this, _Dockerfile_lines, "f").push(`# ${content}`);
+        return this;
+    }
+    /**
+     * Adds a banner comment
+     */
+    banner(content) {
+        __classPrivateFieldGet(this, _Dockerfile_lines, "f").push(`# ---------`);
+        __classPrivateFieldGet(this, _Dockerfile_lines, "f").push(`# ${content}`);
+        __classPrivateFieldGet(this, _Dockerfile_lines, "f").push(`# ---------`);
+        this.blank();
+        return this;
+    }
+    /**
+     * Adds an empty line.
+     */
+    blank() {
+        __classPrivateFieldGet(this, _Dockerfile_lines, "f").push("");
+        return this;
+    }
+    /**
+     * Groups instructions by omitting blank lines between them.
+     */
+    group(callback) {
+        __classPrivateFieldSet(this, _Dockerfile_blankAfterInstruction, false, "f");
+        callback();
+        this.blank();
+        __classPrivateFieldSet(this, _Dockerfile_blankAfterInstruction, true, "f");
+        return this;
+    }
+    /**
+     * Returns the Dockerfile string.
+     */
+    toString() {
+        return __classPrivateFieldGet(this, _Dockerfile_lines, "f").join("\n");
+    }
+    /**
+     * Saves the Dockerfile.
+     */
+    save(filePath) {
+        (0, fs_1.writeFileSync)(filePath, this.toString());
+    }
+    /**
+     * Appends the contents of a Dockerfile instance.
+     */
+    append(dockerfile) {
+        __classPrivateFieldGet(this, _Dockerfile_lines, "f").push(...__classPrivateFieldGet(dockerfile, _Dockerfile_lines, "f"));
+        return this;
+    }
+}
+exports.Dockerfile = Dockerfile;
+_Dockerfile_lines = new WeakMap(), _Dockerfile_blankAfterInstruction = new WeakMap(), _Dockerfile_instances = new WeakSet(), _Dockerfile_fileInstruction = function _Dockerfile_fileInstruction(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+args, kind) {
+    const source = args[0];
+    const destination = args[1];
+    const options = args[2];
+    const base = `${kind} ${optionsToString(options)}`.trim();
+    const files = [source, destination].flatMap((s) => s);
+    const withSpaces = files.some((s) => s.includes(" "));
+    if (withSpaces) {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, `${base} [ ${files.map((s) => `"${s}"`).join(", ")} ]`);
+    }
+    else {
+        __classPrivateFieldGet(this, _Dockerfile_instances, "m", _Dockerfile_pushInstruction).call(this, `${base} ${files.join(" ")}`);
+    }
+}, _Dockerfile_pushInstruction = function _Dockerfile_pushInstruction(instruction) {
+    __classPrivateFieldGet(this, _Dockerfile_lines, "f").push(`${instruction}`);
+    if (__classPrivateFieldGet(this, _Dockerfile_blankAfterInstruction, "f")) {
+        this.blank();
+    }
+};
+function mountOpts(mount) {
+    if (mount === undefined) {
+        return "";
+    }
+    return [mount]
+        .flatMap((m) => m)
+        .map((m) => Object.entries(m)
+        .reduce((acc, val) => {
+        if (val[0] === "type") {
+            return acc;
+        }
+        if (typeof val[1] === "string") {
+            acc.push(`${val[0]}=${val[1]}`);
+        }
+        else {
+            acc.push(val[0]);
+        }
+        return acc;
+    }, [`--mount=type=${m.type}`])
+        .join(","))
+        .join(" \\\n    ");
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function optionsToString(opts) {
+    if (opts === undefined) {
+        return "";
+    }
+    return Object.entries(opts)
+        .reduce((acc, val) => {
+        const optionName = (0, case_anything_1.kebabCase)(val[0]);
+        if (optionName === "on-build") {
+            return acc;
+        }
+        if (typeof val[1] === "boolean") {
+            acc += `--${optionName} `;
+        }
+        else {
+            acc += `--${optionName}=${val[1]} `;
+        }
+        return acc;
+    }, "")
+        .trimEnd();
+}
+function filterUndefined(value) {
+    return value !== undefined;
+}
+function buildOption(options) {
+    return options?.onBuild ? "ONBUILD" : undefined;
+}
+//# sourceMappingURL=df.js.map

package/dist/cjs/packages/docker/validator.d.ts

@@ -0,0 +1,7 @@
+import { Dockerfile } from "~docker/df.js";
+/**
+ * Validates a {@link Dockerfile }.
+ *
+ * @throws `Error` if the Dockerfile is not valid.
+ */
+export declare function validate(dw: Dockerfile): boolean;

package/dist/cjs/packages/docker/validator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+const dockerfile_utils_1 = require("dockerfile-utils");
+/**
+ * Validates a {@link Dockerfile }.
+ *
+ * @throws `Error` if the Dockerfile is not valid.
+ */
+function validate(dw) {
+    const diagnostic = (0, dockerfile_utils_1.validate)(dw.toString());
+    if (diagnostic.length !== 0) {
+        console.dir(diagnostic);
+        throw new Error("Invalid Dockerfile", { cause: diagnostic });
+    }
+    return true;
+}
+//# sourceMappingURL=validator.js.map

package/dist/cjs/packages/utils/create-file.d.ts

@@ -0,0 +1 @@
+export declare function createFile(filePath: string, content: string, log?: boolean): void;

package/dist/cjs/packages/utils/create-file.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFile = createFile;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+function createFile(filePath, content, log = true) {
+    const overwritten = (0, fs_1.existsSync)(filePath);
+    (0, fs_1.writeFileSync)(filePath, content);
+    if (log) {
+        const relativePath = path_1.default.relative(process.cwd(), filePath);
+        console.log(`${picocolors_1.default.green(overwritten ? "overwritten" : "created")} ${relativePath}`);
+    }
+}
+//# sourceMappingURL=create-file.js.map

package/dist/cjs/packages/utils/date-string.d.ts

@@ -0,0 +1 @@
+export declare function dateStringWithMilliseconds(): string;

package/dist/cjs/packages/utils/date-string.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateStringWithMilliseconds = dateStringWithMilliseconds;
+function dateStringWithMilliseconds() {
+    return new Date()
+        .toISOString()
+        .replace(/[-:]/g, "")
+        .replace(".", "")
+        .replace("T", "")
+        .replace("Z", "");
+}
+//# sourceMappingURL=date-string.js.map

package/dist/cjs/packages/utils/exception.d.ts

@@ -0,0 +1 @@
+export declare function isErrnoException(error: unknown): error is NodeJS.ErrnoException;

package/dist/cjs/packages/utils/exception.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isErrnoException = isErrnoException;
+function isErrnoException(error) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return error instanceof Error && typeof error.code === "string";
+}
+//# sourceMappingURL=exception.js.map

package/dist/cjs/packages/utils/hash-value.d.ts

@@ -0,0 +1,16 @@
+export declare function hashValue(value: string): string;
+interface HashDigestOptions {
+    /**
+     * Length of the digest to generate.
+     *
+     * @default 8
+     */
+    length: number;
+}
+/**
+ * Returns a hex digest of a string.
+ * @param value String to generate a digest.
+ * @param options {@link HashDigestOptions}
+ */
+export declare function hashDigest(value: string, options?: HashDigestOptions): import("effect/Effect").Effect<string, never, never>;
+export {};

package/dist/cjs/packages/utils/hash-value.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashValue = hashValue;
+exports.hashDigest = hashDigest;
+const Effect_1 = require("effect/Effect");
+const node_crypto_1 = require("node:crypto");
+function hashValue(value) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    hash.update(value);
+    return hash.digest("hex").substring(0, 8);
+}
+/**
+ * Returns a hex digest of a string.
+ * @param value String to generate a digest.
+ * @param options {@link HashDigestOptions}
+ */
+function hashDigest(value, options) {
+    return (0, Effect_1.gen)(function* () {
+        const hash = (0, node_crypto_1.createHash)("sha256");
+        hash.update(value);
+        const digest = hash.digest("hex").substring(0, options?.length ?? 8);
+        return yield* (0, Effect_1.succeed)(digest);
+    });
+}
+//# sourceMappingURL=hash-value.js.map

package/dist/cjs/packages/utils/import-default.d.ts

@@ -0,0 +1 @@
+export declare function importDefault(path: string): import("effect/Effect").Effect<any, NodeJS.ErrnoException | import("effect/Cause").UnknownException, never>;

package/dist/cjs/packages/utils/import-default.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDefault = importDefault;
+const Effect_1 = require("effect/Effect");
+const import_file_js_1 = require("./import-file.js");
+function importDefault(path) {
+    return (0, Effect_1.gen)(function* () {
+        const imported = yield* (0, import_file_js_1.importFile)(path);
+        return imported.default && imported.default.default
+            ? imported.default.default
+            : imported.default;
+    });
+}
+//# sourceMappingURL=import-default.js.map

package/dist/cjs/packages/utils/import-file.d.ts

@@ -0,0 +1,8 @@
+import type { UnknownException } from "effect/Cause";
+/**
+ * Dynamically imports a module from the specified path.
+ *
+ * @param path path to file to import.
+ * @typeParam T The expected type of the imported module. Default: `any`
+ */
+export declare const importFile: <T = any>(path: string) => import("effect/Effect").Effect<T, NodeJS.ErrnoException | UnknownException, never>;

package/dist/cjs/packages/utils/import-file.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importFile = void 0;
+const Effect_1 = require("effect/Effect");
+const exception_js_1 = require("./exception.js");
+/**
+ * Dynamically imports a module from the specified path.
+ *
+ * @param path path to file to import.
+ * @typeParam T The expected type of the imported module. Default: `any`
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const importFile = (path) => (0, Effect_1.tryPromise)({
+    try: () => Promise.resolve(`${path}`).then(s => __importStar(require(s))),
+    catch: (e) => ((0, exception_js_1.isErrnoException)(e) ? e : e),
+});
+exports.importFile = importFile;
+//# sourceMappingURL=import-file.js.map

package/dist/cjs/packages/utils/log-with-spinner.d.ts

@@ -0,0 +1 @@
+export declare function logWithSpinner(msg: string, fn: () => Promise<void>): Promise<void>;

package/dist/cjs/packages/utils/log-with-spinner.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logWithSpinner = logWithSpinner;
+const ora_1 = __importDefault(require("ora"));
+const picocolors_1 = __importDefault(require("picocolors"));
+async function logWithSpinner(msg, fn) {
+    const spinner = (0, ora_1.default)();
+    spinner.start(msg);
+    const start = performance.now();
+    try {
+        await fn();
+        const end = performance.now();
+        const milliseconds = Number(end - start).toFixed(3);
+        spinner.succeed(`${msg} ${picocolors_1.default.gray(`(${milliseconds}ms)`)}`);
+    }
+    catch (e) {
+        spinner.fail();
+        throw e;
+    }
+}
+//# sourceMappingURL=log-with-spinner.js.map

package/dist/cjs/packages/utils/path.d.ts

@@ -0,0 +1,2 @@
+import { Effect } from "effect";
+export declare function pathExists(filePath: string): Effect.Effect<boolean, import("effect/Cause").UnknownException, never>;

package/dist/cjs/packages/utils/path.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathExists = pathExists;
+const effect_1 = require("effect");
+const promises_1 = require("fs/promises");
+function pathExists(filePath) {
+    return effect_1.Effect.tryPromise(async () => {
+        try {
+            await (0, promises_1.stat)(filePath);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return false;
+            }
+            throw error;
+        }
+        return true;
+    });
+}
+//# sourceMappingURL=path.js.map

package/dist/cjs/packages/utils/playground.d.ts

@@ -0,0 +1 @@
+declare function main(): Promise<any>;