@bomb.sh/router 0.7.0 → 0.7.1

package/src/lib/print.ts

@@ -1,216 +0,0 @@
-/**
- * 😵‍💫 This file has been vibe coded 😵‍💫
- */
-
-import type { AnyParam } from "./param.js";
-import type {
-  AnyRoute,
-  Help,
-  Issue,
-  MethodNotAllowed,
-  RoutePath,
-  UnprocessableContent,
-  Version,
-} from "./types.js";
-
-export function printHelp<
-  const H extends Help<RoutePath>,
->(intent: H): string {
-  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: Row[] = [];
-  let options: Row[] = [];
-
-  for (let param of params(route)) {
-    let syntax = param.cli.syntax;
-    if (!syntax) {
-      continue;
-    }
-
-    let row: 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<
-  const V extends Version<RoutePath>,
->(intent: V): string {
-  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: MethodNotAllowed | UnprocessableContent,
-): string {
-  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");
-    }
-  }
-}
-
-type Row = readonly [label: string, description?: string];
-
-function params(route: AnyRoute): AnyParam[] {
-  return route.phases.flatMap((phase) =>
-    Object.values(phase.model.params) as AnyParam[]
-  );
-}
-
-function title(intent: {
-  readonly path: readonly string[];
-  readonly definition: AnyRoute;
-}): string {
-  return intent.path.length > 0
-    ? intent.path.join(" ")
-    : intent.definition.name;
-}
-
-function list(rows: readonly Row[]): string[] {
-  let size = Math.max(...rows.map(([label]) => label.length));
-  let available = Math.max(24, width - size - 4);
-  let lines: string[] = [];
-
-  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: string, size: number): string[] {
-  let words = text.trim().split(/\s+/);
-  let lines: string[] = [];
-  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: Issue): string {
-  let location = address(issue.path);
-  return location ? `${location}: ${issue.message}` : message(issue.message);
-}
-
-function message(value: string): string {
-  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: Issue["path"]): string | undefined {
-  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/src/lib/read.ts

@@ -1,133 +0,0 @@
-import type { Maybe } from "./maybe.js";
-import type { AnyParam } from "./param.js";
-import { brand, 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 function cli(
-  names: readonly string[],
-  options: CLIOptions = {},
-): IdentityElement<AnyParam> {
-  const read: ReadCLI = (tokens) => {
-    if (options.switch) {
-      let s = tokens.claimOne((t): t is Flag => {
-        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): token is Setter => {
-      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): t is Flag => {
-      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<IdentityElement<AnyParam>>(
-    (param: AnyParam) => ({
-      ...param,
-      cli: {
-        read,
-        syntax: {
-          type: "option",
-          label: options.switch
-            ? names.join(", ")
-            : `${names.join(", ")} <VALUE>`,
-        },
-      },
-    }),
-  );
-}
-
-function nothing(tokenizer: TokenInput<Symbol>): CLIRead {
-  let claim = tokenizer.claimAll(() => false);
-
-  return {
-    claim,
-    result: {
-      ok: true,
-      value: { exists: false },
-      issues: [],
-    },
-  };
-}

package/src/lib/rest.ts

@@ -1,10 +0,0 @@
-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/src/lib/result.ts

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

package/src/lib/route.ts

@@ -1,77 +0,0 @@
-// deno-lint-ignore-file ban-types
-import {
-  brand,
-  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 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>> {
-  let zero: RouteZero<N> = {
-    ...start,
-    methods: ["help"],
-    phases: [{
-      model: {
-        params: {},
-        steps: [],
-      },
-      routes: [],
-      values: [],
-      envs: [],
-    }],
-  };
-
-  return elements.reduce<unknown>(
-    (value, element) => element(value as never),
-    zero,
-  ) as Materialize<Fold<RouteZero<N>, E>>;
-}
-
-export function version(semver: string): MethodElement<"version"> {
-  return brand<MethodElement<"version">>((route: AnyRoute) => ({
-    ...route,
-    methods: [...route.methods, "version"] as const,
-    version: semver,
-  }));
-}
-
-export function executable(): MethodElement<"execute"> {
-  return brand<MethodElement<"execute">>((route: AnyRoute) => ({
-    ...route,
-    methods: [...route.methods, "execute"] as const,
-  }));
-}
-
-export function routes<const C extends readonly AnyRoute[]>(
-  ...children: C
-): RoutesElement<C> {
-  return brand<RoutesElement<C>>((route: AnyRoute) => {
-    let phases = [...route.phases];
-    let phase = phases.pop()!;
-    phases.push({
-      ...phase,
-      routes: [...phase.routes, ...children],
-    });
-
-    return {
-      ...route,
-      phases,
-    };
-  });
-}

package/src/lib/toggle.ts

@@ -1,132 +0,0 @@
-import { boolean as decode } from "./decode.js";
-import { dasherize } from "./dasherize.js";
-import {
-  type AnyParam,
-  type Param,
-  param,
-  type ParamModel,
-  schema,
-} from "./param.js";
-import {
-  brand,
-  type Check,
-  type Fold,
-  type ModelElement,
-  type Unary,
-} from "./pipeline.js";
-import type { CLIRead, ReadCLI } from "./read.js";
-import type { Flag } from "./tokenize.js";
-import type { AnyRoute, Definition, Schema } from "./types.js";
-
-export 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>> {
-  const added = elements.reduce<unknown>(
-    (value, element) => element(value as never),
-    {
-      ...param(named, binding(named.name), schema(bool)),
-      decode,
-    },
-  ) as AnyParam;
-
-  return brand<ElementOf<N, Fold<Zero<N>, E>>>(
-    (route: AnyRoute) => {
-      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,
-      };
-    },
-  );
-}
-
-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;
-
-function binding(name: string): <P extends AnyParam>(param: P) => P {
-  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: string): ReadCLI {
-  const stem = dasherize(name);
-  const yes = `--${stem}`;
-  const no = `--no-${stem}`;
-
-  return (tokens): CLIRead => {
-    let claim = tokens.claimOne((token): token is Flag => {
-      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: Schema<boolean> = {
-  "~standard": {
-    version: 1,
-    vendor: "@bomb.sh/router",
-    validate(value) {
-      return typeof value === "undefined"
-        ? { value: false }
-        : typeof value === "boolean"
-        ? { value }
-        : { issues: [{ message: "expected boolean" }] };
-    },
-  },
-};

package/src/lib/tokenize.ts

@@ -1,74 +0,0 @@
-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 function tokenize(argv: string[]): readonly AnyToken[] {
-  let quote = false;
-  let tokens: AnyToken[] = [];
-
-  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]*)$/;