@webiny/app 5.44.1-beta.0 → 5.45.0-beta.0

package/features/router/Route.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export type RouteParamsDefinition = Record<string, z.ZodTypeAny>;
+export type RouteParamsInfer<T extends RouteParamsDefinition | undefined> = T extends RouteParamsDefinition ? z.infer<z.ZodObject<T> & {
+    [k: string]: any;
+}> : never;
+export interface RouteParams<TParams extends RouteParamsDefinition | undefined> {
+    name: string;
+    path: `/${string}` | `*`;
+    params?: (zod: typeof z) => TParams;
+}
+export declare class Route<TParams extends RouteParamsDefinition | undefined = undefined> {
+    private readonly route;
+    private readonly schema;
+    constructor(route: RouteParams<TParams>);
+    get name(): string;
+    get path(): `/${string}` | "*";
+    get params(): TParams extends RouteParamsDefinition ? RouteParamsInfer<TParams> : undefined;
+    private coerceParams;
+}

package/features/router/Route.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export class Route {
+  constructor(route) {
+    this.route = route;
+    const paramsSchema = route.params ? route.params(z) : undefined;
+    // @ts-expect-error
+    this.schema = paramsSchema ? z.object(this.coerceParams(paramsSchema)).passthrough() : undefined;
+  }
+  get name() {
+    return this.route.name;
+  }
+  get path() {
+    return this.route.path;
+  }
+  get params() {
+    return this.schema;
+  }
+  coerceParams(shape) {
+    const result = {};
+    for (const [key, schema] of Object.entries(shape)) {
+      let base = schema;
+      let isOptional = false;
+      let isNullable = false;
+
+      // unwrap optional
+      if (base._def.typeName === z.ZodFirstPartyTypeKind.ZodOptional) {
+        isOptional = true;
+        base = base._def.innerType;
+      }
+
+      // unwrap nullable
+      if (base._def.typeName === z.ZodFirstPartyTypeKind.ZodNullable) {
+        isNullable = true;
+        base = base._def.innerType;
+      }
+
+      // replace with coerced
+      if (base instanceof z.ZodString) {
+        base = z.coerce.string();
+      } else if (base instanceof z.ZodNumber) {
+        base = z.coerce.number();
+      } else if (base instanceof z.ZodBoolean) {
+        base = z.coerce.boolean();
+      }
+
+      // rewrap optional/nullable
+      if (isNullable) {
+        base = base.nullable();
+      }
+      if (isOptional) {
+        base = base.optional();
+      }
+      result[key] = base;
+    }
+    return result;
+  }
+}
+
+//# sourceMappingURL=Route.js.map

package/features/router/Route.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["z","Route","constructor","route","paramsSchema","params","undefined","schema","object","coerceParams","passthrough","name","path","shape","result","key","Object","entries","base","isOptional","isNullable","_def","typeName","ZodFirstPartyTypeKind","ZodOptional","innerType","ZodNullable","ZodString","coerce","string","ZodNumber","number","ZodBoolean","boolean","nullable","optional"],"sources":["Route.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport type RouteParamsDefinition = Record<string, z.ZodTypeAny>;\n\nexport type RouteParamsInfer<T extends RouteParamsDefinition | undefined> =\n    T extends RouteParamsDefinition ? z.infer<z.ZodObject<T> & { [k: string]: any }> : never;\n\nexport interface RouteParams<TParams extends RouteParamsDefinition | undefined> {\n    name: string;\n    path: `/${string}` | `*`;\n    params?: (zod: typeof z) => TParams;\n}\n\nexport class Route<TParams extends RouteParamsDefinition | undefined = undefined> {\n    private readonly route: RouteParams<TParams>;\n    private readonly schema: TParams extends RouteParamsDefinition\n        ? RouteParamsInfer<TParams>\n        : undefined;\n\n    constructor(route: RouteParams<TParams>) {\n        this.route = route;\n        const paramsSchema = route.params ? route.params(z) : undefined;\n        // @ts-expect-error\n        this.schema = paramsSchema\n            ? z.object(this.coerceParams(paramsSchema)).passthrough()\n            : undefined;\n    }\n\n    get name() {\n        return this.route.name;\n    }\n\n    get path() {\n        return this.route.path;\n    }\n\n    get params(): TParams extends RouteParamsDefinition ? RouteParamsInfer<TParams> : undefined {\n        return this.schema;\n    }\n\n    private coerceParams<T extends Record<string, z.ZodTypeAny>>(shape: T) {\n        const result: Record<string, z.ZodTypeAny> = {};\n        for (const [key, schema] of Object.entries(shape)) {\n            let base = schema as z.ZodTypeAny;\n            let isOptional = false;\n            let isNullable = false;\n\n            // unwrap optional\n            if (base._def.typeName === z.ZodFirstPartyTypeKind.ZodOptional) {\n                isOptional = true;\n                base = base._def.innerType;\n            }\n\n            // unwrap nullable\n            if (base._def.typeName === z.ZodFirstPartyTypeKind.ZodNullable) {\n                isNullable = true;\n                base = base._def.innerType;\n            }\n\n            // replace with coerced\n            if (base instanceof z.ZodString) {\n                base = z.coerce.string();\n            } else if (base instanceof z.ZodNumber) {\n                base = z.coerce.number();\n            } else if (base instanceof z.ZodBoolean) {\n                base = z.coerce.boolean();\n            }\n\n            // rewrap optional/nullable\n            if (isNullable) {\n                base = base.nullable();\n            }\n            if (isOptional) {\n                base = base.optional();\n            }\n\n            result[key] = base;\n        }\n        return result;\n    }\n}\n"],"mappings":"AAAA,SAASA,CAAC,QAAQ,KAAK;AAavB,OAAO,MAAMC,KAAK,CAAgE;EAM9EC,WAAWA,CAACC,KAA2B,EAAE;IACrC,IAAI,CAACA,KAAK,GAAGA,KAAK;IAClB,MAAMC,YAAY,GAAGD,KAAK,CAACE,MAAM,GAAGF,KAAK,CAACE,MAAM,CAACL,CAAC,CAAC,GAAGM,SAAS;IAC/D;IACA,IAAI,CAACC,MAAM,GAAGH,YAAY,GACpBJ,CAAC,CAACQ,MAAM,CAAC,IAAI,CAACC,YAAY,CAACL,YAAY,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,GACvDJ,SAAS;EACnB;EAEA,IAAIK,IAAIA,CAAA,EAAG;IACP,OAAO,IAAI,CAACR,KAAK,CAACQ,IAAI;EAC1B;EAEA,IAAIC,IAAIA,CAAA,EAAG;IACP,OAAO,IAAI,CAACT,KAAK,CAACS,IAAI;EAC1B;EAEA,IAAIP,MAAMA,CAAA,EAAkF;IACxF,OAAO,IAAI,CAACE,MAAM;EACtB;EAEQE,YAAYA,CAAyCI,KAAQ,EAAE;IACnE,MAAMC,MAAoC,GAAG,CAAC,CAAC;IAC/C,KAAK,MAAM,CAACC,GAAG,EAAER,MAAM,CAAC,IAAIS,MAAM,CAACC,OAAO,CAACJ,KAAK,CAAC,EAAE;MAC/C,IAAIK,IAAI,GAAGX,MAAsB;MACjC,IAAIY,UAAU,GAAG,KAAK;MACtB,IAAIC,UAAU,GAAG,KAAK;;MAEtB;MACA,IAAIF,IAAI,CAACG,IAAI,CAACC,QAAQ,KAAKtB,CAAC,CAACuB,qBAAqB,CAACC,WAAW,EAAE;QAC5DL,UAAU,GAAG,IAAI;QACjBD,IAAI,GAAGA,IAAI,CAACG,IAAI,CAACI,SAAS;MAC9B;;MAEA;MACA,IAAIP,IAAI,CAACG,IAAI,CAACC,QAAQ,KAAKtB,CAAC,CAACuB,qBAAqB,CAACG,WAAW,EAAE;QAC5DN,UAAU,GAAG,IAAI;QACjBF,IAAI,GAAGA,IAAI,CAACG,IAAI,CAACI,SAAS;MAC9B;;MAEA;MACA,IAAIP,IAAI,YAAYlB,CAAC,CAAC2B,SAAS,EAAE;QAC7BT,IAAI,GAAGlB,CAAC,CAAC4B,MAAM,CAACC,MAAM,CAAC,CAAC;MAC5B,CAAC,MAAM,IAAIX,IAAI,YAAYlB,CAAC,CAAC8B,SAAS,EAAE;QACpCZ,IAAI,GAAGlB,CAAC,CAAC4B,MAAM,CAACG,MAAM,CAAC,CAAC;MAC5B,CAAC,MAAM,IAAIb,IAAI,YAAYlB,CAAC,CAACgC,UAAU,EAAE;QACrCd,IAAI,GAAGlB,CAAC,CAAC4B,MAAM,CAACK,OAAO,CAAC,CAAC;MAC7B;;MAEA;MACA,IAAIb,UAAU,EAAE;QACZF,IAAI,GAAGA,IAAI,CAACgB,QAAQ,CAAC,CAAC;MAC1B;MACA,IAAIf,UAAU,EAAE;QACZD,IAAI,GAAGA,IAAI,CAACiB,QAAQ,CAAC,CAAC;MAC1B;MAEArB,MAAM,CAACC,GAAG,CAAC,GAAGG,IAAI;IACtB;IACA,OAAOJ,MAAM;EACjB;AACJ","ignoreList":[]}

package/features/router/RouteUrl.d.ts

@@ -0,0 +1,85 @@
+interface Params {
+    [key: string]: any;
+}
+interface MatchResult {
+    params: Record<string, string>;
+}
+/**
+ * Utility class for route URL pattern matching and generation.
+ * Handles simple route patterns with :param syntax (e.g., /cms/entries/:modelId).
+ *
+ * Public API uses static methods, which internally construct RouteUrl instances
+ * to handle the logic through proper instance methods.
+ */
+export declare class RouteUrl {
+    private static patternCache;
+    private readonly pattern;
+    private readonly params;
+    private readonly baseUrl;
+    private constructor();
+    /**
+     * Generate a URL from a route pattern and parameters.
+     * Path parameters are injected into the pattern, remaining parameters become query strings.
+     *
+     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')
+     * @param params - Parameters object (e.g., { id: 123, new: true })
+     * @param baseUrl - Optional base URL to prepend (e.g., '/tenant123')
+     * @returns Generated URL string
+     *
+     * @example
+     * RouteUrl.fromPattern('/security/api-keys/:id', { id: 123, new: true })
+     * // Returns: '/security/api-keys/123?new=true'
+     *
+     * @example
+     * RouteUrl.fromPattern('/file-manager', {}, '/tenant123')
+     * // Returns: '/tenant123/file-manager'
+     */
+    static fromPattern(pattern: string, params?: Params, baseUrl?: string): string;
+    /**
+     * Match a pathname against a route pattern and extract parameters.
+     * If baseUrl is provided, it will be stripped from the pathname before matching.
+     *
+     * @param pathname - The pathname to match (e.g., '/tenant123/security/api-keys/123')
+     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')
+     * @param baseUrl - Optional base URL to strip before matching (e.g., '/tenant123')
+     * @returns Object with extracted params if matched, null otherwise
+     *
+     * @example
+     * RouteUrl.match('/security/api-keys/123', '/security/api-keys/:id')
+     * // Returns: { params: { id: '123' } }
+     *
+     * @example
+     * RouteUrl.match('/tenant123/file-manager', '/file-manager', '/tenant123')
+     * // Returns: { params: {} }
+     */
+    static match(pathname: string, pattern: string, baseUrl?: string): MatchResult | null;
+    /**
+     * Generate a URL from the instance's pattern, params, and baseUrl.
+     */
+    private generate;
+    /**
+     * Match a pathname against the instance's pattern.
+     */
+    private matchPathname;
+    /**
+     * Extract path parameter names from the pattern.
+     */
+    private extractPathKeys;
+    /**
+     * Replace :param placeholders with actual values from params.
+     */
+    private replacePathParams;
+    /**
+     * Build query string from params that are not path parameters.
+     */
+    private buildQueryString;
+    /**
+     * Normalize baseUrl by ensuring it starts with / and doesn't end with /
+     */
+    private normalizeBaseUrl;
+    /**
+     * Compile the instance's pattern into a regex and extract parameter names.
+     */
+    private compilePattern;
+}
+export {};

package/features/router/RouteUrl.js

@@ -0,0 +1,232 @@
+/**
+ * Utility class for route URL pattern matching and generation.
+ * Handles simple route patterns with :param syntax (e.g., /cms/entries/:modelId).
+ *
+ * Public API uses static methods, which internally construct RouteUrl instances
+ * to handle the logic through proper instance methods.
+ */
+export class RouteUrl {
+  static patternCache = new Map();
+  constructor(pattern, params, baseUrl) {
+    this.pattern = pattern;
+    this.params = params;
+    this.baseUrl = this.normalizeBaseUrl(baseUrl);
+  }
+
+  /**
+   * Generate a URL from a route pattern and parameters.
+   * Path parameters are injected into the pattern, remaining parameters become query strings.
+   *
+   * @param pattern - Route pattern (e.g., '/security/api-keys/:id')
+   * @param params - Parameters object (e.g., { id: 123, new: true })
+   * @param baseUrl - Optional base URL to prepend (e.g., '/tenant123')
+   * @returns Generated URL string
+   *
+   * @example
+   * RouteUrl.fromPattern('/security/api-keys/:id', { id: 123, new: true })
+   * // Returns: '/security/api-keys/123?new=true'
+   *
+   * @example
+   * RouteUrl.fromPattern('/file-manager', {}, '/tenant123')
+   * // Returns: '/tenant123/file-manager'
+   */
+  static fromPattern(pattern, params, baseUrl) {
+    const routeUrl = new RouteUrl(pattern, params, baseUrl);
+    return routeUrl.generate();
+  }
+
+  /**
+   * Match a pathname against a route pattern and extract parameters.
+   * If baseUrl is provided, it will be stripped from the pathname before matching.
+   *
+   * @param pathname - The pathname to match (e.g., '/tenant123/security/api-keys/123')
+   * @param pattern - Route pattern (e.g., '/security/api-keys/:id')
+   * @param baseUrl - Optional base URL to strip before matching (e.g., '/tenant123')
+   * @returns Object with extracted params if matched, null otherwise
+   *
+   * @example
+   * RouteUrl.match('/security/api-keys/123', '/security/api-keys/:id')
+   * // Returns: { params: { id: '123' } }
+   *
+   * @example
+   * RouteUrl.match('/tenant123/file-manager', '/file-manager', '/tenant123')
+   * // Returns: { params: {} }
+   */
+  static match(pathname, pattern, baseUrl) {
+    const routeUrl = new RouteUrl(pattern, undefined, baseUrl);
+    return routeUrl.matchPathname(pathname);
+  }
+
+  /**
+   * Generate a URL from the instance's pattern, params, and baseUrl.
+   */
+  generate() {
+    if (!this.params) {
+      return this.baseUrl + this.pattern;
+    }
+
+    // Extract path parameter names from pattern
+    const pathKeys = this.extractPathKeys();
+
+    // Replace :param with actual values
+    let url = this.replacePathParams();
+
+    // Handle empty url
+    if (!url || url === "") {
+      url = "/";
+    }
+
+    // Prepend baseUrl
+    url = this.baseUrl + url;
+
+    // Add query parameters for keys not used in the path
+    const queryString = this.buildQueryString(pathKeys);
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    return url;
+  }
+
+  /**
+   * Match a pathname against the instance's pattern.
+   */
+  matchPathname(pathname) {
+    // Strip baseUrl from pathname if provided
+    if (this.baseUrl && pathname.startsWith(this.baseUrl)) {
+      pathname = pathname.slice(this.baseUrl.length) || "/";
+    } else if (this.baseUrl) {
+      // pathname doesn't start with baseUrl, no match
+      return null;
+    }
+
+    // Handle wildcard pattern
+    if (this.pattern === "*" || this.pattern === "(.*)") {
+      return {
+        params: {}
+      };
+    }
+
+    // Get or create cached pattern
+    let compiled = RouteUrl.patternCache.get(this.pattern);
+    if (!compiled) {
+      compiled = this.compilePattern();
+      RouteUrl.patternCache.set(this.pattern, compiled);
+    }
+    const match = pathname.match(compiled.regex);
+    if (!match) {
+      return null;
+    }
+
+    // Extract parameters from capture groups
+    const params = {};
+    compiled.keys.forEach((key, index) => {
+      const value = match[index + 1];
+      if (value !== undefined) {
+        params[key] = decodeURIComponent(value);
+      }
+    });
+    return {
+      params
+    };
+  }
+
+  /**
+   * Extract path parameter names from the pattern.
+   */
+  extractPathKeys() {
+    const pathKeys = new Set();
+    const paramRegex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    let match;
+    while ((match = paramRegex.exec(this.pattern)) !== null) {
+      pathKeys.add(match[1]);
+    }
+    return pathKeys;
+  }
+
+  /**
+   * Replace :param placeholders with actual values from params.
+   */
+  replacePathParams() {
+    return this.pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {
+      const value = this.params[key];
+      if (value === undefined || value === null) {
+        return "";
+      }
+      return encodeURIComponent(String(value));
+    });
+  }
+
+  /**
+   * Build query string from params that are not path parameters.
+   */
+  buildQueryString(pathKeys) {
+    const queryParams = {};
+    for (const key in this.params) {
+      if (!pathKeys.has(key)) {
+        queryParams[key] = this.params[key];
+      }
+    }
+    if (Object.keys(queryParams).length === 0) {
+      return "";
+    }
+    const searchParams = new URLSearchParams();
+    for (const key in queryParams) {
+      const value = queryParams[key];
+      if (value !== undefined && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach(v => searchParams.append(key, String(v)));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      }
+    }
+    return searchParams.toString();
+  }
+
+  /**
+   * Normalize baseUrl by ensuring it starts with / and doesn't end with /
+   */
+  normalizeBaseUrl(baseUrl) {
+    if (!baseUrl || baseUrl === "/") {
+      return "";
+    }
+    let normalized = baseUrl;
+
+    // Ensure it starts with /
+    if (!normalized.startsWith("/")) {
+      normalized = "/" + normalized;
+    }
+
+    // Remove trailing /
+    if (normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+  }
+
+  /**
+   * Compile the instance's pattern into a regex and extract parameter names.
+   */
+  compilePattern() {
+    const keys = [];
+
+    // Escape special regex characters except for :param syntax
+    let regexPattern = this.pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&") // Escape special chars
+    .replace(/\\\*/g, ".*"); // Handle * wildcard (already escaped by above)
+
+    // Replace :param with capture groups
+    regexPattern = regexPattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {
+      keys.push(key);
+      return "([^/]+)"; // Match any non-slash characters
+    });
+
+    // Create regex that matches the entire pathname
+    const regex = new RegExp(`^${regexPattern}$`);
+    return {
+      regex,
+      keys
+    };
+  }
+}
+
+//# sourceMappingURL=RouteUrl.js.map

package/features/router/RouteUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RouteUrl","patternCache","Map","constructor","pattern","params","baseUrl","normalizeBaseUrl","fromPattern","routeUrl","generate","match","pathname","undefined","matchPathname","pathKeys","extractPathKeys","url","replacePathParams","queryString","buildQueryString","startsWith","slice","length","compiled","get","compilePattern","set","regex","keys","forEach","key","index","value","decodeURIComponent","Set","paramRegex","exec","add","replace","_","encodeURIComponent","String","queryParams","has","Object","searchParams","URLSearchParams","Array","isArray","v","append","toString","normalized","endsWith","regexPattern","push","RegExp"],"sources":["RouteUrl.ts"],"sourcesContent":["interface Params {\n    [key: string]: any;\n}\n\ninterface MatchResult {\n    params: Record<string, string>;\n}\n\n/**\n * Utility class for route URL pattern matching and generation.\n * Handles simple route patterns with :param syntax (e.g., /cms/entries/:modelId).\n *\n * Public API uses static methods, which internally construct RouteUrl instances\n * to handle the logic through proper instance methods.\n */\nexport class RouteUrl {\n    private static patternCache = new Map<string, { regex: RegExp; keys: string[] }>();\n\n    private readonly pattern: string;\n    private readonly params: Params | undefined;\n    private readonly baseUrl: string;\n\n    private constructor(pattern: string, params?: Params, baseUrl?: string) {\n        this.pattern = pattern;\n        this.params = params;\n        this.baseUrl = this.normalizeBaseUrl(baseUrl);\n    }\n\n    /**\n     * Generate a URL from a route pattern and parameters.\n     * Path parameters are injected into the pattern, remaining parameters become query strings.\n     *\n     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')\n     * @param params - Parameters object (e.g., { id: 123, new: true })\n     * @param baseUrl - Optional base URL to prepend (e.g., '/tenant123')\n     * @returns Generated URL string\n     *\n     * @example\n     * RouteUrl.fromPattern('/security/api-keys/:id', { id: 123, new: true })\n     * // Returns: '/security/api-keys/123?new=true'\n     *\n     * @example\n     * RouteUrl.fromPattern('/file-manager', {}, '/tenant123')\n     * // Returns: '/tenant123/file-manager'\n     */\n    static fromPattern(pattern: string, params?: Params, baseUrl?: string): string {\n        const routeUrl = new RouteUrl(pattern, params, baseUrl);\n        return routeUrl.generate();\n    }\n\n    /**\n     * Match a pathname against a route pattern and extract parameters.\n     * If baseUrl is provided, it will be stripped from the pathname before matching.\n     *\n     * @param pathname - The pathname to match (e.g., '/tenant123/security/api-keys/123')\n     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')\n     * @param baseUrl - Optional base URL to strip before matching (e.g., '/tenant123')\n     * @returns Object with extracted params if matched, null otherwise\n     *\n     * @example\n     * RouteUrl.match('/security/api-keys/123', '/security/api-keys/:id')\n     * // Returns: { params: { id: '123' } }\n     *\n     * @example\n     * RouteUrl.match('/tenant123/file-manager', '/file-manager', '/tenant123')\n     * // Returns: { params: {} }\n     */\n    static match(pathname: string, pattern: string, baseUrl?: string): MatchResult | null {\n        const routeUrl = new RouteUrl(pattern, undefined, baseUrl);\n        return routeUrl.matchPathname(pathname);\n    }\n\n    /**\n     * Generate a URL from the instance's pattern, params, and baseUrl.\n     */\n    private generate(): string {\n        if (!this.params) {\n            return this.baseUrl + this.pattern;\n        }\n\n        // Extract path parameter names from pattern\n        const pathKeys = this.extractPathKeys();\n\n        // Replace :param with actual values\n        let url = this.replacePathParams();\n\n        // Handle empty url\n        if (!url || url === \"\") {\n            url = \"/\";\n        }\n\n        // Prepend baseUrl\n        url = this.baseUrl + url;\n\n        // Add query parameters for keys not used in the path\n        const queryString = this.buildQueryString(pathKeys);\n        if (queryString) {\n            url += `?${queryString}`;\n        }\n\n        return url;\n    }\n\n    /**\n     * Match a pathname against the instance's pattern.\n     */\n    private matchPathname(pathname: string): MatchResult | null {\n        // Strip baseUrl from pathname if provided\n        if (this.baseUrl && pathname.startsWith(this.baseUrl)) {\n            pathname = pathname.slice(this.baseUrl.length) || \"/\";\n        } else if (this.baseUrl) {\n            // pathname doesn't start with baseUrl, no match\n            return null;\n        }\n\n        // Handle wildcard pattern\n        if (this.pattern === \"*\" || this.pattern === \"(.*)\") {\n            return { params: {} };\n        }\n\n        // Get or create cached pattern\n        let compiled = RouteUrl.patternCache.get(this.pattern);\n        if (!compiled) {\n            compiled = this.compilePattern();\n            RouteUrl.patternCache.set(this.pattern, compiled);\n        }\n\n        const match = pathname.match(compiled.regex);\n        if (!match) {\n            return null;\n        }\n\n        // Extract parameters from capture groups\n        const params: Record<string, string> = {};\n        compiled.keys.forEach((key, index) => {\n            const value = match[index + 1];\n            if (value !== undefined) {\n                params[key] = decodeURIComponent(value);\n            }\n        });\n\n        return { params };\n    }\n\n    /**\n     * Extract path parameter names from the pattern.\n     */\n    private extractPathKeys(): Set<string> {\n        const pathKeys = new Set<string>();\n        const paramRegex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;\n        let match;\n        while ((match = paramRegex.exec(this.pattern)) !== null) {\n            pathKeys.add(match[1]);\n        }\n        return pathKeys;\n    }\n\n    /**\n     * Replace :param placeholders with actual values from params.\n     */\n    private replacePathParams(): string {\n        return this.pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {\n            const value = this.params![key];\n            if (value === undefined || value === null) {\n                return \"\";\n            }\n            return encodeURIComponent(String(value));\n        });\n    }\n\n    /**\n     * Build query string from params that are not path parameters.\n     */\n    private buildQueryString(pathKeys: Set<string>): string {\n        const queryParams: Record<string, any> = {};\n\n        for (const key in this.params) {\n            if (!pathKeys.has(key)) {\n                queryParams[key] = this.params[key];\n            }\n        }\n\n        if (Object.keys(queryParams).length === 0) {\n            return \"\";\n        }\n\n        const searchParams = new URLSearchParams();\n\n        for (const key in queryParams) {\n            const value = queryParams[key];\n            if (value !== undefined && value !== null) {\n                if (Array.isArray(value)) {\n                    value.forEach(v => searchParams.append(key, String(v)));\n                } else {\n                    searchParams.append(key, String(value));\n                }\n            }\n        }\n\n        return searchParams.toString();\n    }\n\n    /**\n     * Normalize baseUrl by ensuring it starts with / and doesn't end with /\n     */\n    private normalizeBaseUrl(baseUrl?: string): string {\n        if (!baseUrl || baseUrl === \"/\") {\n            return \"\";\n        }\n\n        let normalized = baseUrl;\n\n        // Ensure it starts with /\n        if (!normalized.startsWith(\"/\")) {\n            normalized = \"/\" + normalized;\n        }\n\n        // Remove trailing /\n        if (normalized.endsWith(\"/\")) {\n            normalized = normalized.slice(0, -1);\n        }\n\n        return normalized;\n    }\n\n    /**\n     * Compile the instance's pattern into a regex and extract parameter names.\n     */\n    private compilePattern(): { regex: RegExp; keys: string[] } {\n        const keys: string[] = [];\n\n        // Escape special regex characters except for :param syntax\n        let regexPattern = this.pattern\n            .replace(/[.+?^${}()|[\\]\\\\]/g, \"\\\\$&\") // Escape special chars\n            .replace(/\\\\\\*/g, \".*\"); // Handle * wildcard (already escaped by above)\n\n        // Replace :param with capture groups\n        regexPattern = regexPattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {\n            keys.push(key);\n            return \"([^/]+)\"; // Match any non-slash characters\n        });\n\n        // Create regex that matches the entire pathname\n        const regex = new RegExp(`^${regexPattern}$`);\n\n        return { regex, keys };\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/features/router/Router.d.ts

@@ -0,0 +1,45 @@
+import type { RouteDefinition, MatchedRoute } from "./abstractions.js";
+interface ResolveResult {
+    matchedRoute: MatchedRoute;
+    onMatch: (route: MatchedRoute) => void;
+}
+/**
+ * Router manages a collection of route definitions and resolves pathnames to matched routes.
+ */
+export declare class Router {
+    private routes;
+    private baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Set or update route definitions. Routes with the same name will be replaced.
+     *
+     * @param routes - Array of route definitions to add
+     */
+    setRoutes(routes: RouteDefinition[]): void;
+    /**
+     * Find a route by name.
+     *
+     * @param name - Route name to find
+     * @returns Route definition if found, undefined otherwise
+     */
+    findRoute(name: string): RouteDefinition | undefined;
+    /**
+     * Resolve a pathname to a matched route.
+     * The pathname will be matched against patterns after stripping the baseUrl.
+     *
+     * @param pathname - The pathname to resolve (e.g., '/tenant123/cms/entries/123')
+     * @param queryParams - Optional query parameters to merge into route params
+     * @returns Matched route with onMatch callback, or null if no route matches
+     */
+    resolve(pathname: string, queryParams?: Record<string, unknown>): ResolveResult | null;
+    /**
+     * Get the current baseUrl.
+     */
+    getBaseUrl(): string;
+    /**
+     * Sort routes to ensure proper matching order.
+     * Wildcard routes (*) and index routes (/) are moved to the bottom.
+     */
+    private sortRoutes;
+}
+export {};

package/features/router/Router.js

@@ -0,0 +1,129 @@
+import { RouteUrl } from "./RouteUrl.js";
+/**
+ * Router manages a collection of route definitions and resolves pathnames to matched routes.
+ */
+export class Router {
+  routes = [];
+  constructor(baseUrl = "") {
+    this.baseUrl = baseUrl;
+  }
+
+  /**
+   * Set or update route definitions. Routes with the same name will be replaced.
+   *
+   * @param routes - Array of route definitions to add
+   */
+  setRoutes(routes) {
+    routes.forEach(route => {
+      const index = this.routes.findIndex(r => r.name === route.name);
+      if (index > -1) {
+        this.routes[index] = route;
+      } else {
+        this.routes.push(route);
+      }
+    });
+    this.sortRoutes();
+  }
+
+  /**
+   * Find a route by name.
+   *
+   * @param name - Route name to find
+   * @returns Route definition if found, undefined otherwise
+   */
+  findRoute(name) {
+    return this.routes.find(r => r.name === name);
+  }
+
+  /**
+   * Resolve a pathname to a matched route.
+   * The pathname will be matched against patterns after stripping the baseUrl.
+   *
+   * @param pathname - The pathname to resolve (e.g., '/tenant123/cms/entries/123')
+   * @param queryParams - Optional query parameters to merge into route params
+   * @returns Matched route with onMatch callback, or null if no route matches
+   */
+  resolve(pathname, queryParams) {
+    for (const route of this.routes) {
+      const pattern = route.path === "*" ? "(.*)" : route.path;
+      const matchResult = RouteUrl.match(pathname, pattern, this.baseUrl);
+      if (matchResult) {
+        const matchedRoute = {
+          name: route.name,
+          path: route.path,
+          pathname,
+          params: {
+            ...matchResult.params,
+            ...(queryParams || {})
+          }
+        };
+        const onMatch = matched => {
+          route.onMatch(matched);
+        };
+        return {
+          matchedRoute,
+          onMatch
+        };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get the current baseUrl.
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+
+  /**
+   * Sort routes to ensure proper matching order.
+   * Wildcard routes (*) and index routes (/) are moved to the bottom.
+   */
+  sortRoutes() {
+    const INDEX_PATH = "/";
+    const WILDCARD_PATTERNS = ["*", "(.*)"];
+    this.routes.sort((a, b) => {
+      const pathA = a.path || "*";
+      const pathB = b.path || "*";
+      const isWildcardA = WILDCARD_PATTERNS.includes(pathA);
+      const isWildcardB = WILDCARD_PATTERNS.includes(pathB);
+      const isIndexA = pathA === INDEX_PATH;
+      const isIndexB = pathB === INDEX_PATH;
+
+      // Both are wildcards or both are index - maintain order
+      if (isWildcardA && isWildcardB || isIndexA && isIndexB) {
+        return 0;
+      }
+
+      // Index path should come before wildcard
+      if (isIndexA && isWildcardB) {
+        return -1;
+      }
+      if (isWildcardA && isIndexB) {
+        return 1;
+      }
+
+      // Push wildcards to the bottom
+      if (isWildcardA) {
+        return 1;
+      }
+      if (isWildcardB) {
+        return -1;
+      }
+
+      // Push index to the bottom (but above wildcards)
+      if (isIndexA) {
+        return 1;
+      }
+      if (isIndexB) {
+        return -1;
+      }
+
+      // All other routes maintain their order
+      return 0;
+    });
+  }
+}
+
+//# sourceMappingURL=Router.js.map

package/features/router/Router.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RouteUrl","Router","routes","constructor","baseUrl","setRoutes","forEach","route","index","findIndex","r","name","push","sortRoutes","findRoute","find","resolve","pathname","queryParams","pattern","path","matchResult","match","matchedRoute","params","onMatch","matched","getBaseUrl","INDEX_PATH","WILDCARD_PATTERNS","sort","a","b","pathA","pathB","isWildcardA","includes","isWildcardB","isIndexA","isIndexB"],"sources":["Router.ts"],"sourcesContent":["import type { RouteDefinition, MatchedRoute } from \"./abstractions.js\";\nimport { RouteUrl } from \"./RouteUrl.js\";\n\ninterface ResolveResult {\n    matchedRoute: MatchedRoute;\n    onMatch: (route: MatchedRoute) => void;\n}\n\n/**\n * Router manages a collection of route definitions and resolves pathnames to matched routes.\n */\nexport class Router {\n    private routes: RouteDefinition[] = [];\n    private baseUrl: string;\n\n    constructor(baseUrl: string = \"\") {\n        this.baseUrl = baseUrl;\n    }\n\n    /**\n     * Set or update route definitions. Routes with the same name will be replaced.\n     *\n     * @param routes - Array of route definitions to add\n     */\n    setRoutes(routes: RouteDefinition[]): void {\n        routes.forEach(route => {\n            const index = this.routes.findIndex(r => r.name === route.name);\n\n            if (index > -1) {\n                this.routes[index] = route;\n            } else {\n                this.routes.push(route);\n            }\n        });\n\n        this.sortRoutes();\n    }\n\n    /**\n     * Find a route by name.\n     *\n     * @param name - Route name to find\n     * @returns Route definition if found, undefined otherwise\n     */\n    findRoute(name: string): RouteDefinition | undefined {\n        return this.routes.find(r => r.name === name);\n    }\n\n    /**\n     * Resolve a pathname to a matched route.\n     * The pathname will be matched against patterns after stripping the baseUrl.\n     *\n     * @param pathname - The pathname to resolve (e.g., '/tenant123/cms/entries/123')\n     * @param queryParams - Optional query parameters to merge into route params\n     * @returns Matched route with onMatch callback, or null if no route matches\n     */\n    resolve(pathname: string, queryParams?: Record<string, unknown>): ResolveResult | null {\n        for (const route of this.routes) {\n            const pattern = route.path === \"*\" ? \"(.*)\" : route.path;\n            const matchResult = RouteUrl.match(pathname, pattern, this.baseUrl);\n\n            if (matchResult) {\n                const matchedRoute: MatchedRoute = {\n                    name: route.name,\n                    path: route.path,\n                    pathname,\n                    params: { ...matchResult.params, ...(queryParams || {}) }\n                };\n\n                const onMatch = (matched: MatchedRoute) => {\n                    route.onMatch(matched);\n                };\n\n                return { matchedRoute, onMatch };\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * Get the current baseUrl.\n     */\n    getBaseUrl(): string {\n        return this.baseUrl;\n    }\n\n    /**\n     * Sort routes to ensure proper matching order.\n     * Wildcard routes (*) and index routes (/) are moved to the bottom.\n     */\n    private sortRoutes(): void {\n        const INDEX_PATH = \"/\";\n        const WILDCARD_PATTERNS = [\"*\", \"(.*)\"];\n\n        this.routes.sort((a, b) => {\n            const pathA = a.path || \"*\";\n            const pathB = b.path || \"*\";\n\n            const isWildcardA = WILDCARD_PATTERNS.includes(pathA);\n            const isWildcardB = WILDCARD_PATTERNS.includes(pathB);\n            const isIndexA = pathA === INDEX_PATH;\n            const isIndexB = pathB === INDEX_PATH;\n\n            // Both are wildcards or both are index - maintain order\n            if ((isWildcardA && isWildcardB) || (isIndexA && isIndexB)) {\n                return 0;\n            }\n\n            // Index path should come before wildcard\n            if (isIndexA && isWildcardB) {\n                return -1;\n            }\n            if (isWildcardA && isIndexB) {\n                return 1;\n            }\n\n            // Push wildcards to the bottom\n            if (isWildcardA) {\n                return 1;\n            }\n            if (isWildcardB) {\n                return -1;\n            }\n\n            // Push index to the bottom (but above wildcards)\n            if (isIndexA) {\n                return 1;\n            }\n            if (isIndexB) {\n                return -1;\n            }\n\n            // All other routes maintain their order\n            return 0;\n        });\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/features/router/RouterPresenter.d.ts

@@ -0,0 +1,17 @@
+import { Route } from "./Route.js";
+import { RouterRepository, RouterPresenter as Abstraction, type OnRouteExit } from "./abstractions.js";
+declare class RouterPresenterImpl implements Abstraction.Interface {
+    private routerRepository;
+    constructor(routerRepository: RouterRepository.Interface);
+    get vm(): {
+        currentRoute: import("./abstractions.js").MatchedRoute<Record<string, any>> | undefined;
+    };
+    bootstrap: (routes: Route[]) => void;
+    goToRoute: (route: any, params?: any) => void;
+    setRouteParams: (cb: any) => void;
+    getLink: (route: any, params?: any) => string;
+    onRouteExit: (cb: OnRouteExit) => void;
+    destroy: () => void;
+}
+export declare const RouterPresenter: import("@webiny/di").Implementation<typeof RouterPresenterImpl>;
+export {};