@b9g/match-pattern 0.1.6 → 0.1.7

package/src/match-pattern.d.ts

@@ -1,43 +0,0 @@
-declare let URLPattern: any;
-type URLPatternInput = URLPatternInit | string;
-interface URLPatternComponentResult {
-    input: string;
-    groups: Record<string, string | undefined>;
-}
-interface URLPatternResult {
-    inputs: URLPatternInput[];
-    protocol: URLPatternComponentResult;
-    username: URLPatternComponentResult;
-    password: URLPatternComponentResult;
-    hostname: URLPatternComponentResult;
-    port: URLPatternComponentResult;
-    pathname: URLPatternComponentResult;
-    search: URLPatternComponentResult;
-    hash: URLPatternComponentResult;
-}
-/**
- * Enhanced URLPattern result that includes unified params
- */
-export interface MatchPatternResult extends URLPatternResult {
-    params: Record<string, string>;
-}
-/**
- * MatchPattern extends URLPattern with enhanced routing capabilities:
- * - Order-independent search parameter matching
- * - Non-exhaustive search matching (extra params allowed)
- * - Unified parameter extraction (pathname + search + extras)
- * - Enhanced string pattern parsing with & syntax
- */
-export declare class MatchPattern extends URLPattern {
-    private _originalInput;
-    constructor(input: string | URLPatternInit, baseURL?: string);
-    /**
-     * Enhanced exec that returns unified params object
-     */
-    exec(input: string | URL): MatchPatternResult | null;
-    /**
-     * Enhanced test with order-independent search parameter matching
-     */
-    test(input: string | URL): boolean;
-}
-export {};

package/src/match-pattern.js

@@ -1,183 +0,0 @@
-/// <reference types="./match-pattern.d.ts" />
-// src/match-pattern.ts
-var URLPattern = globalThis.URLPattern;
-if (!URLPattern) {
-  await import("urlpattern-polyfill");
-  URLPattern = globalThis.URLPattern;
-}
-var MatchPattern = class extends URLPattern {
-  _originalInput;
-  constructor(input, baseURL) {
-    let processedInput = input;
-    if (typeof input === "string") {
-      processedInput = parseStringPattern(input);
-    }
-    if (baseURL !== void 0) {
-      super(processedInput, baseURL);
-    } else {
-      super(processedInput);
-    }
-    this._originalInput = processedInput;
-  }
-  /**
-   * Enhanced exec that returns unified params object
-   */
-  exec(input) {
-    if (!this.test(input)) {
-      return null;
-    }
-    const result = super.exec(input);
-    if (result) {
-      const enhancedResult = {
-        ...result,
-        params: extractUnifiedParams(result, input)
-      };
-      return enhancedResult;
-    }
-    return buildCustomResult(this, input);
-  }
-  /**
-   * Enhanced test with order-independent search parameter matching
-   */
-  test(input) {
-    const url = typeof input === "string" ? new URL(input) : input;
-    if (!this.search || this.search === "*") {
-      return super.test(input);
-    }
-    const pathPatternInit = typeof this._originalInput === "string" ? { pathname: this._originalInput } : { ...this._originalInput, search: void 0 };
-    const pathPattern = new URLPattern(pathPatternInit);
-    if (!pathPattern.test(input)) {
-      return false;
-    }
-    return testSearchParameters(this.search, url.searchParams);
-  }
-};
-function parseStringPattern(pattern) {
-  if (pattern.includes("://")) {
-    const ampIndex2 = pattern.indexOf("&");
-    if (ampIndex2 === -1) {
-      return pattern;
-    }
-    const urlPart = pattern.slice(0, ampIndex2);
-    const search2 = pattern.slice(ampIndex2 + 1);
-    try {
-      const url = new URL(urlPart.replace(/:(\w+)/g, "placeholder"));
-      return {
-        protocol: urlPart.split("://")[0],
-        hostname: url.hostname,
-        pathname: url.pathname.replace(/placeholder/g, ":$1"),
-        // Restore params
-        search: search2
-      };
-    } catch {
-      return pattern;
-    }
-  }
-  const ampIndex = pattern.indexOf("&");
-  if (ampIndex === -1) {
-    return { pathname: pattern };
-  }
-  if (ampIndex === 0) {
-    return { search: pattern.slice(1) };
-  }
-  const pathname = pattern.slice(0, ampIndex);
-  const search = pattern.slice(ampIndex + 1);
-  return { pathname, search };
-}
-function extractUnifiedParams(result, url) {
-  const params = {};
-  if (result.pathname?.groups) {
-    for (const [key, value] of Object.entries(result.pathname.groups)) {
-      if (value !== void 0) {
-        params[key] = value;
-      }
-    }
-  }
-  if (result.search?.groups) {
-    const actualUrl = typeof url === "string" ? new URL(url) : url;
-    const searchParams = actualUrl.searchParams;
-    for (const [key, value] of searchParams) {
-      params[key] = value;
-    }
-  } else if (typeof url !== "string") {
-    const actualUrl = url instanceof URL ? url : new URL(url);
-    for (const [key, value] of actualUrl.searchParams) {
-      params[key] = value;
-    }
-  }
-  return params;
-}
-function buildCustomResult(pattern, input) {
-  const url = typeof input === "string" ? new URL(input) : input;
-  const result = {
-    inputs: [input],
-    pathname: { input: url.pathname, groups: {} },
-    search: { input: url.search, groups: {} },
-    hash: { input: url.hash, groups: {} },
-    protocol: { input: url.protocol, groups: {} },
-    hostname: { input: url.hostname, groups: {} },
-    port: { input: url.port, groups: {} },
-    username: { input: url.username, groups: {} },
-    password: { input: url.password, groups: {} },
-    params: {}
-  };
-  if (pattern.pathname && pattern.pathname !== "*") {
-    const pathPattern = new URLPattern({ pathname: pattern.pathname });
-    const pathResult = pathPattern.exec(url);
-    if (pathResult?.pathname?.groups) {
-      result.pathname.groups = pathResult.pathname.groups;
-    }
-  }
-  if (pattern.search && pattern.search !== "*") {
-    const searchParams = parseSearchPattern(pattern.search);
-    const actualParams = url.searchParams;
-    for (const [key, paramDef] of searchParams) {
-      if (actualParams.has(key)) {
-        if (paramDef.type === "named" && paramDef.name) {
-          result.search.groups[paramDef.name] = actualParams.get(key);
-        }
-      }
-    }
-  }
-  result.params = extractUnifiedParams(result, input);
-  return result;
-}
-function testSearchParameters(searchPattern, actualParams) {
-  const patternParams = parseSearchPattern(searchPattern);
-  for (const [key, paramPattern] of patternParams) {
-    if (!actualParams.has(key)) {
-      return false;
-    }
-    if (paramPattern.type === "literal") {
-      if (actualParams.get(key) !== paramPattern.value) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function parseSearchPattern(pattern) {
-  const params = /* @__PURE__ */ new Map();
-  const parts = pattern.split("&");
-  for (const part of parts) {
-    const [key, value] = part.split("=");
-    if (!key || !value)
-      continue;
-    if (value.startsWith(":")) {
-      const isOptional = value.endsWith("?");
-      params.set(key, {
-        type: "named",
-        name: value.slice(1, isOptional ? -1 : void 0),
-        optional: isOptional
-      });
-    } else if (value === "*") {
-      params.set(key, { type: "wildcard" });
-    } else {
-      params.set(key, { type: "literal", value });
-    }
-  }
-  return params;
-}
-export {
-  MatchPattern
-};