@bronti/wooter 0.0.0-stage → 6.0.0

package/src/path/matcher.ts

@@ -0,0 +1,29 @@
+import type { Matcher } from "./types.ts";
+
+/** Creates a named matcher while preserving matcher typing. */
+export const matcher = <T, Options = undefined>(
+  matcher: Matcher<T, Options>,
+): Matcher<T, Options> => matcher;
+
+/** Creates a one-segment matcher from a segment parser function. */
+export function single<T, Options = undefined>(
+  fn: (seg: string, options: Options) => { ok: false } | { ok: true; value: T },
+): Matcher<T, Options> {
+  return wrap((path, i, opt) => {
+    if (i >= path.length) return { ok: false };
+    const result = fn(path[i], opt);
+    return result.ok ? { ok: true, value: result.value, consume: 1 } : result;
+  }, fn.name);
+}
+
+/** Wraps a matcher and optionally rewrites its display name. */
+export function wrap<T, Options = undefined>(
+  fn: Matcher<T, Options>,
+  name: string,
+  transform?: (name: string) => string,
+): Matcher<T, Options> {
+  return Object.defineProperty(fn, "name", {
+    value: name ? (transform ? transform(name) : name) : "",
+    configurable: true,
+  });
+}

package/src/path/types.ts

@@ -0,0 +1,39 @@
+import type { Merge } from "../types/internal.ts";
+
+/** Matches path segments and returns a parsed value and consumed count. */
+export type Matcher<T, Options = undefined> = (
+  path: string[],
+  current_index: number,
+  options: Options,
+) => { ok: false } | { ok: true; value: T; consume: number };
+/** Extracts the parsed value type from a matcher-bearing parameter. */
+export type MatcherValue<P> = P extends { matcher: Matcher<infer T, any> }
+  ? T
+  : never;
+
+/** Describes a named route parameter with an optional matcher. */
+export type Param<
+  Name extends string = string,
+  T = unknown,
+  Options = undefined,
+> =
+  | {
+      name: Name;
+    }
+  | { name: Name; matcher: Matcher<T, Options>; options: Options };
+/** Resolves the value type produced by a route parameter. */
+export type ParamValue<P> = [MatcherValue<P>] extends [never]
+  ? string
+  : MatcherValue<P>;
+
+/** A typed sequence of literal and parameter path segments. */
+export type Path = (Param | string)[];
+/** Infers a parameter object from a typed path. */
+export type ParamsOfPath<P extends readonly unknown[]> = P extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? [Head] extends [Param<infer Name, any>]
+    ? Merge<{ [K in Name]: ParamValue<Head> }, ParamsOfPath<Tail>>
+    : ParamsOfPath<Tail>
+  : Record<never, never>;

package/src/types/internal.ts

@@ -0,0 +1,41 @@
+/**
+ * Computes optional property names from a type.
+ *
+ * @internal
+ * https://stackoverflow.com/a/49683575/15910952
+ */
+type OptionalPropertyNames<T> = {
+  // deno-lint-ignore ban-types
+  [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never;
+}[keyof T];
+
+/**
+ * Merges overlapping properties while preserving requiredness rules.
+ *
+ * @internal
+ * https://stackoverflow.com/a/49683575/15910952
+ */
+type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+  [P in K]: L[P] | Exclude<R[P], undefined>;
+};
+
+/**
+ * Flattens intersections for cleaner public-facing type output.
+ *
+ * @internal
+ * https://stackoverflow.com/a/49683575/15910952
+ */
+type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
+
+/**
+ * Utility type that merges two object types with optional-property awareness.
+ *
+ * @internal
+ * https://stackoverflow.com/a/49683575/15910952
+ */
+export type Merge<L, R> = Id<
+  Pick<L, Exclude<keyof L, keyof R>> &
+    Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> &
+    Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> &
+    SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
+>;

package/src/types/types.ts

@@ -0,0 +1,39 @@
+import type { Merge } from "./internal.ts";
+
+/**
+ * Generic route-parameter object shape.
+ */
+export type Params = Record<string, unknown>;
+
+/** Empty object shape used when no state or parameters are defined. */
+export type EmptyObject = Record<never, never>;
+
+/**
+ * Generic context state object shape.
+ */
+export type State = Record<string, unknown>;
+
+export type {
+  default as MiddlewareContext,
+  MiddlewareHandler,
+} from "../MiddlewareContext.ts";
+export type { default as RouteContext, RouteHandler } from "../RouteContext.ts";
+export type { MethodDefinitionInput, MethodDefinitions } from "../Graph.ts";
+
+export type { TypedMap } from "@bronti/robust/TypedMap";
+
+/**
+ * Conditionally merges two state/params types when either side may be undefined.
+ *
+ * @internal
+ */
+export type OptionalMerge<
+  A extends Record<keyof any, unknown> | undefined,
+  B extends Record<keyof any, unknown> | undefined,
+> = A extends undefined ? B : B extends undefined ? A : Merge<A, B>;
+
+/**
+ * HTTP methods for typed route declarations.
+ */
+export type Methods =
+  "GET" | "PUT" | "POST" | "PATCH" | "DELETE" | "OPTIONS" | "QUERY";