@jsnix/pastel/build/generate-arguments.js

Framework for effortlessly building Ink apps

import { isDeepStrictEqual } from 'node:util';
import { Argument } from 'commander';
import { ZodArray, ZodDefault, ZodEnum, ZodNumber, ZodOptional, ZodTuple, } from 'zod';
import decamelize from 'decamelize';
const getConfig = (value) => {
    return value?.startsWith('__pastel_argument_config__')
        ? JSON.parse(value.replace('__pastel_argument_config__', ''))
        : undefined;
};
const getName = (value) => {
    return getConfig(value)?.name ?? value;
};
const getDescription = (value) => {
    return getConfig(value)?.description;
};
const getDefaultValueDescription = (value) => {
    return getConfig(value)?.defaultValueDescription;
};
export default function generateArguments(argumentsSchema) {
    let isOptionalByDefault = false;
    let arrayDefaultValue;
    let arrayName = getName(argumentsSchema.description);
    const arrayDescription = getDescription(argumentsSchema.description);
    const arrayDefaultValueDescription = getDefaultValueDescription(argumentsSchema.description);
    if (argumentsSchema instanceof ZodOptional) {
        isOptionalByDefault = true;
        argumentsSchema = argumentsSchema._def.innerType;
        arrayName = argumentsSchema.description ?? arrayName;
    }
    if (argumentsSchema instanceof ZodDefault) {
        isOptionalByDefault = true;
        arrayDefaultValue = argumentsSchema._def.defaultValue();
        argumentsSchema = argumentsSchema._def.innerType;
        arrayName = argumentsSchema.description ?? arrayName;
    }
    if (argumentsSchema instanceof ZodOptional) {
        isOptionalByDefault = true;
        argumentsSchema = argumentsSchema._def.innerType;
        arrayName = argumentsSchema.description ?? arrayName;
    }
    const arguments_ = [];
    if (argumentsSchema instanceof ZodTuple) {
        for (let argumentSchema of argumentsSchema._def.items) {
            let isOptional = isOptionalByDefault;
            let defaultValue;
            const defaultValueDescription = getDefaultValueDescription(argumentSchema.description);
            let name = getName(argumentSchema.description);
            const description = getDescription(argumentSchema.description);
            if (argumentSchema instanceof ZodOptional) {
                isOptional = true;
                argumentSchema = argumentSchema._def.innerType;
                name = getName(argumentSchema.description) ?? name;
            }
            if (argumentSchema instanceof ZodDefault) {
                isOptional = true;
                defaultValue = argumentSchema._def.defaultValue();
                argumentSchema = argumentSchema._def.innerType;
                name = getName(argumentSchema.description) ?? name;
            }
            if (argumentSchema instanceof ZodOptional) {
                isOptional = true;
                argumentSchema = argumentSchema._def.innerType;
                name = getName(argumentSchema.description) ?? name;
            }
            name = decamelize(name ?? 'arg', { separator: '-' });
            const argument = new Argument(isOptional ? `[${name}]` : `<${name}>`, description);
            if (argumentSchema instanceof ZodNumber) {
                argument.argParser(value => Number.parseFloat(value));
            }
            if (argumentSchema instanceof ZodEnum) {
                argument.choices(argumentSchema._def.values);
            }
            if (defaultValue !== undefined) {
                argument.default(defaultValue, defaultValueDescription);
            }
            arguments_.push(argument);
        }
        const restSchema = argumentsSchema._def.rest;
        if (restSchema) {
            const name = getName(restSchema.description) ?? 'arg';
            const argument = new Argument(`[${name}...]`);
            if (restSchema instanceof ZodNumber) {
                argument.argParser((value, previousValue) => {
                    return [...(previousValue ?? []), Number.parseFloat(value)];
                });
            }
            if (restSchema instanceof ZodEnum) {
                argument.choices(restSchema._def.values);
            }
            arguments_.push(argument);
        }
    }
    if (argumentsSchema instanceof ZodArray) {
        const name = arrayName ?? 'arg';
        const argument = new Argument(isOptionalByDefault ? `[${name}...]` : `<${name}...>`, arrayDescription);
        if (arrayDefaultValue !== undefined) {
            argument.default(arrayDefaultValue, arrayDefaultValueDescription);
        }
        if (argumentsSchema.element instanceof ZodNumber) {
            argument.argParser((value, previousValue) => {
                const joinPreviousValue = !isDeepStrictEqual(previousValue, arrayDefaultValue);
                return joinPreviousValue
                    ? [...(previousValue ?? []), Number.parseFloat(value)]
                    : [Number.parseFloat(value)];
            });
        }
        arguments_.push(argument);
    }
    return arguments_;
}
//# sourceMappingURL=generate-arguments.js.map