@bomb.sh/router 0.0.1 → 0.7.1

package/esm/lib/print.js

@@ -0,0 +1,156 @@
+/**
+ * 😵‍💫 This file has been vibe coded 😵‍💫
+ */
+export function printHelp(intent) {
+    let route = intent.definition;
+    let subject = title(intent);
+    let heading = route.version ? `${subject} ${route.version}` : subject;
+    let children = route.phases.flatMap((phase) => phase.routes);
+    let args = [];
+    let options = [];
+    for (let param of params(route)) {
+        let syntax = param.cli.syntax;
+        if (!syntax) {
+            continue;
+        }
+        let row = [syntax.label, param.description];
+        if (syntax.type === "argument") {
+            args.push(row);
+        }
+        else {
+            options.push(row);
+        }
+    }
+    let usage = [subject, "[OPTIONS]", ...args.map(([label]) => label)].join(" ");
+    if (children.length > 0) {
+        usage += route.methods.includes("execute") ? " [COMMAND]" : " <COMMAND>";
+    }
+    let lines = [heading];
+    if (route.description) {
+        lines.push(...wrap(route.description, width));
+    }
+    lines.push("", "Usage:", `  ${usage}`);
+    if (args.length > 0) {
+        lines.push("", "Arguments:", ...list(args));
+    }
+    if (children.length > 0) {
+        lines.push("", "Commands:", ...list(children.map((child) => [child.name, child.description])));
+    }
+    options.push(["-h, --help", "Print help"]);
+    if (route.methods.includes("version")) {
+        options.push(["-v, --version", "Print version"]);
+    }
+    lines.push("", "Options:", ...list(options));
+    return lines.join("\n");
+}
+export function printVersion(intent) {
+    let version = intent.definition.version;
+    if (!version) {
+        throw new TypeError(`route ${JSON.stringify(intent.route)} has no version`);
+    }
+    return `${title(intent)} ${version}`;
+}
+export function printErrors(result) {
+    let subject = title(result);
+    switch (result.code) {
+        case "method-not-allowed":
+            return [
+                `${subject} does not support ${result.method.toUpperCase()}`,
+                "",
+                "Available methods:",
+                ...result.allowed.map((method) => `  ${method.toUpperCase()}`),
+            ].join("\n");
+        case "unprocessable-content": {
+            return result.issues.map(problem).join("\n");
+        }
+    }
+}
+function params(route) {
+    return route.phases.flatMap((phase) => Object.values(phase.model.params));
+}
+function title(intent) {
+    return intent.path.length > 0
+        ? intent.path.join(" ")
+        : intent.definition.name;
+}
+function list(rows) {
+    let size = Math.max(...rows.map(([label]) => label.length));
+    let available = Math.max(24, width - size - 4);
+    let lines = [];
+    for (let [label, description] of rows) {
+        let prefix = `  ${label.padEnd(size)}`;
+        if (!description) {
+            lines.push(prefix.trimEnd());
+            continue;
+        }
+        let [first, ...rest] = wrap(description, available);
+        lines.push(`${prefix}  ${first}`);
+        lines.push(...rest.map((line) => `${" ".repeat(size + 4)}${line}`));
+    }
+    return lines;
+}
+function wrap(text, size) {
+    let words = text.trim().split(/\s+/);
+    let lines = [];
+    let line = "";
+    for (let word of words) {
+        if (line.length === 0) {
+            line = word;
+        }
+        else if (line.length + word.length + 1 <= size) {
+            line += ` ${word}`;
+        }
+        else {
+            lines.push(line);
+            line = word;
+        }
+    }
+    if (line) {
+        lines.push(line);
+    }
+    return lines;
+}
+function problem(issue) {
+    let location = address(issue.path);
+    return location ? `${location}: ${issue.message}` : message(issue.message);
+}
+function message(value) {
+    if (value.startsWith("unexpected ")) {
+        let encoded = value.slice("unexpected ".length);
+        try {
+            let token = JSON.parse(encoded);
+            if (typeof token === "string") {
+                return `unexpected: \`${token.replaceAll("`", "\\`")}\``;
+            }
+        }
+        catch {
+            // Keep non-JSON diagnostics intact.
+        }
+    }
+    return value;
+}
+function address(path) {
+    if (!path || path.length === 0) {
+        return;
+    }
+    let result = "";
+    for (let segment of path) {
+        let key = typeof segment === "object" && segment !== null
+            ? segment.key
+            : segment;
+        if (typeof key === "number") {
+            result += `[${key}]`;
+        }
+        else if (typeof key === "symbol") {
+            result += `[${String(key)}]`;
+        }
+        else if (/^[A-Za-z_$][\w$]*$/.test(key)) {
+            result += result ? `.${key}` : key;
+        }
+        else {
+            result += `[${JSON.stringify(key)}]`;
+        }
+    }
+    return result;
+}
+const width = 80;

package/esm/lib/read.d.ts

@@ -0,0 +1,27 @@
+import type { Maybe } from "./maybe.js";
+import type { AnyParam } from "./param.js";
+import { type IdentityElement } from "./pipeline.js";
+import type { Result } from "./result.js";
+import type { Flag, Setter, Word } from "./tokenize.js";
+import type { Claim, TokenInput } from "./tokenizer.js";
+export type Symbol = Flag | Setter | Word;
+export type ReadCLI = (tokens: TokenInput<Symbol>) => CLIRead;
+export interface CLIBinding {
+    readonly read: ReadCLI;
+    readonly syntax?: CLISyntax;
+}
+export type CLISyntax = {
+    readonly type: "argument";
+    readonly label: string;
+} | {
+    readonly type: "option";
+    readonly label: string;
+};
+export interface CLIRead {
+    result: Result<Maybe<string | boolean>>;
+    claim: Claim<Symbol>;
+}
+export interface CLIOptions {
+    switch?: true;
+}
+export declare function cli(names: readonly string[], options?: CLIOptions): IdentityElement<AnyParam>;

package/esm/lib/read.js

@@ -0,0 +1,95 @@
+import { brand } from "./pipeline.js";
+export function cli(names, options = {}) {
+    const read = (tokens) => {
+        if (options.switch) {
+            let s = tokens.claimOne((t) => {
+                return t.type === "flag" && names.includes(t.text);
+            });
+            let [flag] = s.tokens;
+            return flag
+                ? {
+                    result: {
+                        ok: true,
+                        value: { exists: true, value: true },
+                        issues: [],
+                    },
+                    claim: s,
+                }
+                : nothing(tokens);
+        }
+        let setter = tokens.claimOne((token) => {
+            return (token.type === "setter" && names.includes(`--${token.nameText}`));
+        });
+        let [token] = setter.tokens;
+        if (token) {
+            return {
+                claim: setter,
+                result: {
+                    ok: true,
+                    value: {
+                        exists: true,
+                        value: token.valueText,
+                    },
+                    issues: [],
+                },
+            };
+        }
+        let pair = tokens.claimPair((name, value) => {
+            return name.type === "flag" && names.includes(name.text) &&
+                value.type === "word";
+        });
+        let [, value] = pair.tokens;
+        if (value) {
+            return {
+                claim: pair,
+                result: {
+                    ok: true,
+                    value: {
+                        exists: true,
+                        value: value.text,
+                    },
+                    issues: [],
+                },
+            };
+        }
+        let bare = tokens.claimOne((t) => {
+            return t.type === "flag" && names.includes(t.text);
+        });
+        let [incomplete] = bare.tokens;
+        if (incomplete) {
+            return {
+                claim: bare,
+                result: {
+                    ok: false,
+                    issues: [{
+                            message: `${incomplete.text} requires a value`,
+                        }],
+                },
+            };
+        }
+        return nothing(tokens);
+    };
+    return brand((param) => ({
+        ...param,
+        cli: {
+            read,
+            syntax: {
+                type: "option",
+                label: options.switch
+                    ? names.join(", ")
+                    : `${names.join(", ")} <VALUE>`,
+            },
+        },
+    }));
+}
+function nothing(tokenizer) {
+    let claim = tokenizer.claimAll(() => false);
+    return {
+        claim,
+        result: {
+            ok: true,
+            value: { exists: false },
+            issues: [],
+        },
+    };
+}

package/esm/lib/rest.d.ts

@@ -0,0 +1,9 @@
+import type { Envs } from "./env.js";
+import type { Symbol } from "./read.js";
+import type { Tokenizer } from "./tokenizer.js";
+import type { Values } from "./values.js";
+export interface Rest {
+    readonly tokens: Tokenizer<Symbol>;
+    readonly values: Values;
+    readonly envs: Envs;
+}

package/esm/lib/rest.js

@@ -0,0 +1 @@
+export {};

package/esm/lib/result.d.ts

@@ -0,0 +1,9 @@
+import type { Issue } from "./types.js";
+export type Result<T> = {
+    ok: true;
+    value: T;
+    issues?: readonly Issue[];
+} | {
+    ok: false;
+    issues: readonly Issue[];
+};

package/esm/lib/result.js

@@ -0,0 +1 @@
+export {};

package/esm/lib/route.d.ts

@@ -0,0 +1,9 @@
+import { type Check, type Fold, type Materialize, type MethodElement, type RoutesElement, type Unary } from "./pipeline.js";
+import type { AnyRoute, Definition, Done, Route } from "./types.js";
+export type RouteZero<N extends string = string> = Route<N, "help", [
+    Done<{}, []>
+]>;
+export declare function route<const N extends string, const E extends readonly Unary[]>(start: Definition<N>, ...elements: E & Check<RouteZero<N>, E>): Materialize<Fold<RouteZero<N>, E>>;
+export declare function version(semver: string): MethodElement<"version">;
+export declare function executable(): MethodElement<"execute">;
+export declare function routes<const C extends readonly AnyRoute[]>(...children: C): RoutesElement<C>;

package/esm/lib/route.js

@@ -0,0 +1,45 @@
+// deno-lint-ignore-file ban-types
+import { brand, } from "./pipeline.js";
+export function route(start, ...elements) {
+    let zero = {
+        ...start,
+        methods: ["help"],
+        phases: [{
+                model: {
+                    params: {},
+                    steps: [],
+                },
+                routes: [],
+                values: [],
+                envs: [],
+            }],
+    };
+    return elements.reduce((value, element) => element(value), zero);
+}
+export function version(semver) {
+    return brand((route) => ({
+        ...route,
+        methods: [...route.methods, "version"],
+        version: semver,
+    }));
+}
+export function executable() {
+    return brand((route) => ({
+        ...route,
+        methods: [...route.methods, "execute"],
+    }));
+}
+export function routes(...children) {
+    return brand((route) => {
+        let phases = [...route.phases];
+        let phase = phases.pop();
+        phases.push({
+            ...phase,
+            routes: [...phase.routes, ...children],
+        });
+        return {
+            ...route,
+            phases,
+        };
+    });
+}

package/esm/lib/toggle.d.ts

@@ -0,0 +1,7 @@
+import { type Param, type ParamModel } from "./param.js";
+import { type Check, type Fold, type ModelElement, type Unary } from "./pipeline.js";
+import type { Definition } from "./types.js";
+export declare function toggle<const N extends string, const E extends readonly Unary[]>(named: Definition<N>, ...elements: E & Check<Zero<N>, E>): ElementOf<N, Fold<Zero<N>, E>>;
+type Zero<N extends string> = Param<N, boolean, "one">;
+type ElementOf<N extends string, P> = P extends Param<N, infer Model, infer _Cardinality> ? ModelElement<ParamModel<N, Model>> : never;
+export {};

package/esm/lib/toggle.js

@@ -0,0 +1,91 @@
+import { boolean as decode } from "./decode.js";
+import { dasherize } from "./dasherize.js";
+import { param, schema, } from "./param.js";
+import { brand, } from "./pipeline.js";
+export function toggle(named, ...elements) {
+    const added = elements.reduce((value, element) => element(value), {
+        ...param(named, binding(named.name), schema(bool)),
+        decode,
+    });
+    return brand((route) => {
+        let phases = [...route.phases];
+        let phase = phases.pop();
+        phases.push({
+            ...phase,
+            model: {
+                params: {
+                    ...phase.model.params,
+                    [added.name]: added,
+                },
+                steps: phase.model.steps.concat((current, bindings) => ({
+                    ok: true,
+                    value: {
+                        ...current,
+                        [added.name]: bindings[added.name],
+                    },
+                })),
+            },
+        });
+        return {
+            ...route,
+            phases,
+        };
+    });
+}
+function binding(name) {
+    const stem = dasherize(name);
+    const yes = `--${stem}`;
+    const no = `--no-${stem}`;
+    return (param) => ({
+        ...param,
+        cli: {
+            read: reader(name),
+            syntax: {
+                type: "option",
+                label: `${yes}, ${no}`,
+            },
+        },
+    });
+}
+function reader(name) {
+    const stem = dasherize(name);
+    const yes = `--${stem}`;
+    const no = `--no-${stem}`;
+    return (tokens) => {
+        let claim = tokens.claimOne((token) => {
+            return token.type === "flag" &&
+                (token.text === yes || token.text === no);
+        });
+        let [flag] = claim.tokens;
+        return flag
+            ? {
+                claim,
+                result: {
+                    ok: true,
+                    value: { exists: true, value: flag.text === yes },
+                    issues: [],
+                },
+            }
+            : {
+                claim,
+                result: {
+                    ok: true,
+                    value: { exists: false },
+                    issues: [],
+                },
+            };
+    };
+}
+const bool = {
+    "~standard": {
+        version: 1,
+        vendor: "@bomb.sh/router",
+        validate(value) {
+            return typeof value === "undefined"
+                ? { value: false }
+                : typeof value === "boolean"
+                    ? { value }
+                    : { issues: [{ message: "expected boolean" }] };
+        },
+    },
+};

package/esm/lib/tokenize.d.ts

@@ -0,0 +1,20 @@
+export interface Token<T extends string> {
+    type: T;
+    index: number;
+    text: string;
+}
+export type AnyToken = Word | Flag | Setter | Separator | Literal;
+export interface Setter extends Token<"setter"> {
+    nameText: string;
+    valueText: string;
+}
+export interface Flag extends Token<"flag"> {
+    flagText: string;
+    flagType: "short" | "long";
+}
+export type Word = Token<"word">;
+export interface Separator extends Token<"separator"> {
+    readonly text: "--";
+}
+export type Literal = Token<"literal">;
+export declare function tokenize(argv: string[]): readonly AnyToken[];

package/esm/lib/tokenize.js

@@ -0,0 +1,41 @@
+export function tokenize(argv) {
+    let quote = false;
+    let tokens = [];
+    for (let i = 0; i < argv.length; i++) {
+        let index = i;
+        let text = argv[i];
+        if (quote) {
+            tokens.push({ type: "literal", index, text });
+            continue;
+        }
+        if (text === "--") {
+            tokens.push({ type: "separator", index, text });
+            quote = true;
+            continue;
+        }
+        let matchSetter = setterMatch.exec(text);
+        if (matchSetter?.groups) {
+            let { nameText, valueText } = matchSetter.groups;
+            tokens.push({ type: "setter", index, text, nameText, valueText });
+            continue;
+        }
+        let matchFlag = flagMatch.exec(text);
+        if (matchFlag?.groups) {
+            let { prefix, flagText } = matchFlag.groups;
+            tokens.push({
+                type: "flag",
+                index,
+                text,
+                flagText,
+                flagType: prefix === "-" ? "short" : "long",
+            });
+            continue;
+        }
+        tokens.push({ type: "word", index, text });
+    }
+    return tokens;
+}
+// deno-lint-ignore no-invalid-regexp
+const flagMatch = /^(?<prefix>--?)(?<flagText>[^-=\s][^=\s]*)$/;
+// deno-lint-ignore no-invalid-regexp
+const setterMatch = /^--(?<nameText>[^-=\s][^=\s]*)=(?<valueText>[\s\S]*)$/;

package/esm/lib/tokenizer.d.ts

@@ -0,0 +1,34 @@
+import type { AnyToken } from "./tokenize.js";
+export interface TokenInput<T extends AnyToken> extends Iterable<T> {
+    claimNext(): Claim<T>;
+    claimOne<S extends T>(match: (token: T) => token is S): Claim<S, T>;
+    claimOne(match: (token: T) => boolean): Claim<T, T>;
+    claimPair(match: (a: T, b: T) => boolean): Claim<T, T>;
+    claimAll<S extends T>(match: (token: T) => token is S): Claim<S, T>;
+    claimAll(match: (token: T) => boolean): Claim<T, T>;
+}
+export interface TokenRange {
+    readonly start: number;
+    readonly end?: number;
+}
+export interface ViewOptions {
+    readonly range: TokenRange;
+    readonly through?: number;
+}
+export declare class Tokenizer<T extends AnyToken> implements TokenInput<T> {
+    readonly tokens: readonly T[];
+    readonly claimed: ReadonlySet<number>;
+    constructor(tokens: readonly T[], claimed?: ReadonlySet<number>);
+    claimNext(): Claim<T>;
+    claimOne<S extends T>(match: (token: T) => token is S): Claim<S, T>;
+    claimOne(match: (token: T) => boolean): Claim<T, T>;
+    claimPair(match: (a: T, b: T) => boolean): Claim<T, T>;
+    claimAll<S extends T>(match: (token: T) => token is S): Claim<S, T>;
+    claimAll(match: (token: T) => boolean): Claim<T, T>;
+    view(options: ViewOptions): TokenInput<T>;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}
+export interface Claim<T extends AnyToken, R extends AnyToken = T> {
+    tokens: T[];
+    rest: Tokenizer<R>;
+}

package/esm/lib/tokenizer.js

@@ -0,0 +1,130 @@
+export class Tokenizer {
+    tokens;
+    claimed;
+    constructor(tokens, claimed = new Set()) {
+        this.tokens = tokens;
+        this.claimed = new Set(claimed);
+    }
+    claimNext() {
+        return this.claimOne(() => true);
+    }
+    claimOne(match) {
+        for (let token of this) {
+            if (match(token)) {
+                return {
+                    tokens: [token],
+                    rest: remainder(this, [token.index]),
+                };
+            }
+        }
+        return { tokens: [], rest: this };
+    }
+    claimPair(match) {
+        let previous;
+        for (let token of this) {
+            if (!previous) {
+                previous = token;
+                continue;
+            }
+            if (token.index === previous.index + 1 && match(previous, token)) {
+                return {
+                    tokens: [previous, token],
+                    rest: remainder(this, [previous.index, token.index]),
+                };
+            }
+            previous = token;
+        }
+        return { tokens: [], rest: this };
+    }
+    claimAll(match) {
+        let tokens = [];
+        let claimed = new Set();
+        for (let token of this) {
+            if (match(token)) {
+                claimed.add(token.index);
+                tokens.push(token);
+            }
+        }
+        return {
+            tokens,
+            rest: tokens.length > 0 ? remainder(this, claimed) : this,
+        };
+    }
+    view(options) {
+        return new View(this, options);
+    }
+    *[Symbol.iterator]() {
+        for (let token of this.tokens) {
+            if (!this.claimed.has(token.index)) {
+                yield token;
+            }
+        }
+    }
+}
+class View {
+    source;
+    options;
+    constructor(source, options) {
+        this.source = source;
+        this.options = options;
+    }
+    claimNext() {
+        return this.claimOne(() => true);
+    }
+    claimOne(match) {
+        for (let token of this) {
+            if (match(token)) {
+                return {
+                    tokens: [token],
+                    rest: remainder(this.source, [token.index]),
+                };
+            }
+        }
+        return { tokens: [], rest: this.source };
+    }
+    claimPair(match) {
+        let previous;
+        for (let token of this) {
+            if (!previous) {
+                previous = token;
+                continue;
+            }
+            if (token.index === previous.index + 1 && match(previous, token)) {
+                return {
+                    tokens: [previous, token],
+                    rest: remainder(this.source, [previous.index, token.index]),
+                };
+            }
+            previous = token;
+        }
+        return { tokens: [], rest: this.source };
+    }
+    claimAll(match) {
+        let tokens = [];
+        let claimed = new Set();
+        for (let token of this) {
+            if (match(token)) {
+                claimed.add(token.index);
+                tokens.push(token);
+            }
+        }
+        return {
+            tokens,
+            rest: tokens.length > 0 ? remainder(this.source, claimed) : this.source,
+        };
+    }
+    *[Symbol.iterator]() {
+        let { start, end } = this.options.range;
+        let { through } = this.options;
+        for (let token of this.source) {
+            if (token.index > start &&
+                (end === undefined || token.index < end) &&
+                (through === undefined || token.index <= through)) {
+                yield token;
+            }
+        }
+    }
+}
+function remainder(source, claimed) {
+    return new Tokenizer(source.tokens, new Set([...source.claimed, ...claimed]));
+}