@orkestrel/router 0.0.1 → 0.0.2

package/dist/src/core/index.js

@@ -1,3 +1,5 @@
+import { Emitter } from "@orkestrel/emitter";
+import { isFunction, isString } from "@orkestrel/contract";
 //#region src/core/constants.ts
 /**
 * The complete set of HTTP methods a {@link import('./types.js').Dispatcher}
@@ -410,189 +412,45 @@ function joinPaths(prefix, path) {
 	if (path === "") return prefix;
 	return `${prefix.endsWith("/") ? prefix.slice(0, -1) : prefix}${path.startsWith("/") ? path : `/${path}`}`;
 }
-//#endregion
-//#region node_modules/@orkestrel/emitter/dist/src/core/index.js
 /**
-* Extract the own enumerable keys of a mapped object, typed as its key union.
+* Identity pass-through for a {@link RouteInput} that pins its `Path` generic
+* to the LITERAL registration-site string, so `context.params` types
+* correctly through {@link PathParams} without an explicit type argument.
 *
 * @remarks
-* `Object.keys` widens its result to `string[]`, which breaks the key↔value
-* correlation a mapped type (like `EmitterHooks<TMap>`) otherwise guarantees.
-* A `for…in` push into a `keyof`-typed array narrows the result back,
-* type-safely and with no assertion.
-*
-* @typeParam T - The object shape whose keys are extracted.
-* @param object - The object to read keys from.
-* @returns The object's own enumerable keys, typed as `(keyof T)[]`.
-*
-* @example
-* ```ts
-* import { extractKeys } from '@src/core'
-*
-* const hooks = { tick: () => {}, done: () => {} }
-* extractKeys(hooks) // ['tick', 'done']
-* extractKeys({}) // []
-* ```
-*/
-function extractKeys(object) {
-	const collected = [];
-	for (const key in object) collected.push(key);
-	return collected;
-}
-Object.freeze([
-	"null",
-	"boolean",
-	"object",
-	"array",
-	"number",
-	"integer",
-	"string"
-]);
-/** Determine whether a value is callable. */
-function isFunction$1(value) {
-	return typeof value === "function";
-}
-/**
-* A typed synchronous event emitter — the foundational observable primitive of
-* the codebase (AGENTS §13). Stateful entities OWN one as a `#emitter` field and
-* expose it through `readonly emitter`; they never inherit from it.
-*
-* @typeParam TMap - The event map: each event name to the argument tuple its
-*   listeners receive.
-*
-* @remarks
-* - **Synchronous.** `emit` invokes listeners in registration order, in the
-*   current tick.
-* - **Listener isolation.** A throwing listener never stops its siblings: every
-*   listener runs, and a throw is routed to the `error` handler
-*   ({@link EmitterOptions.error}) — never rethrown. Every throwing listener
-*   surfaces (not just the first), and with no `error` handler a throw is swallowed
-*   silently. The `error` handler runs inside its own try/catch, so a throwing
-*   error-handler is swallowed too (anti-recursion — it cannot escape or re-enter).
-* - **Per-event storage.** Listeners live in a per-event `Set`, so every public
-*   method is precisely typed with no assertions.
-* - **Destroyed → no-op.** After `destroy()`, `on` / `once` / `emit` do nothing
-*   and `destroyed` is `true`.
+* A bare object literal handed straight to {@link import('./types.js').DispatcherInterface}'s
+* `add` already infers `Path` as a literal at that call site — but the moment
+* the object is built through an intermediate binding (a local `const route =
+* { method, path, handler }`) TypeScript widens `path` to `string` unless the
+* binding's own type is pinned. Wrapping the literal in `route(...)` supplies
+* that pin: its `const Path extends string` type parameter infers the NARROW
+* literal from the call, and the function returns its input completely
+* unchanged (same reference, no cloning, no validation) — this is a
+* compile-time typing aid only, not a construction step (contrast
+* {@link import('./factories.js')} `create*` entity factories). A
+* heterogeneous `RouteInput[]` built from several `route(...)` calls still
+* widens each element's `Path` to `string` once collected into one array
+* (§14) — the realistic ceiling this helper raises is PER-CALL typing at the
+* registration site, not a stored, still-literal-typed record.
+*
+* @typeParam Path - The route path pattern literal (drives `context.params`
+*   via {@link PathParams})
+* @typeParam TState - The consumer's opaque per-request state type
+* @param input - The {@link RouteInput} to pass through unchanged
+* @returns `input`, unchanged (same reference)
 *
 * @example
 * ```ts
-* type CounterEventMap = {
-* 	tick: readonly [count: number]
-* 	done: readonly []
-* }
-*
-* const emitter = new Emitter<CounterEventMap>({
-* 	on: { done: () => stop() },
-* 	error: (error, event) => log(`listener for ${event} threw`, error),
+* const input = route({
+* 	method: 'GET',
+* 	path: '/users/:id',
+* 	handler: (_request, context) => new Response(context.params.id), // typed string
 * })
-* emitter.on('tick', (count) => render(count))
-* emitter.emit('tick', 1)
+* dispatcher.add(input)
 * ```
 */
-var Emitter = class {
-	#destroyed = false;
-	#listeners = {};
-	#wrappers = {};
-	#error;
-	constructor(options) {
-		const error = options?.error;
-		this.#error = isFunction$1(error) ? error : void 0;
-		const hooks = options?.on;
-		if (hooks !== void 0) this.#wire(hooks);
-	}
-	get destroyed() {
-		return this.#destroyed;
-	}
-	on(event, handler) {
-		if (this.#destroyed) return;
-		(this.#listeners[event] ??= /* @__PURE__ */ new Set()).add(handler);
-	}
-	once(event, handler) {
-		if (this.#destroyed) return;
-		const pending = this.#wrappers[event] ??= /* @__PURE__ */ new Map();
-		const wrapper = (...args) => {
-			this.#listeners[event]?.delete(wrapper);
-			const wrappers = pending.get(handler);
-			wrappers?.delete(wrapper);
-			if (wrappers !== void 0 && wrappers.size === 0) pending.delete(handler);
-			handler(...args);
-		};
-		const wrappers = pending.get(handler) ?? /* @__PURE__ */ new Set();
-		wrappers.add(wrapper);
-		pending.set(handler, wrappers);
-		this.on(event, wrapper);
-	}
-	off(event, handler) {
-		const listeners = this.#listeners[event];
-		const wrappers = this.#wrappers[event];
-		const pending = wrappers?.get(handler);
-		if (pending !== void 0) {
-			for (const wrapper of pending) listeners?.delete(wrapper);
-			wrappers?.delete(handler);
-		}
-		listeners?.delete(handler);
-	}
-	emit(event, ...args) {
-		if (this.#destroyed) return;
-		const listeners = this.#listeners[event];
-		if (listeners === void 0) return;
-		for (const handler of [...listeners]) try {
-			handler(...args);
-		} catch (error) {
-			this.#surface(error, event);
-		}
-	}
-	count(event) {
-		if (event !== void 0) return this.#listeners[event]?.size ?? 0;
-		let total = 0;
-		for (const set of Object.values(this.#listeners)) total += set?.size ?? 0;
-		return total;
-	}
-	clear(event) {
-		if (event !== void 0) {
-			delete this.#listeners[event];
-			delete this.#wrappers[event];
-			return;
-		}
-		this.#listeners = {};
-		this.#wrappers = {};
-	}
-	destroy() {
-		this.#listeners = {};
-		this.#wrappers = {};
-		this.#error = void 0;
-		this.#destroyed = true;
-	}
-	#surface(error, event) {
-		const handler = this.#error;
-		if (handler === void 0) return;
-		try {
-			handler(error, String(event));
-		} catch {}
-	}
-	#wire(hooks) {
-		for (const event of extractKeys(hooks)) {
-			const handler = hooks[event];
-			if (isFunction$1(handler)) this.on(event, handler);
-		}
-	}
-};
-Object.freeze([
-	"null",
-	"boolean",
-	"object",
-	"array",
-	"number",
-	"integer",
-	"string"
-]);
-/** Determine whether a value is a string. */
-function isString(value) {
-	return typeof value === "string";
-}
-/** Determine whether a value is callable. */
-function isFunction(value) {
-	return typeof value === "function";
+function route(input) {
+	return input;
 }
 //#endregion
 //#region src/core/Group.ts
@@ -1009,6 +867,6 @@ function createDispatcher(options) {
 	return new Dispatcher(options);
 }
 //#endregion
-export { DispatchGroup, Dispatcher, Group, METHODS, Router, TIER_LITERAL, TIER_PARAM, TIER_WILDCARD, canonicalizePath, classifySegment, compareSpecificity, compilePath, computeSpecificity, createDispatcher, createRouter, decodeParam, escapeRegExp, joinPaths, matchPath, parseMethod };
+export { DispatchGroup, Dispatcher, Group, METHODS, Router, TIER_LITERAL, TIER_PARAM, TIER_WILDCARD, canonicalizePath, classifySegment, compareSpecificity, compilePath, computeSpecificity, createDispatcher, createRouter, decodeParam, escapeRegExp, joinPaths, matchPath, parseMethod, route };
 
 //# sourceMappingURL=index.js.map