stratal 0.0.22 → 0.0.24

package/dist/route-name-DGoBOfPg.mjs

@@ -0,0 +1,171 @@
+//#region src/router/utils/path.ts
+/**
+* Path normalization and route ordering utilities.
+*
+* Users always write Hono-style `:param` paths (`:companyId`, `:id`).
+* OpenAPI requires `{param}` style — conversion happens only at registration time.
+*/
+/**
+* Convert Hono-style `:param` path segments to OpenAPI-style `{param}`.
+* Strips regex constraints (e.g., `:locale{sw}` → `{locale}`).
+*
+* @example
+* toOpenAPIPath('/users/:id')                    // '/users/{id}'
+* toOpenAPIPath('/:companyId/users/:userId')     // '/{companyId}/users/{userId}'
+* toOpenAPIPath('/users/:id/posts')              // '/users/{id}/posts'
+* toOpenAPIPath('/:locale{en|fr}/users')         // '/{locale}/users'
+*/
+function toOpenAPIPath(path) {
+	return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]*\})?/g, "{$1}");
+}
+/**
+* Convert Hono-style `:param` path segments to OpenAPI-style `{param}`,
+* preserving regex constraints.
+*
+* Used for Hono route registration via `app.openapi()`. The non-greedy
+* regex in `@hono/zod-openapi` (`\/{(.+?)}/g`) converts `{param}` back
+* to `:param` while leaving the constraint suffix intact.
+*
+* @example
+* toRoutingOpenAPIPath('/:locale{sw}/users/:id')  // '/{locale}{sw}/users/{id}'
+* toRoutingOpenAPIPath('/users/:id')               // '/users/{id}'
+*/
+function toRoutingOpenAPIPath(path) {
+	return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]*\})?/g, (_, name, constraint) => constraint ? `{${name}}${constraint}` : `{${name}}`);
+}
+/**
+* Compute a packed specificity key for route ordering.
+* Encodes both score and segment count into a single number to avoid object allocation.
+*
+* Lower score = higher priority (registered first in Hono).
+* Scoring: static = 0, `:param{constraint}` = 5, `:param` = 10, wildcard `{.+}` / `{.*}` = 100.
+*
+* Packed as: score * 10000 - segmentCount (negative segment count so more segments = lower key = higher priority)
+*
+* Locale variants score against the path with the leading `/:locale{…}` segment
+* stripped — the variant's score therefore matches its primary, but its larger
+* segment count makes it sort just before the primary. Without this, a primary
+* catch-all (e.g. `/:slug{.+}`) gobbles locale-prefixed URLs because Hono picks
+* whichever matching route was registered first.
+*/
+function getPathSpecificityKey(route) {
+	const segmentCount = countSegments(route.path);
+	const scoringPath = route.isLocaleVariant ? route.path.replace(/^\/:locale\{[^}]*\}/, "") || "/" : route.path;
+	let score = 0;
+	let i = 0;
+	while (i < scoringPath.length) {
+		if (scoringPath.charCodeAt(i) === 47) {
+			i++;
+			continue;
+		}
+		let end = scoringPath.indexOf("/", i);
+		if (end === -1) end = scoringPath.length;
+		const segment = scoringPath.substring(i, end);
+		if (segment.includes("{.+}") || segment.includes("{.*}")) score += 100;
+		else if (segment.charCodeAt(0) === 58) score += segment.includes("{") ? 5 : 10;
+		i = end;
+	}
+	return score * 1e4 - segmentCount;
+}
+function countSegments(path) {
+	let count = 0;
+	let i = 0;
+	while (i < path.length) {
+		if (path.charCodeAt(i) === 47) {
+			i++;
+			continue;
+		}
+		let end = path.indexOf("/", i);
+		if (end === -1) end = path.length;
+		count++;
+		i = end;
+	}
+	return count;
+}
+/**
+* Compute a specificity score for route ordering.
+* Lower score = higher priority (registered first in Hono).
+*
+* Scoring: static = 0, `:param{constraint}` = 5, `:param` = 10, wildcard `{.+}` / `{.*}` = 100.
+*/
+function getPathSpecificityScore(path) {
+	const segments = path.split("/").filter(Boolean);
+	let score = 0;
+	for (const segment of segments) if (segment.includes("{.+}") || segment.includes("{.*}")) score += 100;
+	else if (segment.startsWith(":") && segment.includes("{")) score += 5;
+	else if (segment.startsWith(":")) score += 10;
+	return score;
+}
+/**
+* Sort routes by specificity so Hono registers them in the correct order.
+*
+* 1. Static paths before parameterized before wildcards
+* 2. More segments = more specific (tie-breaker)
+* 3. Locale-prefixed variants before their primary (so a locale-prefixed
+*    request matches the variant first; a primary catch-all would otherwise
+*    swallow the locale prefix into its param)
+*/
+function sortRoutesBySpecificity(routes) {
+	const keys = /* @__PURE__ */ new Map();
+	for (const route of routes) keys.set(route, getPathSpecificityKey(route));
+	const copy = routes.slice();
+	copy.sort((a, b) => keys.get(a) - keys.get(b));
+	return copy;
+}
+//#endregion
+//#region src/router/utils/route-name.ts
+/**
+* Route naming utilities.
+*
+* Extracts parameter names from paths and domains,
+* and generates convention-based route names.
+*/
+/**
+* Extract parameter names from a Hono-style path.
+*
+* @example
+* extractParamNames('/users/:id')                     // ['id']
+* extractParamNames('/:companyId/users/:userId')      // ['companyId', 'userId']
+* extractParamNames('/users')                         // []
+*/
+function extractParamNames(path) {
+	if (!path.includes(":")) return [];
+	return [...path.matchAll(/:([a-zA-Z_][a-zA-Z0-9_]*)/g)].map((m) => m[1]);
+}
+/**
+* Extract parameter names from a domain pattern.
+*
+* @example
+* extractDomainParamNames('{tenant}.example.com')           // ['tenant']
+* extractDomainParamNames('{region}.{tenant}.example.com')  // ['region', 'tenant']
+* extractDomainParamNames('example.com')                    // []
+*/
+function extractDomainParamNames(domain) {
+	if (!domain.includes("{")) return [];
+	return [...domain.matchAll(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g)].map((m) => m[1]);
+}
+/**
+* Auto-generate a route name for convention-based `@Route` methods.
+*
+* Strips common prefixes (`/api/`, `/v{N}/`) and parameter segments,
+* then joins remaining static segments with dots and appends the method name.
+*
+* @example
+* generateConventionRouteName('/users', 'index')                         // 'users.index'
+* generateConventionRouteName('/users', 'show')                          // 'users.show'
+* generateConventionRouteName('/api/v1/users', 'create')                 // 'users.create'
+* generateConventionRouteName('/api/v1/users/:userId/notes', 'index')    // 'users.notes.index'
+* generateConventionRouteName('/:companyId/users', 'index')              // 'users.index'
+* generateConventionRouteName('/users/:userId/notes/:noteId/tags', 'index') // 'users.notes.tags.index'
+*/
+function generateConventionRouteName(basePath, methodName) {
+	const parts = basePath.split("/");
+	const segments = [];
+	for (const s of parts) if (s && s !== "api" && !s.startsWith(":") && !/^v\d+$/.test(s)) segments.push(s);
+	if (segments.length === 0) return methodName;
+	return `${segments.join(".")}.${methodName}`;
+}
+//#endregion
+export { sortRoutesBySpecificity as a, getPathSpecificityScore as i, extractParamNames as n, toOpenAPIPath as o, generateConventionRouteName as r, toRoutingOpenAPIPath as s, extractDomainParamNames as t };
+
+//# sourceMappingURL=route-name-DGoBOfPg.mjs.map

package/dist/route-name-DGoBOfPg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-name-DGoBOfPg.mjs","names":[],"sources":["../src/router/utils/path.ts","../src/router/utils/route-name.ts"],"sourcesContent":["/**\n * Path normalization and route ordering utilities.\n *\n * Users always write Hono-style `:param` paths (`:companyId`, `:id`).\n * OpenAPI requires `{param}` style — conversion happens only at registration time.\n */\n\n/**\n * Convert Hono-style `:param` path segments to OpenAPI-style `{param}`.\n * Strips regex constraints (e.g., `:locale{sw}` → `{locale}`).\n *\n * @example\n * toOpenAPIPath('/users/:id')                    // '/users/{id}'\n * toOpenAPIPath('/:companyId/users/:userId')     // '/{companyId}/users/{userId}'\n * toOpenAPIPath('/users/:id/posts')              // '/users/{id}/posts'\n * toOpenAPIPath('/:locale{en|fr}/users')         // '/{locale}/users'\n */\nexport function toOpenAPIPath(path: string): string {\n  return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\\{[^}]*\\})?/g, '{$1}')\n}\n\n/**\n * Convert Hono-style `:param` path segments to OpenAPI-style `{param}`,\n * preserving regex constraints.\n *\n * Used for Hono route registration via `app.openapi()`. The non-greedy\n * regex in `@hono/zod-openapi` (`\\/{(.+?)}/g`) converts `{param}` back\n * to `:param` while leaving the constraint suffix intact.\n *\n * @example\n * toRoutingOpenAPIPath('/:locale{sw}/users/:id')  // '/{locale}{sw}/users/{id}'\n * toRoutingOpenAPIPath('/users/:id')               // '/users/{id}'\n */\nexport function toRoutingOpenAPIPath(path: string): string {\n  return path.replace(\n    /:([a-zA-Z_][a-zA-Z0-9_]*)(\\{[^}]*\\})?/g,\n    (_, name: string, constraint?: string) => constraint ? `{${name}}${constraint}` : `{${name}}`,\n  )\n}\n\n/**\n * Compute a packed specificity key for route ordering.\n * Encodes both score and segment count into a single number to avoid object allocation.\n *\n * Lower score = higher priority (registered first in Hono).\n * Scoring: static = 0, `:param{constraint}` = 5, `:param` = 10, wildcard `{.+}` / `{.*}` = 100.\n *\n * Packed as: score * 10000 - segmentCount (negative segment count so more segments = lower key = higher priority)\n *\n * Locale variants score against the path with the leading `/:locale{…}` segment\n * stripped — the variant's score therefore matches its primary, but its larger\n * segment count makes it sort just before the primary. Without this, a primary\n * catch-all (e.g. `/:slug{.+}`) gobbles locale-prefixed URLs because Hono picks\n * whichever matching route was registered first.\n */\nfunction getPathSpecificityKey(route: { path: string; isLocaleVariant?: boolean }): number {\n  const segmentCount = countSegments(route.path)\n  const scoringPath = route.isLocaleVariant\n    ? (route.path.replace(/^\\/:locale\\{[^}]*\\}/, '') || '/')\n    : route.path\n\n  let score = 0\n  let i = 0\n  while (i < scoringPath.length) {\n    if (scoringPath.charCodeAt(i) === 47 /* '/' */) { i++; continue }\n\n    let end = scoringPath.indexOf('/', i)\n    if (end === -1) end = scoringPath.length\n\n    const segment = scoringPath.substring(i, end)\n\n    if (segment.includes('{.+}') || segment.includes('{.*}')) {\n      score += 100\n    } else if (segment.charCodeAt(0) === 58 /* ':' */) {\n      score += segment.includes('{') ? 5 : 10\n    }\n\n    i = end\n  }\n\n  return score * 10000 - segmentCount\n}\n\nfunction countSegments(path: string): number {\n  let count = 0\n  let i = 0\n  while (i < path.length) {\n    if (path.charCodeAt(i) === 47 /* '/' */) { i++; continue }\n    let end = path.indexOf('/', i)\n    if (end === -1) end = path.length\n    count++\n    i = end\n  }\n  return count\n}\n\n/**\n * Compute a specificity score for route ordering.\n * Lower score = higher priority (registered first in Hono).\n *\n * Scoring: static = 0, `:param{constraint}` = 5, `:param` = 10, wildcard `{.+}` / `{.*}` = 100.\n */\nexport function getPathSpecificityScore(path: string): number {\n  const segments = path.split('/').filter(Boolean)\n  let score = 0\n  for (const segment of segments) {\n    if (segment.includes('{.+}') || segment.includes('{.*}')) {\n      score += 100\n    } else if (segment.startsWith(':') && segment.includes('{')) {\n      score += 5\n    } else if (segment.startsWith(':')) {\n      score += 10\n    }\n  }\n  return score\n}\n\n/**\n * Sort routes by specificity so Hono registers them in the correct order.\n *\n * 1. Static paths before parameterized before wildcards\n * 2. More segments = more specific (tie-breaker)\n * 3. Locale-prefixed variants before their primary (so a locale-prefixed\n *    request matches the variant first; a primary catch-all would otherwise\n *    swallow the locale prefix into its param)\n */\nexport function sortRoutesBySpecificity<T extends { path: string; isLocaleVariant?: boolean }>(routes: T[]): T[] {\n  // Pre-compute packed specificity keys (avoids object allocation per route)\n  const keys = new Map<T, number>()\n  for (const route of routes) {\n    keys.set(route, getPathSpecificityKey(route))\n  }\n\n  const copy = routes.slice()\n  copy.sort((a, b) => keys.get(a)! - keys.get(b)!)\n  return copy\n}\n","/**\n * Route naming utilities.\n *\n * Extracts parameter names from paths and domains,\n * and generates convention-based route names.\n */\n\n/**\n * Extract parameter names from a Hono-style path.\n *\n * @example\n * extractParamNames('/users/:id')                     // ['id']\n * extractParamNames('/:companyId/users/:userId')      // ['companyId', 'userId']\n * extractParamNames('/users')                         // []\n */\nexport function extractParamNames(path: string): string[] {\n  if (!path.includes(':')) return []\n  const matches = path.matchAll(/:([a-zA-Z_][a-zA-Z0-9_]*)/g)\n  return [...matches].map(m => m[1])\n}\n\n/**\n * Extract parameter names from a domain pattern.\n *\n * @example\n * extractDomainParamNames('{tenant}.example.com')           // ['tenant']\n * extractDomainParamNames('{region}.{tenant}.example.com')  // ['region', 'tenant']\n * extractDomainParamNames('example.com')                    // []\n */\nexport function extractDomainParamNames(domain: string): string[] {\n  if (!domain.includes('{')) return []\n  const matches = domain.matchAll(/\\{([a-zA-Z_][a-zA-Z0-9_]*)\\}/g)\n  return [...matches].map(m => m[1])\n}\n\n/**\n * Auto-generate a route name for convention-based `@Route` methods.\n *\n * Strips common prefixes (`/api/`, `/v{N}/`) and parameter segments,\n * then joins remaining static segments with dots and appends the method name.\n *\n * @example\n * generateConventionRouteName('/users', 'index')                         // 'users.index'\n * generateConventionRouteName('/users', 'show')                          // 'users.show'\n * generateConventionRouteName('/api/v1/users', 'create')                 // 'users.create'\n * generateConventionRouteName('/api/v1/users/:userId/notes', 'index')    // 'users.notes.index'\n * generateConventionRouteName('/:companyId/users', 'index')              // 'users.index'\n * generateConventionRouteName('/users/:userId/notes/:noteId/tags', 'index') // 'users.notes.tags.index'\n */\nexport function generateConventionRouteName(basePath: string, methodName: string): string {\n  // Single-pass: split and filter in one loop (avoids 4 intermediate arrays)\n  const parts = basePath.split('/')\n  const segments: string[] = []\n  for (const s of parts) {\n    if (s && s !== 'api' && !s.startsWith(':') && !/^v\\d+$/.test(s)) {\n      segments.push(s)\n    }\n  }\n\n  if (segments.length === 0) {\n    return methodName\n  }\n\n  return `${segments.join('.')}.${methodName}`\n}\n"],"mappings":"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"}