@git.zone/cli 2.14.2 → 2.15.0

package/dist_ts/helpers.workflow.js

@@ -0,0 +1,258 @@
+import { getCliConfigValue } from "./helpers.smartconfig.js";
+const commitFlagToStep = {
+    f: "format",
+    t: "test",
+    b: "build",
+    p: "push",
+};
+const unique = (items) => {
+    const result = [];
+    for (const item of items) {
+        if (!result.includes(item)) {
+            result.push(item);
+        }
+    }
+    return result;
+};
+const normalizeConfirmation = (value, fallback) => {
+    if (value === "prompt" || value === "auto" || value === "plan") {
+        return value;
+    }
+    return fallback;
+};
+const normalizeRegistryUrl = (url) => {
+    let normalizedUrl = url.trim();
+    if (!normalizedUrl.startsWith("http://") && !normalizedUrl.startsWith("https://")) {
+        normalizedUrl = `https://${normalizedUrl}`;
+    }
+    return normalizedUrl.endsWith("/") ? normalizedUrl.slice(0, -1) : normalizedUrl;
+};
+const isDisabled = (argvArg, ...keys) => {
+    return keys.some((key) => argvArg[key] === false || argvArg[`no-${key}`] || argvArg[`no${key[0].toUpperCase()}${key.slice(1)}`]);
+};
+const readCliWorkflowConfig = async () => {
+    return await getCliConfigValue("", {});
+};
+const getOrderedArgsAfterCommand = (commandName) => {
+    const rawArgs = process.argv.slice(2);
+    const commandIndex = rawArgs.indexOf(commandName);
+    if (commandIndex === -1) {
+        return rawArgs;
+    }
+    return rawArgs.slice(commandIndex + 1);
+};
+const getOrderedShortFlags = (commandName) => {
+    const orderedFlags = [];
+    for (const arg of getOrderedArgsAfterCommand(commandName)) {
+        if (arg === "--") {
+            break;
+        }
+        if (arg.startsWith("--")) {
+            continue;
+        }
+        if (arg.startsWith("-") && arg.length > 1) {
+            orderedFlags.push(...arg.slice(1).split(""));
+        }
+    }
+    return orderedFlags;
+};
+const hasExplicitCommitWorkflowFlags = (argvArg) => {
+    return Boolean(argvArg.f ||
+        argvArg.format ||
+        argvArg.t ||
+        argvArg.test ||
+        argvArg.b ||
+        argvArg.build ||
+        argvArg.p ||
+        argvArg.push);
+};
+const normalizeCommitSteps = (rawSteps) => {
+    const steps = unique(rawSteps.filter(Boolean));
+    const pushRequested = steps.includes("push");
+    const prePushSteps = steps.filter((step) => step !== "push");
+    if (!prePushSteps.includes("analyze")) {
+        prePushSteps.unshift("analyze");
+    }
+    if (!prePushSteps.includes("changelog")) {
+        const commitIndex = prePushSteps.indexOf("commit");
+        if (commitIndex === -1) {
+            prePushSteps.push("changelog");
+        }
+        else {
+            prePushSteps.splice(commitIndex, 0, "changelog");
+        }
+    }
+    if (!prePushSteps.includes("commit")) {
+        prePushSteps.push("commit");
+    }
+    const analyzeIndex = prePushSteps.indexOf("analyze");
+    const commitIndex = prePushSteps.indexOf("commit");
+    if (analyzeIndex > commitIndex) {
+        throw new Error("Commit workflow requires analyze before commit.");
+    }
+    const changelogIndex = prePushSteps.indexOf("changelog");
+    if (changelogIndex === -1 || changelogIndex > commitIndex) {
+        throw new Error("Commit workflow requires changelog before commit.");
+    }
+    return pushRequested ? [...prePushSteps, "push"] : prePushSteps;
+};
+const getTargetOverride = (argvArg) => {
+    const validTargets = ["git", "npm", "docker"];
+    const rawTargets = argvArg.target || argvArg.targets;
+    if (typeof rawTargets === "string") {
+        return rawTargets
+            .split(",")
+            .map((target) => target.trim())
+            .filter((target) => validTargets.includes(target));
+    }
+    const targets = [];
+    if (argvArg.git || argvArg.p || argvArg.push)
+        targets.push("git");
+    if (argvArg.npm)
+        targets.push("npm");
+    if (argvArg.docker)
+        targets.push("docker");
+    return targets.length > 0 ? targets : undefined;
+};
+const buildReleasePlan = (options) => {
+    const plan = [];
+    if (options.requireCleanTree)
+        plan.push("preflight.cleanTree");
+    if (options.runTests)
+        plan.push("preflight.test");
+    plan.push("core.version", "core.changelog", "core.commit", "core.tag");
+    if (options.runBuild)
+        plan.push("core.build");
+    for (const target of options.targets) {
+        plan.push(`target.${target}`);
+    }
+    return plan;
+};
+export const resolveCommitWorkflow = async (argvArg) => {
+    const cliConfig = await readCliWorkflowConfig();
+    const commitConfig = cliConfig.commit || {};
+    const releaseFlagRequested = Boolean(argvArg.r || argvArg.release);
+    let confirmation = normalizeConfirmation(commitConfig.confirmation, "prompt");
+    if (argvArg.plan) {
+        confirmation = "plan";
+    }
+    else if (argvArg.y || argvArg.yes) {
+        confirmation = "auto";
+    }
+    let rawSteps;
+    if (hasExplicitCommitWorkflowFlags(argvArg)) {
+        const orderedFlags = getOrderedShortFlags("commit");
+        rawSteps = ["analyze"];
+        for (const shortFlag of orderedFlags) {
+            const step = commitFlagToStep[shortFlag];
+            if (step) {
+                rawSteps.push(step);
+            }
+        }
+        if (argvArg.format && !rawSteps.includes("format"))
+            rawSteps.push("format");
+        if (argvArg.test && !rawSteps.includes("test"))
+            rawSteps.push("test");
+        if (argvArg.build && !rawSteps.includes("build"))
+            rawSteps.push("build");
+        if (argvArg.push && !rawSteps.includes("push"))
+            rawSteps.push("push");
+        rawSteps.push("changelog");
+        rawSteps.push("commit");
+    }
+    else if (Array.isArray(commitConfig.steps) && commitConfig.steps.length > 0) {
+        rawSteps = commitConfig.steps;
+    }
+    else {
+        rawSteps = ["analyze"];
+        if (commitConfig.alwaysTest)
+            rawSteps.push("test");
+        if (commitConfig.alwaysBuild)
+            rawSteps.push("build");
+        rawSteps.push("changelog");
+        rawSteps.push("commit");
+    }
+    return {
+        confirmation,
+        steps: normalizeCommitSteps(rawSteps),
+        staging: commitConfig.staging || "all",
+        testCommand: commitConfig.test?.command || "pnpm test",
+        buildCommand: commitConfig.build?.command || "pnpm build",
+        changelogFile: "changelog.md",
+        changelogSection: "Pending",
+        pushRemote: commitConfig.push?.remote || "origin",
+        pushFollowTags: commitConfig.push?.followTags || false,
+        releaseFlagRequested,
+    };
+};
+export const resolveReleaseWorkflow = async (argvArg) => {
+    const cliConfig = await readCliWorkflowConfig();
+    const releaseConfig = cliConfig.release || {};
+    const targetConfig = releaseConfig.targets || {};
+    const gitConfig = targetConfig.git || {};
+    const npmConfig = targetConfig.npm || {};
+    const dockerConfig = targetConfig.docker || {};
+    const npmRegistries = (npmConfig.registries || []).map(normalizeRegistryUrl);
+    const npmEnabled = npmConfig.enabled ?? npmRegistries.length > 0;
+    const gitEnabled = gitConfig.enabled ?? true;
+    const dockerEnabled = dockerConfig.enabled ?? false;
+    let confirmation = normalizeConfirmation(releaseConfig.confirmation, "prompt");
+    if (argvArg.plan) {
+        confirmation = "plan";
+    }
+    else if (argvArg.y || argvArg.yes) {
+        confirmation = "auto";
+    }
+    let requireCleanTree = releaseConfig.preflight?.requireCleanTree ?? true;
+    let runTests = releaseConfig.preflight?.test ?? false;
+    let runBuild = releaseConfig.preflight?.build ?? true;
+    if (argvArg.t || argvArg.test)
+        runTests = true;
+    if (argvArg.b || argvArg.build)
+        runBuild = true;
+    if (isDisabled(argvArg, "test"))
+        runTests = false;
+    if (isDisabled(argvArg, "build"))
+        runBuild = false;
+    if (isDisabled(argvArg, "preflight"))
+        requireCleanTree = false;
+    const configuredTargets = [];
+    if (gitEnabled)
+        configuredTargets.push("git");
+    if (npmEnabled)
+        configuredTargets.push("npm");
+    if (dockerEnabled)
+        configuredTargets.push("docker");
+    let targets = getTargetOverride(argvArg) || configuredTargets;
+    if (isDisabled(argvArg, "git", "push")) {
+        targets = targets.filter((target) => target !== "git");
+    }
+    if (isDisabled(argvArg, "publish")) {
+        targets = targets.filter((target) => target === "git");
+    }
+    targets = unique(targets);
+    return {
+        confirmation,
+        plan: buildReleasePlan({ requireCleanTree, runTests, runBuild, targets }),
+        targets,
+        requireCleanTree,
+        runTests,
+        runBuild,
+        testCommand: releaseConfig.preflight?.testCommand || "pnpm test",
+        buildCommand: releaseConfig.preflight?.buildCommand || "pnpm build",
+        changelogFile: "changelog.md",
+        changelogPendingSection: "Pending",
+        changelogVersionHeading: "## {{date}} - {{version}}",
+        gitEnabled,
+        gitRemote: gitConfig.remote || "origin",
+        pushBranch: gitConfig.pushBranch ?? true,
+        pushTags: gitConfig.pushTags ?? true,
+        npmEnabled,
+        npmRegistries,
+        npmAccessLevel: npmConfig.accessLevel || "public",
+        npmAlreadyPublished: npmConfig.alreadyPublished || "success",
+        dockerEnabled,
+        dockerImages: dockerConfig.images || [],
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.workflow.js","sourceRoot":"","sources":["../ts/helpers.workflow.ts"],"names":[],"mappings":"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"}