@fynjs/run 1.0.1 → 1.1.1

package/dist/lib/util/task-options.js

@@ -0,0 +1,115 @@
+const TYPE_NAMES = new Set(["string", "number", "boolean", "float", "int", "integer"]);
+/**
+ * Normalize task option specifications into @fynjs/cli-args compatible OptionSpec.
+ * Supports:
+ * - Native @fynjs/cli-args spec: { required: true, args: "<val string>", alias: "f" }
+ * - Shorthand args without value name: { args: "<string>" } -> { args: "<val string>" }
+ * - Legacy format: { require: true, type: "string", alias: "f" }
+ * - Legacy array format: { type: "array" } -> { args: "[val string..]" }
+ * - Legacy count format: { type: "count" } -> { counting: Infinity }
+ *
+ * @param {Record<string, any>} rawOpts - Raw options dictionary
+ * @returns {Record<string, any>} Normalized options dictionary
+ */
+export function normalizeTaskOptions(rawOpts) {
+    if (!rawOpts || typeof rawOpts !== "object") {
+        return {};
+    }
+    const normalized = {};
+    for (const [name, spec] of Object.entries(rawOpts)) {
+        if (!spec || typeof spec !== "object") {
+            continue;
+        }
+        const opt = { ...spec };
+        // Support legacy `require: true`
+        if (opt.require !== undefined && opt.required === undefined) {
+            opt.required = Boolean(opt.require);
+            delete opt.require;
+        }
+        // Support legacy `type: "string"` / `type: "array"` / `type: "count"`
+        if (opt.type !== undefined && typeof opt.type === "string" && opt.args === undefined) {
+            if (opt.type === "count") {
+                opt.counting = opt.counting !== undefined ? opt.counting : Infinity;
+            }
+            else if (opt.type === "array") {
+                opt.args = opt.required ? "<val string..>" : "[val string..]";
+            }
+            else {
+                opt.args = `<val ${opt.type}>`;
+            }
+            delete opt.type;
+        }
+        // Normalize type-only angle or square brackets: `<string>` -> `<val string>`, `<array>` -> `<val string..>`
+        if (typeof opt.args === "string") {
+            opt.args = opt.args
+                .replace(/^<([a-zA-Z]+)>$/, (_m, type) => {
+                if (type === "array") {
+                    return "<val string..>";
+                }
+                return TYPE_NAMES.has(type) ? `<val ${type}>` : `<${type}>`;
+            })
+                .replace(/^\[([a-zA-Z]+)\]$/, (_m, type) => {
+                if (type === "array") {
+                    return "[val string..]";
+                }
+                return TYPE_NAMES.has(type) ? `[val ${type}]` : `[${type}]`;
+            });
+        }
+        normalized[name] = opt;
+    }
+    return normalized;
+}
+/**
+ * Normalize subcommand definitions so nested options and commands are properly structured.
+ *
+ * @param {Record<string, any>} rawCmds - Raw commands dictionary
+ * @returns {Record<string, any>} Normalized commands dictionary
+ */
+export function normalizeTaskCommands(rawCmds) {
+    if (!rawCmds) {
+        return {};
+    }
+    const normalized = {};
+    for (const [cmdName, cmdSpec] of Object.entries(rawCmds)) {
+        if (cmdSpec && typeof cmdSpec === "object") {
+            const sub = cmdSpec.subCommands || cmdSpec.commands;
+            const copy = { ...cmdSpec };
+            delete copy.commands;
+            if (copy.options) {
+                copy.options = normalizeTaskOptions(copy.options);
+            }
+            if (sub) {
+                copy.subCommands = normalizeTaskCommands(sub);
+            }
+            normalized[cmdName] = copy;
+        }
+        else {
+            normalized[cmdName] = cmdSpec;
+        }
+    }
+    return normalized;
+}
+/**
+ * Extract and normalize option specifications for a given task definition.
+ *
+ * @param {any} task - Task item or task object
+ * @returns {{ options: Record<string, any>, commands: Record<string, any>, allowUnknownOption?: boolean }}
+ */
+export function getTaskOptionSpec(task) {
+    const item = task?.item || task || {};
+    const cliParser = item.cliParser || task?.cliParser || {};
+    const rawOpts = item.argOpts || cliParser.options || task?.argOpts;
+    const options = normalizeTaskOptions(rawOpts);
+    const commands = normalizeTaskCommands(cliParser.subCommands || cliParser.commands);
+    const allowUnknownOption = cliParser.allowUnknownOption !== undefined
+        ? cliParser.allowUnknownOption
+        : item.allowUnknownOption !== undefined
+            ? item.allowUnknownOption
+            : undefined;
+    return { options, commands, allowUnknownOption };
+}
+export default {
+    normalizeTaskOptions,
+    normalizeTaskCommands,
+    getTaskOptionSpec
+};

package/dist/lib/util/update-env.d.ts

@@ -0,0 +1 @@
+export default function (env: any, target: any, override?: boolean): any;

package/dist/lib/util/update-env.js

@@ -0,0 +1,18 @@
+export default function (env, target, override = true) {
+    target = target || process.env;
+    if (env) {
+        Object.keys(env).forEach(k => {
+            if (override === false && target.hasOwnProperty(k)) {
+                return;
+            }
+            if (env[k] === undefined || env[k] === null) {
+                delete target[k];
+            }
+            else {
+                target[k] = env[k];
+            }
+        });
+    }
+    return target;
+}
+;

package/dist/lib/xqitem.d.ts

@@ -0,0 +1,22 @@
+declare class XQItem {
+    _isFinally: any;
+    anon: any;
+    argv: any;
+    children: any;
+    id: any;
+    level: any;
+    name: any;
+    ns: any;
+    parentId: any;
+    resolved: any;
+    type: any;
+    constructor(options: any);
+    lookup(tasks: any): any;
+    value(): any;
+    setResolve(value: any): void;
+    setNamespace(ns: any): void;
+    addChild(x: any): void;
+    get isFinally(): any;
+    set isFinally(f: any);
+}
+export default XQItem;

package/dist/lib/xqitem.js

@@ -0,0 +1,57 @@
+import genXqId from "./gen-xqid.js";
+import assert from "assert";
+class XQItem {
+    constructor(options) {
+        this.id = genXqId();
+        this.argv = [];
+        this.resolved = [];
+        this.children = [];
+        this.level = options.level || 0;
+        this.ns = options.ns || "";
+        let value = options.value;
+        if (typeof options.name === "string") {
+            this.argv = options.name
+                .trim()
+                .split(" ")
+                .filter(x => x);
+            this.name = this.argv[0];
+            if (this.name !== options.name && !value) {
+                value = options.name;
+            }
+        }
+        assert(this.name, "xqitem must have a name");
+        if (value) {
+            this.setResolve(value);
+        }
+        this.type = options.type;
+        if (options.parent) {
+            this.parentId = options.parent.id;
+            this.isFinally = options.parent.isFinally;
+        }
+        this.anon = options.anon;
+    }
+    lookup(tasks) {
+        const found = tasks.lookup(this.name);
+        this.setResolve({ top: true, item: found.item });
+        return found;
+    }
+    value() {
+        return this.resolved.length === 0 ? this.name : this.resolved[this.resolved.length - 1];
+    }
+    setResolve(value) {
+        this.resolved.push(value);
+    }
+    setNamespace(ns) {
+        this.ns = ns;
+    }
+    addChild(x) {
+        this.children.push(x);
+    }
+    get isFinally() {
+        return this._isFinally;
+    }
+    set isFinally(f) {
+        this._isFinally = f;
+    }
+}
+export default XQItem;

package/dist/lib/xqtor.d.ts

@@ -0,0 +1,57 @@
+import XQItem from "./xqitem.js";
+import childProc from "child_process";
+declare class XQtor {
+    _done: any;
+    _tasks: any;
+    _xrun: any;
+    xqItems: any;
+    constructor(options: any);
+    next(err?: any, xqId?: any): void;
+    _next(err: any, xqId: any): void;
+    execute(): any;
+    pushMarkItem(qItem: any, callback?: any): XQItem;
+    pushItem(qItem: any): void;
+    popItem(): any;
+    _isAnonShell(value: any): false | {
+        sig: any;
+        opt: boolean;
+    };
+    _parseShellFlags(flags: any, value?: any): any;
+    _parseAnonShell(value: any): any;
+    _isStrArray(value: any): any;
+    _parseStrArray(value: any): import("string-array").StringArray[];
+    _processLookup(qItem: any): void;
+    _processDep(qItem: any, dep: any): void;
+    _processTaskObject(qItem: any): any;
+    _processArray(qItem: any, tasks: any, top?: any): void;
+    _serialArrayXer(qItem: any, tasks: any): void;
+    _resolveValueToQItemOptions(ns: any, name: any, value: any, type: any): {
+        ns: any;
+        name: any;
+        value: any;
+        anon: boolean;
+        type: any;
+    };
+    _concurrentArrayXer(qItem: any, tasks: any): void;
+    _envXer(qItem: any, cmdVal: any): void;
+    _shellXer(qItem: any, cmdVal: any, anon?: any): void;
+    _doShellXer({ /*anon,*/ qItem, cmd, flags, /*cmdVal,*/ options, item }: {
+        cmd: any;
+        flags: any;
+        item: any;
+        options: any;
+        qItem: any;
+    }): void;
+    _handleChildTask(child: any, cmd: any): childProc.ChildProcess;
+    _processMoreFromFn(qItem: any, value: any, callback?: any): void;
+    _isChildSigTerm(err: any, child: any): boolean;
+    _isChildTerminated(child: any): any;
+    _handleStream(val: any): any;
+    _functionXer(qItem: any, fn: any): any;
+    _watchFailure(watch: any): NodeJS.Timeout;
+    _processMark(qItem: any): void;
+    _makeXqMarkItem(qItem: any, callback: any): XQItem;
+    _emit(event: any, data?: any): void;
+    _createQItem(options: any, parent: any): any;
+}
+export default XQtor;