@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/load-route-map-worker.js

@@ -0,0 +1,92 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import * as process from 'node:process';
+import { pathToFileURL } from 'node:url';
+void run().catch((error) => {
+    if (error instanceof Error) {
+        process.stderr.write(`${error.message}\n`);
+    }
+    else {
+        process.stderr.write(`${String(error)}\n`);
+    }
+    setExitCode(1);
+});
+async function run() {
+    let routesFile = process.argv[2];
+    if (typeof routesFile !== 'string' || routesFile.length === 0) {
+        throw new Error('Missing app/routes.ts path.');
+    }
+    let tree = await loadRawRouteTree(routesFile);
+    process.stdout.write(JSON.stringify(tree));
+}
+async function loadRawRouteTree(routesFile) {
+    let routeModule = await import(__rewriteRelativeImportExtension(pathToFileURL(routesFile).href));
+    if (!('routes' in routeModule)) {
+        throw new Error(`Route module ${routesFile} must export a named "routes" value.`);
+    }
+    return normalizeRouteGroup(Reflect.get(routeModule, 'routes'), [], new Map());
+}
+function normalizeRouteGroup(value, parentSegments, seen) {
+    if (!isPlainObject(value)) {
+        let location = parentSegments.length === 0 ? 'routes' : parentSegments.join('.');
+        throw new Error(`Invalid route map value at "${location}". Expected a nested route object.`);
+    }
+    let existingPath = seen.get(value);
+    let currentPath = parentSegments.length === 0 ? 'routes' : parentSegments.join('.');
+    if (existingPath != null) {
+        throw new Error(`Detected a route map cycle at "${currentPath}" via "${existingPath}".`);
+    }
+    seen.set(value, currentPath);
+    try {
+        return Object.entries(value).map(([key, entryValue]) => {
+            let nameSegments = [...parentSegments, key];
+            let name = nameSegments.join('.');
+            if (isRouteLeaf(entryValue)) {
+                return {
+                    children: [],
+                    key,
+                    kind: 'route',
+                    method: entryValue.method,
+                    name,
+                    pattern: entryValue.pattern.source,
+                };
+            }
+            if (isPlainObject(entryValue)) {
+                return {
+                    children: normalizeRouteGroup(entryValue, nameSegments, seen),
+                    key,
+                    kind: 'group',
+                    name,
+                };
+            }
+            throw new Error(`Invalid route map value at "${name}". Expected a route or nested route object.`);
+        });
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+function isRouteLeaf(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        typeof Reflect.get(value, 'method') === 'string' &&
+        typeof Reflect.get(value, 'pattern') === 'object' &&
+        Reflect.get(value, 'pattern') != null &&
+        typeof Reflect.get(Reflect.get(value, 'pattern'), 'source') === 'string');
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value == null) {
+        return false;
+    }
+    let prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function setExitCode(exitCode) {
+    globalThis.process.exitCode = exitCode;
+}

package/dist/lib/parse-args.d.ts

@@ -0,0 +1,22 @@
+export interface ParseArgsBooleanOptionSpec {
+    flag: string;
+    type: 'boolean';
+}
+export interface ParseArgsStringOptionSpec {
+    flag: string;
+    type: 'string';
+}
+export type ParseArgsOptionSpec = ParseArgsBooleanOptionSpec | ParseArgsStringOptionSpec;
+export type ParseArgsOptionDefinitions = Record<string, ParseArgsOptionSpec>;
+export interface ParseArgsOptions {
+    maxPositionals?: number;
+}
+export type ParsedArgsValues<definitions extends ParseArgsOptionDefinitions> = {
+    [key in keyof definitions]: definitions[key]['type'] extends 'boolean' ? boolean : string | undefined;
+};
+export interface ParsedArgsResult<definitions extends ParseArgsOptionDefinitions> {
+    options: ParsedArgsValues<definitions>;
+    positionals: string[];
+}
+export declare function parseArgs<const definitions extends ParseArgsOptionDefinitions>(argv: string[], definitions: definitions, options?: ParseArgsOptions): ParsedArgsResult<definitions>;
+//# sourceMappingURL=parse-args.d.ts.map

package/dist/lib/parse-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-args.d.ts","sourceRoot":"","sources":["../../src/lib/parse-args.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,SAAS,CAAA;CAChB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;CACf;AAED,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,GAAG,yBAAyB,CAAA;AAExF,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;AAE5E,MAAM,WAAW,gBAAgB;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,MAAM,gBAAgB,CAAC,WAAW,SAAS,0BAA0B,IAAI;KAC5E,GAAG,IAAI,MAAM,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,SAAS,SAAS,GAClE,OAAO,GACP,MAAM,GAAG,SAAS;CACvB,CAAA;AAED,MAAM,WAAW,gBAAgB,CAAC,WAAW,SAAS,0BAA0B;IAC9E,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAA;IACtC,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB;AAED,wBAAgB,SAAS,CAAC,KAAK,CAAC,WAAW,SAAS,0BAA0B,EAC5E,IAAI,EAAE,MAAM,EAAE,EACd,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,gBAAqB,GAC7B,gBAAgB,CAAC,WAAW,CAAC,CA8C/B"}

package/dist/lib/parse-args.js

@@ -0,0 +1,35 @@
+import { missingOptionValue, unexpectedExtraArgument, unknownArgument } from "./errors.js";
+export function parseArgs(argv, definitions, options = {}) {
+    let values = {};
+    let specsByFlag = new Map();
+    let positionals = [];
+    for (let [key, spec] of Object.entries(definitions)) {
+        values[key] = (spec.type === 'boolean' ? false : undefined);
+        specsByFlag.set(spec.flag, { key, spec });
+    }
+    for (let index = 0; index < argv.length; index++) {
+        let arg = argv[index];
+        let resolved = specsByFlag.get(arg);
+        if (resolved != null) {
+            if (resolved.spec.type === 'boolean') {
+                values[resolved.key] = true;
+                continue;
+            }
+            let next = argv[index + 1];
+            if (next == null || next.startsWith('-')) {
+                throw missingOptionValue(arg);
+            }
+            values[resolved.key] = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            throw unknownArgument(arg);
+        }
+        if (options.maxPositionals != null && positionals.length >= options.maxPositionals) {
+            throw unexpectedExtraArgument(arg);
+        }
+        positionals.push(arg);
+    }
+    return { options: values, positionals };
+}

package/dist/lib/remix-version.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveDefaultRemixVersion(cwd?: string): Promise<string | undefined>;
+//# sourceMappingURL=remix-version.d.ts.map

package/dist/lib/remix-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remix-version.d.ts","sourceRoot":"","sources":["../../src/lib/remix-version.ts"],"names":[],"mappings":"AAWA,wBAAsB,0BAA0B,CAC9C,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAO7B"}

package/dist/lib/remix-version.js

@@ -0,0 +1,58 @@
+import * as fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { fileURLToPath } from 'node:url';
+export async function resolveDefaultRemixVersion(cwd = process.cwd()) {
+    for (let packageJsonPath of getRemixPackageJsonCandidates(cwd)) {
+        let version = await readRemixPackageVersion(packageJsonPath);
+        if (version != null) {
+            return version;
+        }
+    }
+}
+function getRemixPackageJsonCandidates(cwd) {
+    let candidates = [];
+    let seen = new Set();
+    function addCandidate(filePath) {
+        if (filePath == null) {
+            return;
+        }
+        let resolvedPath = path.resolve(filePath);
+        if (seen.has(resolvedPath)) {
+            return;
+        }
+        seen.add(resolvedPath);
+        candidates.push(resolvedPath);
+    }
+    function addResolvedPackageJson(basePath) {
+        try {
+            addCandidate(createRequire(basePath).resolve('remix/package.json'));
+        }
+        catch { }
+    }
+    addResolvedPackageJson(path.join(cwd, 'package.json'));
+    if (process.argv[1] != null) {
+        addResolvedPackageJson(path.resolve(process.argv[1]));
+    }
+    addResolvedPackageJson(import.meta.url);
+    addCandidate(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../remix/package.json'));
+    return candidates;
+}
+async function readRemixPackageVersion(packageJsonPath) {
+    let packageJson;
+    try {
+        packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (packageJson.name !== 'remix') {
+        return undefined;
+    }
+    if (typeof packageJson.version !== 'string') {
+        return undefined;
+    }
+    let version = packageJson.version.trim();
+    return version.length === 0 ? undefined : version;
+}

package/dist/lib/reporter.d.ts

@@ -0,0 +1,56 @@
+interface StepProgressLabel {
+    complete: string;
+    running?: string;
+}
+export interface CommandReporter {
+    finish(): void;
+    out: TextChannel;
+    status: StatusChannel;
+}
+export interface TableOptions {
+    headers: string[];
+    noHeaders?: boolean;
+    rows: string[][];
+    formatRow?: (line: string, rowIndex: number) => string;
+}
+export interface TextChannel {
+    blank(): void;
+    bullet(text: string): void;
+    bullets(items: string[]): void;
+    dedent(): void;
+    indent(): void;
+    label(tag: string, text: string, options?: LabelOptions): string;
+    line(text?: string): void;
+    section(title: string, callback?: () => void): void;
+    table(options: TableOptions): void;
+    withIndent<result>(callback: () => result): result;
+}
+export interface StatusChannel extends TextChannel {
+    commandHeader(commandLabel: string): Promise<void>;
+    failStep(label?: string): void;
+    skipStep(label: string, reason?: string): void;
+    startStep(label: string): void;
+    succeedStep(label?: string): void;
+    summaryGap(): void;
+}
+export interface LabelOptions {
+    tone?: 'error' | 'warn';
+}
+export interface CreateCommandReporterOptions {
+    remixVersion?: string;
+    stderr?: NodeJS.WriteStream;
+    statusFrameIntervalMs?: number;
+    stdout?: NodeJS.WriteStream;
+}
+export interface StepProgressReporter<step extends string> {
+    fail(step: step): void;
+    skip(step: step, reason?: string): void;
+    start(step: step): void;
+    succeed(step: step): void;
+    writeSummaryGap(): void;
+}
+export declare function createCommandReporter(options?: CreateCommandReporterOptions): CommandReporter;
+export declare function createStepProgressReporter<step extends string>(status: StatusChannel, labels: Record<step, string | StepProgressLabel>): StepProgressReporter<step>;
+export declare function runProgressStep<step extends string, result>(progress: StepProgressReporter<step> | null | undefined, step: step, callback: () => Promise<result>): Promise<result>;
+export {};
+//# sourceMappingURL=reporter.d.ts.map

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

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

package/dist/lib/reporter.js

@@ -0,0 +1,357 @@
+import * as process from 'node:process';
+import { bold, canUseAnsi, clearCurrentLine, lightGray, lightGreen, lightRed, lightYellow, remixWordmark, } from "./terminal.js";
+const BULLET = '•';
+const DOT_FRAMES = ['.', '..', '...'];
+const DEFAULT_INDENT = '  ';
+const DEFAULT_STATUS_FRAME_INTERVAL_MS = 250;
+export function createCommandReporter(options = {}) {
+    let stdout = options.stdout ?? process.stdout;
+    let stderr = options.stderr ?? process.stderr;
+    let session = new ReporterSessionState();
+    let states = new Map();
+    let getState = (stream) => {
+        let state = states.get(stream);
+        if (state != null) {
+            return state;
+        }
+        state = new ReporterStreamState(stream, session);
+        states.set(stream, state);
+        return state;
+    };
+    return {
+        finish() {
+            for (let state of states.values()) {
+                state.finish();
+            }
+        },
+        out: new ReporterTextChannel(stdout, getState(stdout)),
+        status: new ReporterStatusChannel(stderr, getState(stderr), options.statusFrameIntervalMs ?? DEFAULT_STATUS_FRAME_INTERVAL_MS, options.remixVersion),
+    };
+}
+export function createStepProgressReporter(status, labels) {
+    return {
+        fail(step) {
+            status.failStep(getCompleteLabel(labels[step]));
+        },
+        skip(step, reason) {
+            status.skipStep(getCompleteLabel(labels[step]), reason);
+        },
+        start(step) {
+            status.startStep(getRunningLabel(labels[step]));
+        },
+        succeed(step) {
+            status.succeedStep(getCompleteLabel(labels[step]));
+        },
+        writeSummaryGap() {
+            status.summaryGap();
+        },
+    };
+}
+export async function runProgressStep(progress, step, callback) {
+    progress?.start(step);
+    try {
+        let result = await callback();
+        progress?.succeed(step);
+        return result;
+    }
+    catch (error) {
+        progress?.fail(step);
+        throw error;
+    }
+}
+class ReporterTextChannel {
+    #indentLevel = 0;
+    #state;
+    #stream;
+    constructor(stream, state) {
+        this.#stream = stream;
+        this.#state = state;
+    }
+    blank() {
+        if (!this.#state.hasWrittenContent()) {
+            return;
+        }
+        this.#state.queueBlank();
+    }
+    bullet(text) {
+        this.line(`${BULLET} ${text}`);
+    }
+    bullets(items) {
+        for (let item of items) {
+            this.bullet(item);
+        }
+    }
+    dedent() {
+        this.#indentLevel = Math.max(0, this.#indentLevel - 1);
+    }
+    indent() {
+        this.#indentLevel += 1;
+    }
+    label(tag, text, options) {
+        let line = text.length === 0 ? formatLabel(tag) : `${formatLabel(tag)} ${text}`;
+        if (options?.tone === 'warn') {
+            return lightYellow(line, this.#stream);
+        }
+        if (options?.tone === 'error') {
+            return lightRed(line, this.#stream);
+        }
+        return line;
+    }
+    line(text = '') {
+        if (text.length === 0) {
+            this.blank();
+            return;
+        }
+        this.#flushPendingBlank();
+        this.#write(`${this.#getIndent()}${text}\n`);
+    }
+    section(title, callback) {
+        this.line(title);
+        if (callback == null) {
+            return;
+        }
+        this.withIndent(callback);
+    }
+    table({ formatRow, headers, noHeaders = false, rows }) {
+        let columnCount = Math.max(headers.length, ...rows.map((row) => row.length));
+        let widths = Array.from({ length: columnCount }, (_, columnIndex) => {
+            let headerWidth = headers[columnIndex]?.length ?? 0;
+            let rowWidth = rows.reduce((width, row) => Math.max(width, row[columnIndex]?.length ?? 0), 0);
+            return Math.max(headerWidth, rowWidth);
+        });
+        if (!noHeaders) {
+            this.line(headers
+                .map((header, columnIndex) => bold(header.padEnd(widths[columnIndex] ?? header.length), this.#stream))
+                .join('  '));
+        }
+        rows.forEach((row, rowIndex) => {
+            let line = row
+                .map((cell, columnIndex) => cell.padEnd(widths[columnIndex] ?? cell.length))
+                .join('  ');
+            this.line(formatRow == null ? line : formatRow(line, rowIndex));
+        });
+    }
+    withIndent(callback) {
+        this.indent();
+        try {
+            return callback();
+        }
+        finally {
+            this.dedent();
+        }
+    }
+    getStream() {
+        return this.#stream;
+    }
+    writeImmediate(text) {
+        this.#state.writeImmediate(text);
+    }
+    getIndentText() {
+        return this.#getIndent();
+    }
+    #flushPendingBlank() {
+        this.#state.flushPendingBlank();
+    }
+    #getIndent() {
+        return DEFAULT_INDENT.repeat(this.#indentLevel);
+    }
+    #write(text) {
+        this.#state.write(text);
+    }
+}
+class ReporterStatusChannel extends ReporterTextChannel {
+    #activeLabel = null;
+    #activeTimer = null;
+    #frameIndex = 0;
+    #frameIntervalMs;
+    #hasRenderedStep = false;
+    #hasWrittenSummaryGap = false;
+    #remixVersion;
+    constructor(stream, state, frameIntervalMs, remixVersion) {
+        super(stream, state);
+        this.#frameIntervalMs = frameIntervalMs;
+        this.#remixVersion = remixVersion;
+    }
+    async commandHeader(commandLabel) {
+        if (!this.getStream().isTTY || this.#remixVersion == null) {
+            return;
+        }
+        this.writeImmediate(`${remixWordmark(this.getStream())} v${this.#remixVersion} - ${commandLabel}\n\n`);
+    }
+    failStep(label = this.#activeLabel ?? '') {
+        this.#stopAnimation();
+        this.#activeLabel = null;
+        this.#noteStepOutput();
+        this.#writeFinalLine(this.#formatFailedLine(label));
+    }
+    skipStep(label, reason) {
+        this.#stopAnimation();
+        if (this.#activeLabel === label) {
+            this.#activeLabel = null;
+        }
+        this.#noteStepOutput();
+        this.#writeFinalLine(this.#formatSkippedLine(label, reason));
+    }
+    startStep(label) {
+        this.#stopAnimation();
+        this.#activeLabel = label;
+        this.#noteStepOutput();
+        if (this.#isInteractive()) {
+            this.#frameIndex = 0;
+            this.writeImmediate(this.#renderLiveLine(this.#formatRunningLine(label, DOT_FRAMES[0])));
+            this.#activeTimer = setInterval(() => {
+                if (this.#activeLabel == null) {
+                    return;
+                }
+                this.#frameIndex = (this.#frameIndex + 1) % DOT_FRAMES.length;
+                this.writeImmediate(this.#renderLiveLine(this.#formatRunningLine(this.#activeLabel, DOT_FRAMES[this.#frameIndex])));
+            }, this.#frameIntervalMs);
+            this.#activeTimer.unref?.();
+            return;
+        }
+        this.writeImmediate(`${this.#formatRunningLine(label, '...')}\n`);
+    }
+    succeedStep(label = this.#activeLabel ?? '') {
+        this.#stopAnimation();
+        this.#activeLabel = null;
+        this.#noteStepOutput();
+        this.#writeFinalLine(this.#formatSucceededLine(label));
+    }
+    summaryGap() {
+        if (!this.#hasRenderedStep || this.#hasWrittenSummaryGap) {
+            return;
+        }
+        this.writeImmediate('\n');
+        this.#hasWrittenSummaryGap = true;
+    }
+    #formatFailedLine(label) {
+        return `${this.getIndentText()}${lightRed('✗', this.getStream())} ${lightGray(label, this.getStream())}`;
+    }
+    #formatRunningLine(label, dots) {
+        return lightGray(`${this.getIndentText()}${BULLET} ${label}${dots}`, this.getStream());
+    }
+    #formatSkippedLine(label, reason) {
+        let line = reason == null ? `${BULLET} ${label}` : `${BULLET} ${label} (skipped: ${reason})`;
+        return lightGray(`${this.getIndentText()}${line}`, this.getStream());
+    }
+    #formatSucceededLine(label) {
+        return `${this.getIndentText()}${lightGreen('✓', this.getStream())} ${lightGray(label, this.getStream())}`;
+    }
+    #isInteractive() {
+        return canUseAnsi(this.getStream());
+    }
+    #noteStepOutput() {
+        this.#hasRenderedStep = true;
+        this.#hasWrittenSummaryGap = false;
+    }
+    #renderLiveLine(line) {
+        return `${clearCurrentLine()}${line}`;
+    }
+    #stopAnimation() {
+        if (this.#activeTimer != null) {
+            clearInterval(this.#activeTimer);
+            this.#activeTimer = null;
+        }
+    }
+    #writeFinalLine(line) {
+        if (this.#isInteractive()) {
+            this.writeImmediate(`${this.#renderLiveLine(line)}\n`);
+            return;
+        }
+        this.writeImmediate(`${line}\n`);
+    }
+}
+class ReporterStreamState {
+    #hasWrittenContent = false;
+    #pendingBlank = false;
+    #session;
+    #stream;
+    #trailingNewlineCount = 0;
+    constructor(stream, session) {
+        this.#session = session;
+        this.#stream = stream;
+    }
+    finish() {
+        if (!this.#hasWrittenContent) {
+            return;
+        }
+        if (this.#trailingNewlineCount >= 2) {
+            return;
+        }
+        this.#writeRaw('\n');
+        this.#pendingBlank = false;
+    }
+    flushPendingBlank() {
+        if (!this.#pendingBlank) {
+            return;
+        }
+        this.#writeRaw('\n');
+        this.#pendingBlank = false;
+    }
+    hasWrittenContent() {
+        return this.#hasWrittenContent;
+    }
+    queueBlank() {
+        this.#pendingBlank = true;
+    }
+    write(text) {
+        if (!this.#session.hasWrittenPreamble()) {
+            this.#writeRaw('\n');
+            this.#session.markPreambleWritten();
+        }
+        this.#writeRaw(text);
+        this.#hasWrittenContent = true;
+    }
+    writeImmediate(text) {
+        if (!this.#session.hasWrittenPreamble()) {
+            this.#writeRaw('\n');
+            this.#session.markPreambleWritten();
+        }
+        this.#writeRaw(text);
+        this.#hasWrittenContent = true;
+        this.#pendingBlank = false;
+    }
+    #writeRaw(text) {
+        this.#stream.write(text);
+        this.#updateTrailingNewlines(text);
+    }
+    #updateTrailingNewlines(text) {
+        let trailingNewlines = 0;
+        for (let index = text.length - 1; index >= 0; index--) {
+            if (text[index] !== '\n') {
+                break;
+            }
+            trailingNewlines += 1;
+        }
+        if (trailingNewlines === 0) {
+            this.#trailingNewlineCount = 0;
+            return;
+        }
+        if (trailingNewlines === text.length) {
+            this.#trailingNewlineCount += trailingNewlines;
+            return;
+        }
+        this.#trailingNewlineCount = trailingNewlines;
+    }
+}
+class ReporterSessionState {
+    #hasWrittenPreamble = false;
+    hasWrittenPreamble() {
+        return this.#hasWrittenPreamble;
+    }
+    markPreambleWritten() {
+        this.#hasWrittenPreamble = true;
+    }
+}
+function formatLabel(tag) {
+    if (tag.startsWith('[') && tag.endsWith(']')) {
+        return tag;
+    }
+    return `[${tag}]`;
+}
+function getCompleteLabel(label) {
+    return typeof label === 'string' ? label : label.complete;
+}
+function getRunningLabel(label) {
+    return typeof label === 'string' ? label : (label.running ?? label.complete);
+}

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

@@ -0,0 +1,38 @@
+export type RouteOwnerKind = 'action' | 'controller';
+export type RouteTreeNodeKind = 'group' | 'route';
+export interface RouteTreeOwner {
+    exists: boolean;
+    kind: RouteOwnerKind;
+    path: string;
+}
+export interface RouteTreeNode {
+    children: RouteTreeNode[];
+    key: string;
+    kind: RouteTreeNodeKind;
+    method?: string;
+    name: string;
+    owner: RouteTreeOwner;
+    pattern?: string;
+}
+export interface LoadedRouteMap {
+    appRoot: string;
+    routesFile: string;
+    tree: RouteTreeNode[];
+}
+export interface LoadedRouteManifest {
+    appRoot: string;
+    routesFile: string;
+    tree: RawRouteTreeNode[];
+}
+export interface RawRouteTreeNode {
+    children: RawRouteTreeNode[];
+    key: string;
+    kind: RouteTreeNodeKind;
+    method?: string;
+    name: string;
+    pattern?: string;
+}
+export declare function loadRouteMap(cwd?: string): Promise<LoadedRouteMap>;
+export declare function loadRouteManifest(cwd?: string): Promise<LoadedRouteManifest>;
+export declare function loadRouteManifestFromAppRoot(appRoot: string): Promise<LoadedRouteManifest>;
+//# sourceMappingURL=route-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"route-map.d.ts","sourceRoot":"","sources":["../../src/lib/route-map.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,YAAY,CAAA;AACpD,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,CAAA;AAEjD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,cAAc,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,aAAa,EAAE,CAAA;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,gBAAgB,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,wBAAsB,YAAY,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAUvF;AAED,wBAAsB,iBAAiB,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAGjG;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAShG"}