@salesforce/ui-bundle 1.117.2

package/dist/proxy/handler.js

@@ -0,0 +1,530 @@
+import { LIVE_PREVIEW_SCRIPT_MARKER, getLivePreviewScriptContent } from "./livePreviewScript.js";
+import { applyTrailingSlash, matchRoute } from "./routing.js";
+import { version } from "../package.json.js";
+import { refreshOrgAuth } from "../app/org.js";
+import "node:fs/promises";
+const UIBUNDLE_HEALTH_CHECK_PARAM = "sfProxyHealthCheck";
+const UIBUNDLE_PROXY_HEADER = "X-Salesforce-UIBundle-Proxy";
+const LIGHTNING_OUT_SINGLE_ACCESS_PATH = "/services/oauth2/singleaccess";
+const SALESFORCE_API_PREFIXES = ["/services/", "/lwr/apex/"];
+const SALESFORCE_FILE_UPLOAD_PREFIX = "/chatter/handlers/file/body";
+const AUTH_FAILED_RESPONSE = {
+  error: "AUTHENTICATION_FAILED",
+  message: "Authentication failed. Please re-authenticate to your Salesforce org.",
+  status: 401
+};
+class AuthenticationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+}
+class UIBundleProxyHandler {
+  constructor(manifest, orgInfo, target, basePath, options) {
+    this.manifest = manifest;
+    this.orgInfo = orgInfo;
+    this.target = target;
+    this.basePath = basePath;
+    this.options = options;
+  }
+  startTime = Date.now();
+  async handle(req, res, next) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.searchParams.get(UIBUNDLE_HEALTH_CHECK_PARAM) === "true") {
+      this.handleHealthCheck(res);
+      return;
+    }
+    let pathname = url.pathname;
+    if (pathname === "/__lo/frontdoor") {
+      await this.handleLightningOutFrontdoor(req, res, url);
+      return;
+    }
+    if (this.options?.debug) {
+      console.log(`[ui-bundle-proxy] ${req.method} ${pathname}`);
+    }
+    pathname = applyTrailingSlash(pathname, this.manifest.routing?.trailingSlash);
+    const match = matchRoute(
+      pathname,
+      this.basePath,
+      this.manifest.routing?.rewrites,
+      this.manifest.routing?.redirects
+    );
+    if (match) {
+      if (match.type === "api") {
+        await this.handleSalesforceApi(req, res);
+        return;
+      }
+      if (match.type === "gql") {
+        await this.handleGraphQL(req, res);
+        return;
+      }
+      if (match.type === "redirect" && match.target && match.statusCode) {
+        this.handleRedirect(res, match.target, match.statusCode);
+        return;
+      }
+      if (match.type === "rewrite" && match.target) {
+        url.pathname = `/${match.target}`.replace(/\/+/g, "/");
+        req.url = url.pathname + url.search;
+        if (this.options?.debug) {
+          console.log(`[ui-bundle-proxy] Rewrite to ${req.url}`);
+        }
+        if (next) {
+          next();
+          return;
+        }
+        await this.forwardToDevServer(req, res);
+        return;
+      }
+      if (match.type === "file-upload") {
+        if (this.options?.debug) {
+          console.log("[ui-bundle-proxy] file-upload match found → handleFileUpload");
+        }
+        await this.handleFileUpload(req, res);
+        return;
+      }
+    }
+    if (pathname.startsWith(SALESFORCE_FILE_UPLOAD_PREFIX)) {
+      await this.handleFileUpload(req, res);
+      return;
+    } else if (SALESFORCE_API_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
+      await this.handleSalesforceApi(req, res);
+      return;
+    }
+    if (next) {
+      next();
+    } else {
+      await this.forwardToDevServer(req, res);
+    }
+  }
+  async forwardToDevServer(req, res) {
+    try {
+      const baseUrl = this.target ?? `http://${req.headers.host ?? "localhost"}`;
+      const url = new URL(req.url ?? "/", baseUrl);
+      if (this.options?.debug) {
+        console.log(`[ui-bundle-proxy] Forwarding to dev server: ${url.href}`);
+      }
+      const body = req.method !== "GET" && req.method !== "HEAD" ? await getBody(req) : void 0;
+      const response = await fetch(url.href, {
+        method: req.method,
+        headers: getFilteredHeaders(req.headers),
+        body
+      });
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[ui-bundle-proxy] Dev server request failed:", error);
+      this.sendAuthOrGatewayError(res, error, "Failed to forward request to dev server");
+    }
+  }
+  handleRedirect(res, location, statusCode) {
+    res.writeHead(statusCode, { Location: location });
+    res.end();
+  }
+  handleHealthCheck(res) {
+    const response = {
+      proxyName: "@salesforce/ui-bundle",
+      proxyVersion: version,
+      port: this.target ? new URL(this.target).port : void 0,
+      org: this.orgInfo?.orgAlias ?? this.orgInfo?.username,
+      apiVersion: this.orgInfo?.apiVersion,
+      uiBundleName: this.manifest.name,
+      uiBundleFolderPath: this.basePath,
+      uptime: Date.now() - this.startTime,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      debugMode: this.options?.debug ?? false
+    };
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      [UIBUNDLE_PROXY_HEADER]: "true"
+    });
+    res.end(JSON.stringify(response, null, 2));
+  }
+  sendNoOrgError(res) {
+    res.writeHead(401, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "NO_ORG_FOUND",
+        message: "No default Salesforce org found. Run 'sf org login web --set-default' to authenticate."
+      })
+    );
+  }
+  sendJson(res, statusCode, body) {
+    res.writeHead(statusCode, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+  }
+  sendAuthOrGatewayError(res, error, gatewayMessage) {
+    if (error instanceof AuthenticationError) {
+      this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
+    } else {
+      this.sendJson(res, 502, {
+        error: "GATEWAY_ERROR",
+        message: gatewayMessage
+      });
+    }
+  }
+  async handleLightningOutFrontdoor(req, res, _url) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      if (req.method && req.method !== "GET") {
+        this.sendJson(res, 405, { error: "METHOD_NOT_ALLOWED", message: "Use GET" });
+        return;
+      }
+      const { rawInstanceUrl, accessToken, orgId } = this.orgInfo;
+      const frontdoorUrl = await this.fetchLightningOutFrontdoorUrl(rawInstanceUrl, accessToken);
+      if (!frontdoorUrl) {
+        this.sendJson(res, 502, {
+          error: "FRONTDOOR_FAILED",
+          message: "No frontdoor URL returned from Salesforce"
+        });
+        return;
+      }
+      this.sendJson(res, 200, {
+        frontdoorUrl,
+        instanceUrl: rawInstanceUrl,
+        orgId
+      });
+    } catch (error) {
+      console.error("[ui-bundle-proxy] Frontdoor request failed:", error);
+      this.sendJson(res, 502, {
+        error: "GATEWAY_ERROR",
+        message: "Failed to generate frontdoor URL"
+      });
+    }
+  }
+  async fetchLightningOutFrontdoorUrl(rawInstanceUrl, accessToken) {
+    let baseUrl = rawInstanceUrl.replace(/\/$/, "");
+    let response = await fetch(`${baseUrl}${LIGHTNING_OUT_SINGLE_ACCESS_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    if (response.status === 401 || response.status === 403) {
+      const updatedOrgInfo = await this.refreshToken();
+      if (!updatedOrgInfo) {
+        throw new AuthenticationError("Failed to refresh token");
+      }
+      baseUrl = updatedOrgInfo.rawInstanceUrl.replace(/\/$/, "");
+      response = await fetch(`${baseUrl}${LIGHTNING_OUT_SINGLE_ACCESS_PATH}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${updatedOrgInfo.accessToken}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+    }
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Frontdoor exchange failed: ${response.status} ${errorBody}`);
+    }
+    const data = await response.json();
+    return data.frontdoor_uri ?? null;
+  }
+  async handleSalesforceApi(req, res) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      let pathIndex = url.pathname.indexOf("/lwr/apex/v");
+      if (pathIndex === -1) {
+        pathIndex = url.pathname.indexOf("/services/data/v");
+      }
+      const apiPath = url.pathname.substring(pathIndex);
+      let targetUrl = `${this.orgInfo.instanceUrl}${apiPath}${url.search}`;
+      if (this.options?.debug) {
+        console.log(`[ui-bundle-proxy] Forwarding to Salesforce: ${targetUrl}`);
+      }
+      const body = req.method !== "GET" && req.method !== "HEAD" ? await getBody(req) : void 0;
+      let response = await fetch(targetUrl, {
+        method: req.method,
+        headers: {
+          ...getFilteredHeaders(req.headers),
+          Cookie: `sid=${this.orgInfo.accessToken}`,
+          Accept: req.headers.accept ?? "application/json",
+          // necessary for Apex requests, for which SessionUtil.validateSessionUsage won't accept OAuth token as `sid` cookie
+          Authorization: `Bearer ${this.orgInfo.accessToken}`
+        },
+        body
+      });
+      if (response.status === 401 || response.status === 403) {
+        console.warn(`[ui-bundle-proxy] Received ${response.status}, refreshing token...`);
+        const updatedOrgInfo = await this.refreshToken();
+        if (updatedOrgInfo === void 0) {
+          console.error("[ui-bundle-proxy] Failed to refresh token - authentication error");
+          this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
+          return;
+        }
+        if (this.options?.debug) {
+          console.log("[ui-bundle-proxy] Token refreshed, retrying request");
+        }
+        targetUrl = `${updatedOrgInfo.instanceUrl}${url.pathname}${url.search}`;
+        response = await fetch(targetUrl, {
+          method: req.method,
+          headers: {
+            ...getFilteredHeaders(req.headers),
+            Cookie: `sid=${updatedOrgInfo.accessToken}`,
+            Accept: req.headers.accept ?? "application/json"
+          },
+          body
+        });
+      }
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[ui-bundle-proxy] Salesforce API request failed:", error);
+      this.sendAuthOrGatewayError(res, error, "Failed to forward request to Salesforce");
+    }
+  }
+  async refreshToken() {
+    if (!this.orgInfo) {
+      return void 0;
+    }
+    const refreshIdentifier = this.orgInfo.orgAlias || this.orgInfo.username;
+    if (!refreshIdentifier) {
+      throw new AuthenticationError("Cannot refresh token: no org alias or username available");
+    }
+    const updatedOrgInfo = await refreshOrgAuth(refreshIdentifier);
+    if (!updatedOrgInfo) {
+      return void 0;
+    }
+    this.orgInfo = updatedOrgInfo;
+    if (this.options?.onTokenRefresh) {
+      this.options.onTokenRefresh(updatedOrgInfo);
+    }
+    return updatedOrgInfo;
+  }
+  async handleGraphQL(req, res) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      const { rawInstanceUrl, apiVersion, accessToken } = this.orgInfo;
+      let targetUrl = `${rawInstanceUrl}/services/data/v${apiVersion}/graphql`;
+      if (this.options?.debug) {
+        console.log(`[ui-bundle-proxy] Forwarding GraphQL to Salesforce: ${targetUrl}`);
+      }
+      const body = await getBody(req);
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "X-Chatter-Entity-Encoding": "false"
+      };
+      let response = await fetch(targetUrl, {
+        method: "POST",
+        headers,
+        body
+      });
+      if (response.status === 401 || response.status === 403) {
+        console.warn(`[ui-bundle-proxy] Received ${response.status}, refreshing token...`);
+        const updatedOrgInfo = await this.refreshToken();
+        if (updatedOrgInfo !== void 0) {
+          if (this.options?.debug) {
+            console.log("[ui-bundle-proxy] Token refreshed, retrying request");
+          }
+          const { rawInstanceUrl: rawInstanceUrl2, apiVersion: apiVersion2, accessToken: accessToken2 } = updatedOrgInfo;
+          targetUrl = `${rawInstanceUrl2}/services/data/v${apiVersion2}/graphql`;
+          headers.Authorization = `Bearer ${accessToken2}`;
+          response = await fetch(targetUrl, {
+            method: "POST",
+            headers,
+            body
+          });
+        } else {
+          console.error(
+            "[ui-bundle-proxy] Failed to refresh token for GraphQL - authentication error"
+          );
+          this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
+          return;
+        }
+      }
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[ui-bundle-proxy] GraphQL request failed:", error);
+      this.sendAuthOrGatewayError(res, error, "Failed to forward GraphQL request to Salesforce");
+    }
+  }
+  async sendResponse(res, response) {
+    const headers = {};
+    const skipHeaders = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding"]);
+    response.headers.forEach((value, key) => {
+      if (!skipHeaders.has(key.toLowerCase())) {
+        headers[key] = value;
+      }
+    });
+    const contentType = response.headers.get("content-type") || "";
+    const isHtml = contentType.includes("text/html");
+    if (isHtml && response.body) {
+      const chunks = [];
+      const reader = response.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const buffer = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.length;
+      }
+      const html = new TextDecoder().decode(buffer);
+      const modifiedHtml = UIBundleProxyHandler.injectLivePreviewScript(html);
+      const modifiedBuffer = new TextEncoder().encode(modifiedHtml);
+      headers["content-length"] = modifiedBuffer.length.toString();
+      res.writeHead(response.status, headers);
+      res.write(modifiedBuffer);
+    } else {
+      res.writeHead(response.status, headers);
+      if (response.body) {
+        const reader = response.body.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
+        }
+      }
+    }
+    res.end();
+  }
+  static injectLivePreviewScript(html) {
+    if (html.includes(LIVE_PREVIEW_SCRIPT_MARKER)) {
+      return html;
+    }
+    const scriptContent = getLivePreviewScriptContent();
+    const scriptTag = `<script ${LIVE_PREVIEW_SCRIPT_MARKER}>` + scriptContent + "<\/script>";
+    if (html.includes("</body>")) {
+      const lastBodyIndex = html.lastIndexOf("</body>");
+      return html.substring(0, lastBodyIndex) + scriptTag + html.substring(lastBodyIndex);
+    }
+    if (html.includes("</html>")) {
+      const lastHtmlIndex = html.lastIndexOf("</html>");
+      return html.substring(0, lastHtmlIndex) + scriptTag + html.substring(lastHtmlIndex);
+    }
+    return html + scriptTag;
+  }
+  /**
+   * Proxy POST /chatter/handlers/file/body (XHR/file upload) to Salesforce.
+   * Uses rawInstanceUrl for Chatter API. Preserves multipart/form-data from XHR.
+   */
+  async handleFileUpload(req, res) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      const pathIndex = url.pathname.indexOf("/chatter/handlers/file/body");
+      const apiPath = url.pathname.substring(pathIndex);
+      const uploadUrl = `${this.orgInfo.rawInstanceUrl}${apiPath}${url.search}`;
+      if (this.options?.debug) {
+        console.log(`[ui-bundle-proxy] Forwarding file upload to Salesforce: ${uploadUrl}`);
+      }
+      const body = await getBody(req);
+      if (!body?.length) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "BAD_REQUEST",
+            message: "Request body is empty"
+          })
+        );
+        return;
+      }
+      const contentType = req.headers["content-type"];
+      if (!contentType?.includes("multipart/form-data")) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "BAD_REQUEST",
+            message: "Content-Type must be multipart/form-data"
+          })
+        );
+        return;
+      }
+      const headers = {
+        "Content-Type": contentType,
+        "Content-Length": String(body.length),
+        Cookie: `sid=${this.orgInfo.accessToken}`,
+        Authorization: `Bearer ${this.orgInfo.accessToken}`
+      };
+      const response = await fetch(uploadUrl, {
+        method: "POST",
+        headers,
+        body: new Uint8Array(body)
+      });
+      const resHeaders = {};
+      const skipHeaders = /* @__PURE__ */ new Set(["content-encoding", "transfer-encoding"]);
+      response.headers.forEach((value, key) => {
+        if (!skipHeaders.has(key.toLowerCase())) {
+          resHeaders[key] = value;
+        }
+      });
+      res.writeHead(response.status, resHeaders);
+      if (response.body) {
+        const reader = response.body.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
+        }
+      }
+      res.end();
+    } catch (error) {
+      console.error("[ui-bundle-proxy] File upload proxy failed:", error);
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "GATEWAY_ERROR",
+          message: "Failed to forward file upload"
+        })
+      );
+    }
+  }
+}
+function createProxyHandler(manifest, orgInfo, target, basePath, options) {
+  const handler = new UIBundleProxyHandler(manifest, orgInfo, target, basePath, options);
+  return (req, res, next) => handler.handle(req, res, next);
+}
+function injectLivePreviewScript(html) {
+  return UIBundleProxyHandler.injectLivePreviewScript(html);
+}
+function getFilteredHeaders(headers) {
+  const filtered = {};
+  const hopByHopHeaders = /* @__PURE__ */ new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade"
+  ]);
+  for (const [key, value] of Object.entries(headers)) {
+    if (!hopByHopHeaders.has(key.toLowerCase()) && value) {
+      filtered[key] = Array.isArray(value) ? value.join(", ") : typeof value === "string" ? value : String(value);
+    }
+  }
+  return filtered;
+}
+function getBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+export {
+  UIBUNDLE_HEALTH_CHECK_PARAM,
+  UIBUNDLE_PROXY_HEADER,
+  createProxyHandler,
+  injectLivePreviewScript
+};

package/dist/proxy/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+export type { ProxyOptions, ProxyHandler } from './handler';
+export { createProxyHandler, injectLivePreviewScript, UIBUNDLE_HEALTH_CHECK_PARAM, UIBUNDLE_PROXY_HEADER, } from './handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/proxy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proxy/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC5D,OAAO,EACN,kBAAkB,EAClB,uBAAuB,EACvB,2BAA2B,EAC3B,qBAAqB,GACrB,MAAM,WAAW,CAAC"}

package/dist/proxy/index.js

@@ -0,0 +1,7 @@
+import { UIBUNDLE_HEALTH_CHECK_PARAM, UIBUNDLE_PROXY_HEADER, createProxyHandler, injectLivePreviewScript } from "./handler.js";
+export {
+  UIBUNDLE_HEALTH_CHECK_PARAM,
+  UIBUNDLE_PROXY_HEADER,
+  createProxyHandler,
+  injectLivePreviewScript
+};

package/dist/proxy/livePreviewScript.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+/**
+ * Returns the JavaScript source that gets injected into previewed UI Bundles.
+ * Reads from templates/livePreviewScript.js at runtime (copied to dist/ by postbuild).
+ * Cached after first read.
+ *
+ * Responsibilities:
+ *  - Fetch interceptor for network-error detection (runs synchronously on load)
+ *  - Runtime / compile / HMR error listeners
+ *  - Error deduplication
+ *  - postMessage bridge to the VS Code webview (when running inside an iframe)
+ *  - Copy / paste / right-click bridge for VS Code webview
+ */
+export declare function getLivePreviewScriptContent(): string;
+/** Data attribute used to detect (and prevent) double injection. */
+export declare const LIVE_PREVIEW_SCRIPT_MARKER = "data-live-preview";
+//# sourceMappingURL=livePreviewScript.d.ts.map

package/dist/proxy/livePreviewScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"livePreviewScript.d.ts","sourceRoot":"","sources":["../../src/proxy/livePreviewScript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CAKpD;AAED,oEAAoE;AACpE,eAAO,MAAM,0BAA0B,sBAAsB,CAAC"}

package/dist/proxy/livePreviewScript.js

@@ -0,0 +1,16 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+let cached = null;
+function getLivePreviewScriptContent() {
+  if (cached) return cached;
+  const scriptPath = join(__dirname$1, "templates", "livePreviewScript.js");
+  cached = readFileSync(scriptPath, "utf-8");
+  return cached;
+}
+const LIVE_PREVIEW_SCRIPT_MARKER = "data-live-preview";
+export {
+  LIVE_PREVIEW_SCRIPT_MARKER,
+  getLivePreviewScriptContent
+};

package/dist/proxy/routing.d.ts

@@ -0,0 +1,35 @@
+import { RedirectRule, RewriteRule } from '../app/index';
+export interface RouteMatch {
+    type: "rewrite" | "redirect" | "api" | "gql" | "file-upload";
+    target?: string;
+    statusCode?: number;
+    params?: Record<string, string>;
+}
+/**
+ * Match URL path against routing rules
+ *
+ * @param pathname - The URL pathname to match
+ * @param basePath - Optional base path of Salesforce server
+ * @param rewrites - Optional array of rewrite rules
+ * @param redirects - Optional array of redirect rules
+ * @returns Route match result indicating the type and target, or null if no match
+ */
+export declare function matchRoute(pathname: string, basePath?: string, rewrites?: RewriteRule[], redirects?: RedirectRule[]): RouteMatch | null;
+/**
+ * Check if a path matches any of the given glob patterns
+ * Supports glob wildcards: * (matches anything except /), ** (matches anything including /), ? (single character)
+ *
+ * @param path - The path to test
+ * @param patterns - Array of glob patterns to match against
+ * @returns True if the path matches any pattern, false otherwise
+ */
+export declare function matchesPattern(path: string, patterns: string[] | undefined): boolean;
+/**
+ * Apply trailing slash rules to pathname
+ *
+ * @param pathname - The URL pathname
+ * @param trailingSlash - Trailing slash handling strategy
+ * @returns Modified pathname with trailing slash applied according to rules
+ */
+export declare function applyTrailingSlash(pathname: string, trailingSlash?: "always" | "never" | "auto"): string;
+//# sourceMappingURL=routing.d.ts.map

package/dist/proxy/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/proxy/routing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE9D,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,CAAC;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AASD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACzB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,WAAW,EAAE,EACxB,SAAS,CAAC,EAAE,YAAY,EAAE,GACxB,UAAU,GAAG,IAAI,CAqEnB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAMpF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GACzC,MAAM,CAiBR"}