@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/short-flags-Qf21as0E.mjs

@@ -0,0 +1,83 @@
+import { a as resolved } from "./command-tree-CEkzWNy6.mjs";
+// src/short-flags.ts
+/**
+* Each flag's short form. A letter is given only where a well-known CLI uses it
+* for the same thing (`tail -f`, `git commit -m`, `head -n`); `-h` and `-v` are
+* help and version, and `-s` is no one's, as `--since`, `--status` and
+* `--severity` would all want it.
+*/
+const SHORT_FLAGS = {
+	all: "a",
+	detach: "d",
+	follow: "f",
+	input: "i",
+	limit: "n",
+	message: "m",
+	output: "o",
+	project: "p",
+	yes: "y"
+};
+/** `def` with `short` first among its aliases. */
+const withAlias = (def, short) => {
+	if (def.type === "positional") return def;
+	const given = "alias" in def ? [def.alias ?? []].flat() : [];
+	return {
+		...def,
+		alias: [short, ...given.filter((alias) => alias !== short)]
+	};
+};
+/** `args` with each flag's short form from {@link SHORT_FLAGS}. */
+const shortFlagsOf = (args) => {
+	const out = { ...args };
+	for (const [name, def] of Object.entries(args)) {
+		const short = SHORT_FLAGS[name];
+		if (short !== void 0) Reflect.set(out, name, withAlias(def, short));
+	}
+	return out;
+};
+/** Each subcommand wrapped once, so `worktrees` and `wt` stay one command. */
+const wrapped = /* @__PURE__ */ new WeakMap();
+const wrappedOnce = (cmd) => {
+	const known = wrapped.get(cmd);
+	if (known !== void 0) return known;
+	const out = withShortFlags(cmd);
+	wrapped.set(cmd, out);
+	return out;
+};
+/**
+* `cmd` and every command under it, loaded on use or not, with their flags'
+* short forms.
+*/
+const withShortFlags = (cmd) => {
+	const { args, subCommands } = cmd;
+	return {
+		...cmd,
+		...args === void 0 ? {} : { args: async () => shortFlagsOf(await resolved(args)) },
+		...subCommands === void 0 ? {} : { subCommands: async () => Object.fromEntries(Object.entries(await resolved(subCommands)).map(([name, sub]) => [name, async () => wrappedOnce(await resolved(sub))])) }
+	};
+};
+/** The spellings of the flag `--name` on a command line. */
+const spellingsOf = (name) => {
+	const short = SHORT_FLAGS[name];
+	return short === void 0 ? [`--${name}`] : [`--${name}`, `-${short}`];
+};
+/** Whether `arg` is the flag `--name` (a boolean), in either spelling. */
+const isFlag = (arg, name) => spellingsOf(name).includes(arg);
+/**
+* Every value given to the flag `--name` in `rawArgs`, in order: `--name v`,
+* `--name=v`, `-x v` and `-x=v` for its short form `-x`.
+*/
+const flagValues = (rawArgs, name) => {
+	const spellings = spellingsOf(name);
+	const values = [];
+	for (const [index, arg] of rawArgs.entries()) {
+		const joined = spellings.find((flag) => arg.startsWith(`${flag}=`));
+		if (joined !== void 0) values.push(arg.slice(joined.length + 1));
+		else if (spellings.includes(arg)) {
+			const value = rawArgs[index + 1];
+			if (value !== void 0) values.push(value);
+		}
+	}
+	return values;
+};
+export { withShortFlags as a, shortFlagsOf as i, flagValues as n, isFlag as r, SHORT_FLAGS as t };