@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/doctor/types.d.ts

@@ -0,0 +1,48 @@
+export type DoctorSuiteName = 'environment' | 'project' | 'controllers';
+export type DoctorFindingSeverity = 'warn' | 'advice';
+export type DoctorSuiteStatus = 'ok' | 'issues' | 'skipped';
+export type DoctorFindingCode = 'project-root-not-found' | 'package-json-read-failed' | 'package-json-invalid' | 'node-engine-missing' | 'node-engine-unparseable' | 'node-version-unsupported' | 'remix-dependency-missing' | 'remix-install-missing' | 'routes-file-missing' | 'routes-export-missing' | 'route-map-invalid' | 'route-module-import-failed' | 'route-map-invalid-json' | 'route-map-loader-signal' | 'missing-owner' | 'wrong-owner-kind' | 'ambiguous-owner' | 'duplicate-owner-file' | 'incomplete-controller' | 'promotion-drift' | 'orphan-action' | 'orphan-controller' | 'orphan-route-directory';
+export type DoctorFixKind = 'create-directory' | 'create-file' | 'update-file';
+export interface DoctorFinding {
+    actualPath?: string;
+    code: DoctorFindingCode;
+    expectedPath?: string;
+    fixable?: boolean;
+    message: string;
+    routeName?: string;
+    severity: DoctorFindingSeverity;
+    suite: DoctorSuiteName;
+}
+export interface DoctorFixPlan {
+    code: DoctorFindingCode;
+    contents?: string;
+    kind: DoctorFixKind;
+    path: string;
+    routeName?: string;
+    suite: DoctorSuiteName;
+}
+export interface DoctorAppliedFix {
+    code: DoctorFindingCode;
+    kind: DoctorFixKind;
+    path: string;
+    routeName?: string;
+    suite: DoctorSuiteName;
+}
+export interface DoctorSuiteResult {
+    appliedFixes?: DoctorAppliedFix[];
+    findings: DoctorFinding[];
+    name: DoctorSuiteName;
+    reason?: string;
+    status: DoctorSuiteStatus;
+}
+export interface DoctorReport {
+    appliedFixes?: DoctorAppliedFix[];
+    appRoot?: string;
+    findings: DoctorFinding[];
+    remainingFindings?: DoctorFinding[];
+    routesFile?: string;
+    suites: DoctorSuiteResult[];
+}
+export declare function createDoctorSuite(name: DoctorSuiteName, findings: DoctorFinding[]): DoctorSuiteResult;
+export declare function createSkippedDoctorSuite(name: DoctorSuiteName, reason: string): DoctorSuiteResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/doctor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,SAAS,GAAG,aAAa,CAAA;AACvE,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,QAAQ,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE3D,MAAM,MAAM,iBAAiB,GACzB,wBAAwB,GACxB,0BAA0B,GAC1B,sBAAsB,GACtB,qBAAqB,GACrB,yBAAyB,GACzB,0BAA0B,GAC1B,0BAA0B,GAC1B,uBAAuB,GACvB,qBAAqB,GACrB,uBAAuB,GACvB,mBAAmB,GACnB,4BAA4B,GAC5B,wBAAwB,GACxB,yBAAyB,GACzB,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,uBAAuB,GACvB,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,wBAAwB,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG,aAAa,GAAG,aAAa,CAAA;AAE9E,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,iBAAiB,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,qBAAqB,CAAA;IAC/B,KAAK,EAAE,eAAe,CAAA;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,eAAe,CAAA;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,iBAAiB,CAAA;IACvB,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,eAAe,CAAA;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,gBAAgB,EAAE,CAAA;IACjC,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,IAAI,EAAE,eAAe,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,iBAAiB,CAAA;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,gBAAgB,EAAE,CAAA;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,iBAAiB,CAAC,EAAE,aAAa,EAAE,CAAA;IACnC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,iBAAiB,EAAE,CAAA;CAC5B;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,aAAa,EAAE,GACxB,iBAAiB,CAMnB;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAOjG"}

package/dist/lib/doctor/types.js

@@ -0,0 +1,15 @@
+export function createDoctorSuite(name, findings) {
+    return {
+        findings,
+        name,
+        status: findings.some((finding) => finding.severity === 'warn') ? 'issues' : 'ok',
+    };
+}
+export function createSkippedDoctorSuite(name, reason) {
+    return {
+        findings: [],
+        name,
+        reason,
+        status: 'skipped',
+    };
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,167 @@
+export interface CliErrorDefinition {
+    code: string;
+    docsUrl?: string;
+    fix?: string;
+    title: string;
+}
+export type CliErrorContext = Record<string, boolean | number | string | null | undefined>;
+export interface CliErrorOptions {
+    code: string;
+    context?: CliErrorContext;
+    docsUrl?: string;
+    fix?: string;
+    message: string;
+    showHelp?: boolean;
+    title: string;
+}
+export declare const CLI_ERROR_DEFINITIONS: {
+    appNameUnavailable: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    remixVersionUnavailable: {
+        code: string;
+        title: string;
+    };
+    invalidCompletionRequest: {
+        code: string;
+        title: string;
+    };
+    fetchUnavailable: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    internalError: {
+        code: string;
+        title: string;
+    };
+    invalidFlagCombination: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    invalidPackageName: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    missingOptionValue: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    missingTargetDirectory: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    projectRootNotFound: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    remoteSkillDataMissing: {
+        code: string;
+        title: string;
+    };
+    routeMapLoaderFailed: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    routeMapLoaderInvalidJson: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    routeMapLoaderSignal: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    routeOwnerPlanUnresolved: {
+        code: string;
+        title: string;
+    };
+    routesFileNotFound: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    targetDirectoryNotEmpty: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    targetPathNotDirectory: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    unexpectedExtraArgument: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    unknownArgument: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    unknownCommand: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    unknownCompletionShell: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+    unknownHelpTopic: {
+        code: string;
+        title: string;
+        fix: string;
+    };
+};
+export declare class CliError extends Error {
+    code: string;
+    context?: CliErrorContext;
+    docsUrl?: string;
+    fix?: string;
+    showHelp: boolean;
+    title: string;
+    constructor(options: CliErrorOptions);
+}
+export declare class UsageError extends CliError {
+    constructor(options: CliErrorOptions);
+}
+export declare function appNameUnavailable(targetDir?: string): UsageError;
+export declare function remixVersionUnavailable(): CliError;
+export declare function invalidCompletionRequest(): CliError;
+export declare function fetchUnavailable(): CliError;
+export declare function invalidFlagCombination(details: string): UsageError;
+export declare function invalidPackageName(input: string): UsageError;
+export declare function missingOptionValue(option: string): UsageError;
+export declare function missingTargetDirectory(): UsageError;
+export declare function projectRootNotFound(startDir?: string): CliError;
+export declare function remoteSkillDataMissing(name: string): CliError;
+export declare function routeMapLoaderFailed(details: string): CliError;
+export declare function routeMapLoaderInvalidJson(): CliError;
+export declare function routeMapLoaderSignal(signal: NodeJS.Signals): CliError;
+export declare function routeOwnerPlanUnresolved(routeName: string): CliError;
+export declare function routesFileNotFound(startDir?: string): CliError;
+export declare function targetDirectoryNotEmpty(targetDir: string): UsageError;
+export declare function targetPathNotDirectory(targetDir: string): UsageError;
+export declare function toCliError(error: unknown): CliError;
+export declare function unknownArgument(argument: string): UsageError;
+export declare function unknownCommand(command: string): UsageError;
+export declare function unknownCompletionShell(shell: string): UsageError;
+export declare function unknownHelpTopic(topic: string): UsageError;
+export declare function unexpectedExtraArgument(argument: string): UsageError;
+export declare function renderCliError(error: unknown, options?: {
+    helpText?: string;
+}): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/lib/errors.ts"],"names":[],"mappings":"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"}

package/dist/lib/errors.js

@@ -0,0 +1,307 @@
+export const CLI_ERROR_DEFINITIONS = {
+    appNameUnavailable: {
+        code: 'RMX_APP_NAME_UNAVAILABLE',
+        title: 'Could not determine an app name',
+        fix: 'Pass --app-name or choose a target directory name that can become an app name.',
+    },
+    remixVersionUnavailable: {
+        code: 'RMX_REMIX_VERSION_UNAVAILABLE',
+        title: 'Could not determine the Remix version',
+    },
+    invalidCompletionRequest: {
+        code: 'RMX_INVALID_COMPLETION_REQUEST',
+        title: 'Invalid completion request',
+    },
+    fetchUnavailable: {
+        code: 'RMX_FETCH_UNAVAILABLE',
+        title: 'This runtime does not provide fetch()',
+        fix: 'Run the Remix CLI in a runtime that provides fetch().',
+    },
+    internalError: {
+        code: 'RMX_INTERNAL_ERROR',
+        title: 'Unexpected Remix CLI error',
+    },
+    invalidFlagCombination: {
+        code: 'RMX_INVALID_FLAG_COMBINATION',
+        title: 'Invalid flag combination',
+        fix: 'Remove one of the conflicting flags and try again.',
+    },
+    invalidPackageName: {
+        code: 'RMX_INVALID_PACKAGE_NAME',
+        title: 'Could not derive a valid package name',
+        fix: 'Choose an app name that can be normalized into a valid npm package name.',
+    },
+    missingOptionValue: {
+        code: 'RMX_MISSING_OPTION_VALUE',
+        title: 'Missing option value',
+        fix: 'Pass a value immediately after the option.',
+    },
+    missingTargetDirectory: {
+        code: 'RMX_MISSING_TARGET_DIRECTORY',
+        title: 'Missing target directory',
+        fix: 'Pass a target directory, for example `remix new my-remix-app`.',
+    },
+    projectRootNotFound: {
+        code: 'RMX_PROJECT_ROOT_NOT_FOUND',
+        title: 'Could not find a project root',
+        fix: 'Run this command inside a Remix project.',
+    },
+    remoteSkillDataMissing: {
+        code: 'RMX_REMOTE_SKILL_DATA_MISSING',
+        title: 'Could not find remote Remix skill data',
+    },
+    routeMapLoaderFailed: {
+        code: 'RMX_ROUTE_MAP_LOADER_FAILED',
+        title: 'Route-map loader failed',
+        fix: 'Check app/routes.ts and make sure it exports a named `routes` value with a valid route map.',
+    },
+    routeMapLoaderInvalidJson: {
+        code: 'RMX_ROUTE_MAP_LOADER_INVALID_JSON',
+        title: 'Route-map loader returned invalid JSON',
+        fix: 'Check app/routes.ts and make sure route-map loading does not write extra output.',
+    },
+    routeMapLoaderSignal: {
+        code: 'RMX_ROUTE_MAP_LOADER_SIGNAL',
+        title: 'Route-map loader exited from a signal',
+        fix: 'Check app/routes.ts for side effects or runtime issues and try again.',
+    },
+    routeOwnerPlanUnresolved: {
+        code: 'RMX_ROUTE_OWNER_PLAN_UNRESOLVED',
+        title: 'Could not resolve a route owner plan',
+    },
+    routesFileNotFound: {
+        code: 'RMX_ROUTES_FILE_NOT_FOUND',
+        title: 'Could not find app/routes.ts',
+        fix: 'Run this command inside a Remix app that has app/routes.ts.',
+    },
+    targetDirectoryNotEmpty: {
+        code: 'RMX_TARGET_DIRECTORY_NOT_EMPTY',
+        title: 'Target directory is not empty',
+        fix: 'Re-run with --force to continue.',
+    },
+    targetPathNotDirectory: {
+        code: 'RMX_TARGET_PATH_NOT_DIRECTORY',
+        title: 'Target path is not a directory',
+        fix: 'Choose a directory path for the new app target.',
+    },
+    unexpectedExtraArgument: {
+        code: 'RMX_UNEXPECTED_ARGUMENT',
+        title: 'Unexpected extra argument',
+        fix: 'Remove the extra argument or run the command with --help.',
+    },
+    unknownArgument: {
+        code: 'RMX_UNKNOWN_ARGUMENT',
+        title: 'Unknown argument',
+        fix: 'Run the command with --help to see supported arguments.',
+    },
+    unknownCommand: {
+        code: 'RMX_UNKNOWN_COMMAND',
+        title: 'Unknown command',
+        fix: 'Run `remix help` to see available commands.',
+    },
+    unknownCompletionShell: {
+        code: 'RMX_UNKNOWN_COMPLETION_SHELL',
+        title: 'Unknown completion shell',
+        fix: 'Run `remix completion bash` or `remix completion zsh`.',
+    },
+    unknownHelpTopic: {
+        code: 'RMX_UNKNOWN_HELP_TOPIC',
+        title: 'Unknown help topic',
+        fix: 'Run `remix help` to see available commands and help topics.',
+    },
+};
+export class CliError extends Error {
+    code;
+    context;
+    docsUrl;
+    fix;
+    showHelp;
+    title;
+    constructor(options) {
+        super(options.message);
+        this.code = options.code;
+        this.context = options.context;
+        this.docsUrl = options.docsUrl;
+        this.fix = options.fix;
+        this.name = 'CliError';
+        this.showHelp = options.showHelp ?? false;
+        this.title = options.title;
+    }
+}
+export class UsageError extends CliError {
+    constructor(options) {
+        super({ ...options, showHelp: options.showHelp ?? true });
+        this.name = 'UsageError';
+    }
+}
+export function appNameUnavailable(targetDir) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.appNameUnavailable, {
+        context: targetDir == null ? undefined : { targetDir },
+        message: 'Could not determine an app name from the target directory.',
+    });
+}
+export function remixVersionUnavailable() {
+    return createCliError(CLI_ERROR_DEFINITIONS.remixVersionUnavailable, {
+        message: 'Could not determine the current Remix version.',
+    });
+}
+export function invalidCompletionRequest() {
+    return createCliError(CLI_ERROR_DEFINITIONS.invalidCompletionRequest, {
+        message: 'Invalid completion request.',
+    });
+}
+export function fetchUnavailable() {
+    return createCliError(CLI_ERROR_DEFINITIONS.fetchUnavailable, {
+        message: 'This runtime does not provide fetch().',
+    });
+}
+export function invalidFlagCombination(details) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.invalidFlagCombination, {
+        context: { details },
+        message: details,
+    });
+}
+export function invalidPackageName(input) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.invalidPackageName, {
+        context: { input },
+        message: `Could not derive a valid package name from "${input}".`,
+    });
+}
+export function missingOptionValue(option) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.missingOptionValue, {
+        context: { option },
+        message: `${option} requires a value.`,
+    });
+}
+export function missingTargetDirectory() {
+    return createUsageError(CLI_ERROR_DEFINITIONS.missingTargetDirectory, {
+        message: 'A target directory is required.',
+    });
+}
+export function projectRootNotFound(startDir) {
+    return createCliError(CLI_ERROR_DEFINITIONS.projectRootNotFound, {
+        context: startDir == null ? undefined : { startDir },
+        message: 'Could not find a project root. Run this command inside a Remix project.',
+    });
+}
+export function remoteSkillDataMissing(name) {
+    return createCliError(CLI_ERROR_DEFINITIONS.remoteSkillDataMissing, {
+        context: { name },
+        message: `Could not find remote data for Remix skill: ${name}`,
+    });
+}
+export function routeMapLoaderFailed(details) {
+    return createCliError(CLI_ERROR_DEFINITIONS.routeMapLoaderFailed, {
+        context: { details },
+        message: details,
+    });
+}
+export function routeMapLoaderInvalidJson() {
+    return createCliError(CLI_ERROR_DEFINITIONS.routeMapLoaderInvalidJson, {
+        message: 'Route-map loader returned invalid JSON.',
+    });
+}
+export function routeMapLoaderSignal(signal) {
+    return createCliError(CLI_ERROR_DEFINITIONS.routeMapLoaderSignal, {
+        context: { signal },
+        message: `Route-map loader exited from signal ${signal}.`,
+    });
+}
+export function routeOwnerPlanUnresolved(routeName) {
+    return createCliError(CLI_ERROR_DEFINITIONS.routeOwnerPlanUnresolved, {
+        context: { routeName },
+        message: `Could not resolve owner plan for "${routeName}".`,
+    });
+}
+export function routesFileNotFound(startDir) {
+    return createCliError(CLI_ERROR_DEFINITIONS.routesFileNotFound, {
+        context: startDir == null ? undefined : { startDir },
+        message: 'Could not find app/routes.ts. Run this command inside a Remix app.',
+    });
+}
+export function targetDirectoryNotEmpty(targetDir) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.targetDirectoryNotEmpty, {
+        context: { targetDir },
+        message: `Target directory is not empty: ${targetDir}. Re-run with --force to continue.`,
+    });
+}
+export function targetPathNotDirectory(targetDir) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.targetPathNotDirectory, {
+        context: { targetDir },
+        message: `Target path is not a directory: ${targetDir}`,
+    });
+}
+export function toCliError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return createCliError(CLI_ERROR_DEFINITIONS.internalError, { message: error.message });
+    }
+    return createCliError(CLI_ERROR_DEFINITIONS.internalError, { message: String(error) });
+}
+export function unknownArgument(argument) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.unknownArgument, {
+        context: { argument },
+        message: `Unknown argument: ${argument}`,
+    });
+}
+export function unknownCommand(command) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.unknownCommand, {
+        context: { command },
+        message: `Unknown command: ${command}`,
+    });
+}
+export function unknownCompletionShell(shell) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.unknownCompletionShell, {
+        context: { shell },
+        message: `Unknown completion shell: ${shell}`,
+    });
+}
+export function unknownHelpTopic(topic) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.unknownHelpTopic, {
+        context: { topic },
+        message: `Unknown help topic: ${topic}`,
+    });
+}
+export function unexpectedExtraArgument(argument) {
+    return createUsageError(CLI_ERROR_DEFINITIONS.unexpectedExtraArgument, {
+        context: { argument },
+        message: `Unexpected extra argument: ${argument}`,
+    });
+}
+export function renderCliError(error, options = {}) {
+    let cliError = toCliError(error);
+    let lines = [`Error [${cliError.code}] ${cliError.title}`, cliError.message];
+    if (cliError.fix != null && cliError.fix.length > 0) {
+        lines.push('', 'Try:', `  ${cliError.fix}`);
+    }
+    if (cliError.docsUrl != null && cliError.docsUrl.length > 0) {
+        lines.push('', 'Documentation:', `  ${cliError.docsUrl}`);
+    }
+    let output = `${lines.join('\n')}\n`;
+    if (cliError.showHelp && options.helpText != null) {
+        output += `\n${options.helpText}`;
+    }
+    return output;
+}
+function createCliError(definition, options) {
+    return new CliError({
+        code: definition.code,
+        context: options.context,
+        docsUrl: definition.docsUrl,
+        fix: definition.fix,
+        message: options.message,
+        title: definition.title,
+    });
+}
+function createUsageError(definition, options) {
+    return new UsageError({
+        code: definition.code,
+        context: options.context,
+        docsUrl: definition.docsUrl,
+        fix: definition.fix,
+        message: options.message,
+        title: definition.title,
+    });
+}

package/dist/lib/help-text.d.ts

@@ -0,0 +1,13 @@
+export interface HelpTextSectionRow {
+    description: string;
+    label: string;
+}
+export interface HelpTextOptions {
+    commands?: HelpTextSectionRow[];
+    description?: string;
+    examples?: string[];
+    options?: HelpTextSectionRow[];
+    usage: string[];
+}
+export declare function formatHelpText(options: HelpTextOptions, target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=help-text.d.ts.map

package/dist/lib/help-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help-text.d.ts","sourceRoot":"","sources":["../../src/lib/help-text.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB;AAKD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,eAAe,EACxB,MAAM,GAAE,MAAM,CAAC,WAA4B,GAC1C,MAAM,CAoBR"}

package/dist/lib/help-text.js

@@ -0,0 +1,43 @@
+import * as process from 'node:process';
+import { boldLightBlue, lightYellow } from "./terminal.js";
+const SECTION_INDENT = '  ';
+const ROW_GAP = 2;
+export function formatHelpText(options, target = process.stdout) {
+    let sections = [renderUsageSection(options.usage, target)];
+    if (options.description != null && options.description.length > 0) {
+        sections.push(options.description);
+    }
+    if (options.commands != null && options.commands.length > 0) {
+        sections.push(renderRowSection('Commands', options.commands, target));
+    }
+    if (options.options != null && options.options.length > 0) {
+        sections.push(renderRowSection('Options', options.options, target));
+    }
+    if (options.examples != null && options.examples.length > 0) {
+        sections.push(renderExamplesSection(options.examples, target));
+    }
+    return `${sections.join('\n\n')}\n`;
+}
+function renderUsageSection(usage, target) {
+    return renderSection('Usage', usage.map((line) => `${SECTION_INDENT}${highlightSyntax(line, target)}`), target);
+}
+function renderExamplesSection(examples, target) {
+    return renderSection('Examples', examples.map((line) => `${SECTION_INDENT}${highlightSyntax(line, target)}`), target);
+}
+function renderRowSection(title, rows, target) {
+    let labelWidth = rows.reduce((width, row) => Math.max(width, row.label.length), 0) + ROW_GAP;
+    let lines = rows.map((row) => {
+        let paddedLabel = row.label.padEnd(labelWidth);
+        return `${SECTION_INDENT}${highlightSyntax(paddedLabel, target)}${row.description}`;
+    });
+    return renderSection(title, lines, target);
+}
+function renderSection(title, lines, target) {
+    return `${formatHeading(title, target)}:\n${lines.join('\n')}`;
+}
+function formatHeading(title, target) {
+    return boldLightBlue(title, target);
+}
+function highlightSyntax(text, target) {
+    return text.replace(/(--[A-Za-z0-9-]+|-[A-Za-z]|\[[A-Za-z][A-Za-z0-9-]*\]|<[^>\n]+>)/g, (token) => lightYellow(token, target));
+}

package/dist/lib/load-route-map-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=load-route-map-worker.d.ts.map

package/dist/lib/load-route-map-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-route-map-worker.d.ts","sourceRoot":"","sources":["../../src/lib/load-route-map-worker.ts"],"names":[],"mappings":""}