@nuxtseo/cli 0.1.0

package/dist/command-contract.js

@@ -0,0 +1,131 @@
+import { EXIT_CODE, fail, ok } from './failures.js';
+function staticValue(value) {
+    return typeof value === 'function' || value instanceof Promise ? undefined : value;
+}
+function commandArgs(command) {
+    return staticValue(command.args) ?? {};
+}
+function commandMeta(command) {
+    return staticValue(command.meta) ?? {};
+}
+function commandChildren(command) {
+    return staticValue(command.subCommands) ?? {};
+}
+function childCommand(value) {
+    return staticValue(value);
+}
+export function resolveCommand(root, rawArgs) {
+    let command = root;
+    const path = [commandMeta(root).name ?? 'nuxtseo'];
+    let index = 0;
+    while (index < rawArgs.length) {
+        const argument = rawArgs[index];
+        if (argument.startsWith('-'))
+            break;
+        const child = childCommand(commandChildren(command)[argument]);
+        if (!child)
+            break;
+        command = child;
+        path.push(argument);
+        index++;
+    }
+    return { command, path, remaining: rawArgs.slice(index) };
+}
+function argument(name, definition) {
+    const type = definition.type ?? 'string';
+    const alias = 'alias' in definition ? definition.alias : undefined;
+    const aliases = alias === undefined
+        ? undefined
+        : Array.isArray(alias) ? alias : [alias];
+    const options = 'options' in definition ? definition.options : undefined;
+    return {
+        name,
+        type,
+        required: definition.required === true,
+        ...(definition.description === undefined ? {} : { description: definition.description }),
+        ...(definition.valueHint === undefined ? {} : { valueHint: definition.valueHint }),
+        ...(aliases === undefined ? {} : { aliases }),
+        ...(options === undefined ? {} : { options: [...options] }),
+    };
+}
+function argumentsFor(command) {
+    return Object.entries(commandArgs(command)).map(([name, definition]) => argument(name, definition));
+}
+export function describeCommand(root, rawArgs, cliVersion) {
+    const resolved = resolveCommand(root, rawArgs.filter(argument => argument !== '--help' && argument !== '-h'));
+    const meta = commandMeta(resolved.command);
+    return {
+        _tag: 'CliHelp',
+        schemaVersion: 1,
+        cliVersion,
+        command: resolved.path.join(' '),
+        ...(meta.description === undefined ? {} : { description: meta.description }),
+        globalOptions: argumentsFor(root).filter(argument => argument.type !== 'positional'),
+        arguments: resolved.command === root ? [] : argumentsFor(resolved.command),
+        subcommands: Object.entries(commandChildren(resolved.command)).flatMap(([name, value]) => {
+            const child = childCommand(value);
+            if (!child)
+                return [];
+            const childMeta = commandMeta(child);
+            return [{ name, ...(childMeta.description === undefined ? {} : { description: childMeta.description }) }];
+        }),
+    };
+}
+function optionName(argument) {
+    const rawName = argument.slice(2).split('=', 1)[0];
+    return rawName.startsWith('no-')
+        ? { name: rawName.slice(3), negated: true }
+        : { name: rawName, negated: false };
+}
+export function validateCommandOptions(root, rawArgs) {
+    const resolved = resolveCommand(root, rawArgs);
+    const definitions = commandArgs(resolved.command);
+    const aliases = new Map();
+    for (const definition of Object.values(definitions)) {
+        const alias = 'alias' in definition ? definition.alias : undefined;
+        const names = alias === undefined
+            ? []
+            : Array.isArray(alias) ? alias : [alias];
+        for (const name of names)
+            aliases.set(name, definition);
+    }
+    for (let index = 0; index < resolved.remaining.length; index++) {
+        const token = resolved.remaining[index];
+        if (token === '--')
+            break;
+        if (token === '--help' || token === '-h')
+            continue;
+        if (token.startsWith('--')) {
+            const parsed = optionName(token);
+            const definition = definitions[parsed.name];
+            if (!definition || (parsed.negated && definition.type !== 'boolean')) {
+                return fail(EXIT_CODE.invalidInput, `invalid_cli_input: Unknown option ${JSON.stringify(token.split('=', 1)[0])}.`);
+            }
+            if (!token.includes('=')
+                && definition.type !== 'boolean'
+                && !resolved.remaining[index + 1]?.startsWith('-')) {
+                index++;
+            }
+            continue;
+        }
+        if (token.startsWith('-')) {
+            const definition = aliases.get(token.slice(1));
+            if (!definition)
+                return fail(EXIT_CODE.invalidInput, `invalid_cli_input: Unknown option ${JSON.stringify(token)}.`);
+            if (definition.type !== 'boolean' && !resolved.remaining[index + 1]?.startsWith('-'))
+                index++;
+        }
+    }
+    return ok(undefined);
+}
+export function commandWithGlobalOptions(root, command) {
+    if (command === root)
+        return command;
+    return {
+        ...command,
+        args: {
+            ...commandArgs(root),
+            ...commandArgs(command),
+        },
+    };
+}

package/dist/commands.d.ts

@@ -0,0 +1,8 @@
+import type { CommandDef } from 'citty';
+import type { CliResult } from './failures.js';
+import type { GlobalOptions } from './parse.js';
+import type { CliRuntime } from './runtime.js';
+export interface CommandExecution {
+    result: CliResult<void> | null;
+}
+export declare function createRootCommand(runtime: CliRuntime, globals: GlobalOptions, execution: CommandExecution): CommandDef<any>;