@vercel/routing-utils 5.3.2 → 5.3.3

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { GetRoutesProps, NormalizedRoutes, Route, RouteWithHandle } from './types';
 export { appendRoutesToPhase } from './append';
 export { mergeRoutes } from './merge';
+export { getOwnershipGuard, normalizeRoutePrefix, scopeRouteSourceToOwnership, } from './service-route-ownership';
 export * from './schemas';
 export { getCleanUrls, sourceToRegex } from './superstatic';
 export * from './types';

package/dist/index.js

@@ -21,11 +21,14 @@ var src_exports = {};
 __export(src_exports, {
   appendRoutesToPhase: () => import_append.appendRoutesToPhase,
   getCleanUrls: () => import_superstatic2.getCleanUrls,
+  getOwnershipGuard: () => import_service_route_ownership.getOwnershipGuard,
   getTransformedRoutes: () => getTransformedRoutes,
   isHandler: () => isHandler,
   isValidHandleValue: () => isValidHandleValue,
   mergeRoutes: () => import_merge.mergeRoutes,
+  normalizeRoutePrefix: () => import_service_route_ownership.normalizeRoutePrefix,
   normalizeRoutes: () => normalizeRoutes,
+  scopeRouteSourceToOwnership: () => import_service_route_ownership.scopeRouteSourceToOwnership,
   sourceToRegex: () => import_superstatic2.sourceToRegex
 });
 module.exports = __toCommonJS(src_exports);
@@ -33,6 +36,7 @@ var import_url = require("url");
 var import_superstatic = require("./superstatic");
 var import_append = require("./append");
 var import_merge = require("./merge");
+var import_service_route_ownership = require("./service-route-ownership");
 __reExport(src_exports, require("./schemas"), module.exports);
 var import_superstatic2 = require("./superstatic");
 __reExport(src_exports, require("./types"), module.exports);
@@ -366,11 +370,14 @@ function getTransformedRoutes(vercelConfig) {
 0 && (module.exports = {
   appendRoutesToPhase,
   getCleanUrls,
+  getOwnershipGuard,
   getTransformedRoutes,
   isHandler,
   isValidHandleValue,
   mergeRoutes,
+  normalizeRoutePrefix,
   normalizeRoutes,
+  scopeRouteSourceToOwnership,
   sourceToRegex,
   ...require("./schemas"),
   ...require("./types")

package/dist/service-route-ownership.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Normalize a route prefix to always have a leading slash and no trailing slash
+ * unless it is root (`/`).
+ */
+export declare function normalizeRoutePrefix(routePrefix: string): string;
+/**
+ * Create a service ownership guard:
+ * - Root services exclude all non-root prefixes.
+ * - Non-root services are constrained to their prefix and exclude descendants.
+ */
+export declare function getOwnershipGuard(ownerPrefix: string, allRoutePrefixes: string[]): string;
+export declare function scopeRouteSourceToOwnership(source: string, ownershipGuard: string): string;

package/dist/service-route-ownership.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var service_route_ownership_exports = {};
+__export(service_route_ownership_exports, {
+  getOwnershipGuard: () => getOwnershipGuard,
+  normalizeRoutePrefix: () => normalizeRoutePrefix,
+  scopeRouteSourceToOwnership: () => scopeRouteSourceToOwnership
+});
+module.exports = __toCommonJS(service_route_ownership_exports);
+function normalizeRoutePrefix(routePrefix) {
+  let normalized = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
+  if (normalized !== "/" && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized || "/";
+}
+function escapeForRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+}
+function toPrefixMatcher(routePrefix) {
+  return `${escapeForRegex(routePrefix)}(?:/|$)`;
+}
+function isDescendantPrefix(candidate, prefix) {
+  return candidate !== prefix && candidate.startsWith(`${prefix}/`);
+}
+function getOwnershipGuard(ownerPrefix, allRoutePrefixes) {
+  const owner = normalizeRoutePrefix(ownerPrefix);
+  const normalizedPrefixes = Array.from(
+    new Set(allRoutePrefixes.map(normalizeRoutePrefix))
+  );
+  const nonRootPrefixes = normalizedPrefixes.filter((prefix) => prefix !== "/").sort((a, b) => b.length - a.length);
+  if (owner === "/") {
+    return nonRootPrefixes.map((prefix) => `(?!${toPrefixMatcher(prefix)})`).join("");
+  }
+  const descendants = nonRootPrefixes.filter(
+    (prefix) => isDescendantPrefix(prefix, owner)
+  );
+  const positive = `(?=${toPrefixMatcher(owner)})`;
+  const negative = descendants.map((prefix) => `(?!${toPrefixMatcher(prefix)})`).join("");
+  return `${positive}${negative}`;
+}
+function scopeRouteSourceToOwnership(source, ownershipGuard) {
+  if (!ownershipGuard) {
+    return source;
+  }
+  const inner = source.startsWith("^") ? source.slice(1) : source;
+  return `^${ownershipGuard}(?:${inner})`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getOwnershipGuard,
+  normalizeRoutePrefix,
+  scopeRouteSourceToOwnership
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/routing-utils",
-  "version": "5.3.2",
+  "version": "5.3.3",
   "description": "Vercel routing utilities",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,7 +19,7 @@
   },
   "devDependencies": {
     "@types/jest": "27.4.1",
-    "@types/node": "14.18.33",
+    "@types/node": "20.11.0",
     "ajv": "^6.12.3",
     "jest-junit": "16.0.0",
     "typescript": "4.9.5"