@hardfin/cli 0.1.0-dev.24 → 0.1.0-dev.26

package/dist/completion-quick-BJHDp8OL.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { n as toCompletion, t as toAnswer } from "./completion-tree-rR_Rmeij.js";
+import { readFileSync } from "node:fs";
+//#region src/command/completion-quick.ts
+/**
+* toQuickAnswer answers a Tab from the tree the build wrote beside the CLI. It answers
+* nothing when there is no tree, as in a test or a build made without one, and the caller
+* then loads the commands instead.
+*/
+function toQuickAnswer(words, location = new URL("./completion-tree.json", import.meta.url)) {
+	let tree;
+	try {
+		tree = JSON.parse(readFileSync(location, "utf8"));
+	} catch {
+		return;
+	}
+	return toAnswer(toCompletion(tree, words));
+}
+//#endregion
+export { toQuickAnswer };

package/dist/completion-tree-rR_Rmeij.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+//#region src/command/completion-tree.ts
+/** Directive is the last line of an answer, which tells the script what to do beyond the candidates. */
+const Directive = {
+	NONE: ":0",
+	FILES: ":1"
+};
+const HELP_FLAG = {
+	name: "help",
+	short: "h",
+	description: "Print help for the command"
+};
+const VERSION_FLAG = {
+	name: "version",
+	short: "v",
+	description: "Print the version"
+};
+/** The value names that mean a path, so the shell offers files for them. */
+const PATH_VALUES = /* @__PURE__ */ new Set(["path", "file"]);
+const NOTHING = {
+	candidates: [],
+	isFile: false
+};
+/**
+* toAnswer writes a completion as a script reads it. Each line is a candidate, with its
+* description after a tab, and the last line is the directive.
+*/
+function toAnswer(completion) {
+	return [...completion.candidates.map((candidate) => candidate.description ? `${candidate.value}\t${toLine(candidate.description)}` : candidate.value), completion.isFile ? Directive.FILES : Directive.NONE].join("\n");
+}
+/**
+* toCompletion answers what may follow the words typed so far. The last word is what is
+* being typed, and it is empty when the cursor sits after a space, which asks what may come
+* next rather than how to finish the word before it.
+*/
+function toCompletion(tree, words) {
+	const partial = words[words.length - 1] ?? "";
+	const walked = toWalked(tree, words.slice(0, -1));
+	if (walked.isUnknown) return NOTHING;
+	if (walked.pending) return toValues(walked.pending, partial, "");
+	const assigned = /^(--?[^=]+)=(.*)$/.exec(partial);
+	if (assigned?.[1] !== void 0 && assigned[2] !== void 0) {
+		const flag = toFlag(walked.flags, assigned[1]);
+		return flag?.valueName ? {
+			candidates: toValues(flag, assigned[2], `${assigned[1]}=`).candidates,
+			isFile: false
+		} : NOTHING;
+	}
+	if (partial.startsWith("-")) return {
+		candidates: toFlagCandidates(walked).filter((candidate) => candidate.value.startsWith(partial)),
+		isFile: false
+	};
+	const subcommands = toSubcommands(tree.commands, walked).filter((command) => !command.hidden && command.name.startsWith(partial)).map((command) => ({
+		value: command.name,
+		description: command.summary
+	}));
+	if (walked.command && walked.command.subcommands.length > 0 && !walked.command.runs) return {
+		candidates: subcommands,
+		isFile: false
+	};
+	return {
+		candidates: [...subcommands, ...toArgumentValues(walked, partial)],
+		isFile: false
+	};
+}
+/** toSubcommands lists the commands the next word may name. */
+function toSubcommands(commands, walked) {
+	if (!walked.command) return commands;
+	return walked.positionals === 0 ? walked.command.subcommands : [];
+}
+function toWalked(tree, words) {
+	let walked = {
+		flags: [
+			...tree.globalFlags,
+			VERSION_FLAG,
+			HELP_FLAG
+		],
+		used: /* @__PURE__ */ new Set(),
+		positionals: 0,
+		isUnknown: false
+	};
+	for (const word of words) {
+		if (walked.pending) {
+			walked.pending = void 0;
+			continue;
+		}
+		if (word.startsWith("-")) {
+			const flag = toFlag(walked.flags, word.split("=")[0] ?? word);
+			if (flag) walked.used.add(flag.name);
+			if (flag?.valueName && !word.includes("=")) walked.pending = flag;
+			continue;
+		}
+		const found = toSubcommands(tree.commands, walked).find((entry) => entry.name === word);
+		if (found) {
+			walked = {
+				command: found,
+				flags: [...found.flags, HELP_FLAG],
+				used: /* @__PURE__ */ new Set(),
+				positionals: 0,
+				isUnknown: false
+			};
+			continue;
+		}
+		if (walked.command?.arguments.length) {
+			walked.positionals += 1;
+			continue;
+		}
+		return {
+			...walked,
+			isUnknown: true
+		};
+	}
+	return walked;
+}
+/** toFlag finds the flag a word names, whether long, short, or the --no- form of a boolean. */
+function toFlag(flags, word) {
+	if (word.startsWith("--")) {
+		const name = word.slice(2);
+		return flags.find((flag) => flag.name === name || flag.negatable && `no-${flag.name}` === name);
+	}
+	return flags.find((flag) => flag.short !== void 0 && `-${flag.short}` === word);
+}
+function toFlagCandidates(walked) {
+	return walked.flags.filter((flag) => flag.repeatable || !walked.used.has(flag.name)).flatMap((flag) => {
+		const candidate = {
+			value: `--${flag.name}`,
+			description: flag.description
+		};
+		return flag.negatable ? [candidate, {
+			value: `--no-${flag.name}`,
+			description: `${flag.description}, turned off`
+		}] : [candidate];
+	});
+}
+/** toValues offers the values a flag takes, each written after the prefix the word already has. */
+function toValues(flag, partial, prefix) {
+	const values = flag.values;
+	if (values) {
+		const typed = partial.toLowerCase();
+		return {
+			candidates: values.filter((value) => value.toLowerCase().startsWith(typed)).map((value) => ({ value: `${prefix}${value}` })),
+			isFile: false
+		};
+	}
+	return {
+		candidates: [],
+		isFile: PATH_VALUES.has(flag.valueName ?? "")
+	};
+}
+function toArgumentValues(walked, partial) {
+	const declared = walked.command?.arguments ?? [];
+	const last = declared[declared.length - 1];
+	return ((walked.positionals < declared.length ? declared[walked.positionals] : last?.variadic ? last : void 0)?.values ?? []).filter((value) => value.startsWith(partial)).map((value) => ({ value }));
+}
+/** toLine keeps a description on one line, because a newline would start another candidate. */
+function toLine(description) {
+	return description.replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { toCompletion as n, toAnswer as t };