@vercel/microfrontends 0.12.1 → 0.14.0

package/dist/v2/next/testing.cjs

@@ -0,0 +1,992 @@
+"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);
+
+// src/next-v2/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  expandWildcards: () => expandWildcards,
+  getAllChildApplicationNames: () => getAllChildApplicationNames,
+  getAllMultiZonesPaths: () => getAllMultiZonesPaths,
+  getExpectedDomainForApp: () => getExpectedDomainForApp,
+  getFlaggedPathsForApp: () => getFlaggedPathsForApp,
+  getLaunchedPathsForApp: () => getLaunchedPathsForApp,
+  loadMicrofrontendConfigForEdge: () => loadMicrofrontendConfigForEdge,
+  validateMiddlewareConfig: () => validateMiddlewareConfig,
+  validateMiddlewareOnFlaggedPaths: () => validateMiddlewareOnFlaggedPaths
+});
+module.exports = __toCommonJS(testing_exports);
+var import_node_fs = require("fs");
+var import_server = require("next/server");
+var import_path_to_regexp3 = require("path-to-regexp");
+var import_jsonc_parser2 = require("jsonc-parser");
+var import_prepare_destination = require("next/dist/shared/lib/router/utils/prepare-destination");
+var import_adapter = require("next/dist/server/web/adapter");
+var import_web = require("next/dist/server/base-http/web");
+
+// src/config-v2/microfrontends-config/isomorphic/index.ts
+var import_jsonc_parser = require("jsonc-parser");
+
+// src/config-v2/errors.ts
+var MicrofrontendError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "MicrofrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/microfrontends";
+    this.type = (opts == null ? void 0 : opts.type) ?? "unknown";
+    this.subtype = opts == null ? void 0 : opts.subtype;
+    Error.captureStackTrace(this, MicrofrontendError);
+  }
+  isKnown() {
+    return this.type !== "unknown";
+  }
+  isUnknown() {
+    return !this.isKnown();
+  }
+  /**
+   * Converts an error to a MicrofrontendsError.
+   * @param original - The original error to convert.
+   * @returns The converted MicrofrontendsError.
+   */
+  static convert(original, opts) {
+    if (opts == null ? void 0 : opts.fileName) {
+      const err = MicrofrontendError.convertFSError(original, opts.fileName);
+      if (err) {
+        return err;
+      }
+    }
+    if (original.message.includes(
+      "Code generation from strings disallowed for this context"
+    )) {
+      return new MicrofrontendError(original.message, {
+        type: "config",
+        subtype: "unsupported_validation_env",
+        source: "ajv"
+      });
+    }
+    return new MicrofrontendError(original.message);
+  }
+  static convertFSError(original, fileName) {
+    if (original instanceof Error && "code" in original) {
+      if (original.code === "ENOENT") {
+        return new MicrofrontendError(`Could not find "${fileName}"`, {
+          type: "config",
+          subtype: "unable_to_read_file",
+          source: "fs"
+        });
+      }
+      if (original.code === "EACCES") {
+        return new MicrofrontendError(
+          `Permission denied while accessing "${fileName}"`,
+          {
+            type: "config",
+            subtype: "invalid_permissions",
+            source: "fs"
+          }
+        );
+      }
+    }
+    if (original instanceof SyntaxError) {
+      return new MicrofrontendError(
+        `Failed to parse "${fileName}": Invalid JSON format.`,
+        {
+          type: "config",
+          subtype: "invalid_syntax",
+          source: "fs"
+        }
+      );
+    }
+    return null;
+  }
+  /**
+   * Handles an unknown error and returns a MicrofrontendsError instance.
+   * @param err - The error to handle.
+   * @returns A MicrofrontendsError instance.
+   */
+  static handle(err, opts) {
+    if (err instanceof MicrofrontendError) {
+      return err;
+    }
+    if (err instanceof Error) {
+      return MicrofrontendError.convert(err, opts);
+    }
+    if (typeof err === "object" && err !== null) {
+      if ("message" in err && typeof err.message === "string") {
+        return MicrofrontendError.convert(new Error(err.message), opts);
+      }
+    }
+    return new MicrofrontendError("An unknown error occurred");
+  }
+};
+
+// src/config-v2/microfrontends-config/utils/get-config-from-env.ts
+function getConfigStringFromEnv() {
+  const config = process.env.MFE_CONFIG;
+  if (!config) {
+    throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
+      type: "config",
+      subtype: "not_found_in_env"
+    });
+  }
+  return config;
+}
+
+// src/config-v2/schema/utils/is-main-config.ts
+function isMainConfig(c) {
+  return !("partOf" in c);
+}
+
+// src/config-v2/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
+}
+
+// src/config-v2/microfrontends-config/client/index.ts
+var import_path_to_regexp = require("path-to-regexp");
+var MicrofrontendConfigClient = class {
+  constructor(config, opts) {
+    this.pathCache = {};
+    this.serialized = config;
+    if (opts == null ? void 0 : opts.removeFlaggedPaths) {
+      for (const app of Object.values(config.applications)) {
+        if (app.routing) {
+          app.routing = app.routing.filter((match2) => !match2.flag);
+        }
+      }
+    }
+    this.applications = config.applications;
+  }
+  /**
+   * Create a new `MicrofrontendConfigClient` from a JSON string.
+   * Config must be passed in to remain framework agnostic
+   */
+  static fromEnv(config, opts) {
+    if (!config) {
+      throw new Error("No microfrontends configuration found");
+    }
+    return new MicrofrontendConfigClient(
+      JSON.parse(config),
+      opts
+    );
+  }
+  isEqual(other) {
+    return JSON.stringify(this.applications) === JSON.stringify(other.applications);
+  }
+  getApplicationNameForPath(path) {
+    if (!path.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path]) {
+      return this.pathCache[path];
+    }
+    const pathname = new URL(path, "https://example.com").pathname;
+    for (const [name, application] of Object.entries(this.applications)) {
+      if (application.routing) {
+        for (const group of application.routing) {
+          for (const childPath of group.paths) {
+            const regexp = (0, import_path_to_regexp.pathToRegexp)(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path] = name;
+              return name;
+            }
+          }
+        }
+      }
+    }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config-v2/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+
+// src/config-v2/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  var _a;
+  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+}
+
+// src/config-v2/overrides/get-override-from-cookie.ts
+function getOverrideFromCookie(cookie) {
+  if (!isOverrideCookie(cookie) || !cookie.value)
+    return;
+  return {
+    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
+    host: cookie.value
+  };
+}
+
+// src/config-v2/overrides/parse-overrides.ts
+function parseOverrides(cookies) {
+  const overridesConfig = { applications: {} };
+  cookies.forEach((cookie) => {
+    const override = getOverrideFromCookie(cookie);
+    if (!override)
+      return;
+    overridesConfig.applications[override.application] = {
+      environment: { host: override.host }
+    };
+  });
+  return overridesConfig;
+}
+
+// src/config-v2/microfrontends-config/isomorphic/validation.ts
+var import_path_to_regexp2 = require("path-to-regexp");
+var SUPPORTED_VERSIONS = ["2"];
+var validateConfigVersion = (version) => {
+  if (!SUPPORTED_VERSIONS.includes(version)) {
+    throw new MicrofrontendError(
+      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
+        ", "
+      )}`,
+      { type: "config", subtype: "unsupported_version" }
+    );
+  }
+};
+var validateConfigPaths = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
+  }
+  const pathsByApplicationId = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [id, app] of Object.entries(applicationConfigsById)) {
+    if (isDefaultApp(app)) {
+      continue;
+    }
+    for (const pathMatch of app.routing) {
+      for (const path of pathMatch.paths) {
+        const tokens = (0, import_path_to_regexp2.parse)(path);
+        for (const token of tokens.slice(0, -1)) {
+          if (typeof token !== "string") {
+            errors.push(
+              `Path ${path} may only have a :wildcard in the last path component`
+            );
+          }
+        }
+        const existing = pathsByApplicationId.get(path);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path, {
+            applications: [id],
+            matcher: (0, import_path_to_regexp2.pathToRegexp)(path),
+            applicationId: id
+          });
+        }
+      }
+    }
+  }
+  const entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
+          errors.push(
+            `Overlapping path detected between ${source} and ${destination}`
+          );
+        }
+      }
+    );
+  });
+  if (errors.length) {
+    throw new MicrofrontendError(`Invalid paths: ${errors.join(", ")}`, {
+      type: "config",
+      subtype: "conflicting_paths"
+    });
+  }
+};
+var validateAppPaths = (name, app) => {
+  for (const group of app.routing) {
+    for (const p of group.paths) {
+      if (p === "/") {
+        continue;
+      }
+      if (p.endsWith("/")) {
+        throw new MicrofrontendError(
+          `Invalid path for application "${name}". ${p} must not end with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+      if (!p.startsWith("/")) {
+        throw new MicrofrontendError(
+          `Invalid path for application "${name}". ${p} must start with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+    }
+  }
+};
+var validateConfigDefaultApplication = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
+  }
+  const applicationsWithRouting = Object.entries(applicationConfigsById).filter(
+    ([, app]) => !isDefaultApp(app)
+  );
+  const applicationsWithRoutingNames = applicationsWithRouting.map(
+    ([key]) => key
+  );
+  const numApplications = Object.keys(applicationConfigsById).length;
+  const numApplicationsWithRouting = applicationsWithRoutingNames.length;
+  const numApplicationsWithoutRouting = numApplications - numApplicationsWithRouting;
+  if (numApplicationsWithoutRouting === 0) {
+    throw new MicrofrontendError(
+      `No default application found. At least one application needs to be the default by omitting routing.`,
+      { type: "config", subtype: "no_default_application" }
+    );
+  }
+  if (numApplicationsWithoutRouting > 1) {
+    throw new MicrofrontendError(
+      `Only one application can omit "routing". Found ${applicationsWithRoutingNames.length - Object.keys(applicationConfigsById).length > 1}.`,
+      { type: "config", subtype: "multiple_default_applications" }
+    );
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
+var PREFIX = "vc-ap";
+function generateAssetPrefixFromName({
+  name
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate an asset prefix");
+  }
+  return `${PREFIX}-${name}`;
+}
+
+// src/config-v2/microfrontends-config/isomorphic/utils/generate-port.ts
+function generatePortFromName({
+  name,
+  minPort = 3e3,
+  maxPort = 8e3
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate a port");
+  }
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = (hash << 5) - hash + name.charCodeAt(i);
+    hash |= 0;
+  }
+  hash = Math.abs(hash);
+  const range = maxPort - minPort;
+  const port = minPort + hash % range;
+  return port;
+}
+
+// src/config-v2/microfrontends-config/isomorphic/host.ts
+var Host = class {
+  constructor(hostConfig, options) {
+    const { protocol = "https", host, port } = hostConfig;
+    this.protocol = protocol;
+    this.host = host;
+    this.port = Host.getPort({ port, protocol: this.protocol });
+    this.local = options == null ? void 0 : options.isLocal;
+  }
+  isLocal() {
+    return this.local || this.host === "localhost" || this.host === "127.0.0.1";
+  }
+  static getPort({
+    protocol,
+    port
+  }) {
+    if (!port) {
+      if (protocol === "http") {
+        return 80;
+      }
+      return 443;
+    }
+    return port;
+  }
+  isDefaultPort() {
+    return this.port === Host.getPort({ protocol: this.protocol });
+  }
+  toString(opts = {}) {
+    const url = this.toUrl(opts);
+    return url.toString().replace(/\/$/, "");
+  }
+  toUrl(opts = {}) {
+    const { includeDefaultPort } = opts;
+    const url = `${this.protocol}://${this.host}${this.isDefaultPort() && !includeDefaultPort ? "" : `:${this.port}`}`;
+    return new URL(url);
+  }
+};
+var LocalHost = class extends Host {
+  constructor({
+    appName,
+    ...hostConfig
+  }) {
+    const host = hostConfig.host ?? "localhost";
+    const port = hostConfig.port ?? generatePortFromName({ name: appName });
+    const protocol = hostConfig.protocol ?? "http";
+    super({ protocol, host, port });
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/application.ts
+var Application = class {
+  constructor(name, {
+    app,
+    overrides,
+    isDefault
+  }) {
+    var _a, _b;
+    this.name = name;
+    this.development = {
+      local: new LocalHost({
+        appName: name,
+        ...(_a = app.development) == null ? void 0 : _a.local
+      }),
+      fallback: ((_b = app.development) == null ? void 0 : _b.fallback) ? new Host(app.development.fallback) : void 0
+    };
+    this.production = app.production ? new Host(app.production) : void 0;
+    this.vercel = app.vercel;
+    this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
+      environment: new Host(overrides.environment)
+    } : void 0;
+    this.default = isDefault ?? false;
+    this.serialized = app;
+  }
+  isDefault() {
+    return this.default;
+  }
+  getAssetPrefix() {
+    return generateAssetPrefixFromName({ name: this.name });
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+var DefaultApplication = class extends Application {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    super(name, {
+      app,
+      overrides,
+      isDefault: true
+    });
+    this.default = true;
+    this.production = new Host(app.production);
+  }
+  getAssetPrefix() {
+    return "";
+  }
+};
+var ChildApplication = class extends Application {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    ChildApplication.validate(name, app);
+    super(name, {
+      app,
+      overrides,
+      isDefault: false
+    });
+    this.default = false;
+    this.routing = app.routing;
+  }
+  static validate(name, app) {
+    validateAppPaths(name, app);
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/constants.ts
+var DEFAULT_LOCAL_PROXY_PORT = 3024;
+
+// src/config-v2/microfrontends-config/isomorphic/index.ts
+var MicrofrontendConfigIsomorphic = class {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    this.childApplications = {};
+    var _a, _b, _c, _d;
+    MicrofrontendConfigIsomorphic.validate(config);
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+    this.overrides = overrides && !disableOverrides ? overrides : void 0;
+    this.isMainConfig = isMainConfig(config);
+    if (isMainConfig(config)) {
+      for (const [appId, appConfig] of Object.entries(config.applications)) {
+        const appOverrides = !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.applications[appId] : void 0;
+        if (isDefaultApp(appConfig)) {
+          this.defaultApplication = new DefaultApplication(appId, {
+            app: appConfig,
+            overrides: appOverrides
+          });
+        } else {
+          this.childApplications[appId] = new ChildApplication(appId, {
+            app: appConfig,
+            overrides: appOverrides
+          });
+        }
+      }
+    } else {
+      this.partOf = config.partOf;
+      const appOverrides = !disableOverrides ? (_d = this.overrides) == null ? void 0 : _d.applications[meta.fromApp] : void 0;
+      this.childApplications[meta.fromApp] = new ChildApplication(
+        meta.fromApp,
+        {
+          // we don't know routing because we're not in the main config
+          app: { routing: [] },
+          overrides: appOverrides
+        }
+      );
+    }
+    if (isMainConfig(config) && !this.defaultApplication) {
+      throw new MicrofrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.config = config;
+    this.options = config.options;
+    this.serialized = {
+      config,
+      overrides,
+      meta
+    };
+  }
+  static validate(config) {
+    const c = typeof config === "string" ? (0, import_jsonc_parser.parse)(config) : config;
+    if (isMainConfig(c)) {
+      validateConfigVersion(c.version);
+      validateConfigPaths(c.applications);
+      validateConfigDefaultApplication(c.applications);
+    }
+    return c;
+  }
+  static fromEnv({
+    meta,
+    cookies
+  }) {
+    return new MicrofrontendConfigIsomorphic({
+      config: (0, import_jsonc_parser.parse)(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies ?? []),
+      meta
+    });
+  }
+  isOverridesDisabled() {
+    var _a, _b;
+    return ((_b = (_a = this.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getApplicationsByType() {
+    return {
+      defaultApplication: this.defaultApplication,
+      applications: Object.values(this.childApplications)
+    };
+  }
+  getChildApplications() {
+    return Object.values(this.childApplications);
+  }
+  getAllApplications() {
+    return [
+      this.defaultApplication,
+      ...Object.values(this.childApplications)
+    ].filter(Boolean);
+  }
+  getApplication(name) {
+    var _a;
+    if (((_a = this.defaultApplication) == null ? void 0 : _a.name) === name) {
+      return this.defaultApplication;
+    }
+    const app = this.childApplications[name];
+    if (!app) {
+      throw new MicrofrontendError(
+        `Could not find microfrontends configuration for application "${name}"`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    return app;
+  }
+  getApplicationByProjectId(projectId) {
+    var _a, _b;
+    if (((_b = (_a = this.defaultApplication) == null ? void 0 : _a.vercel) == null ? void 0 : _b.projectId) === projectId) {
+      return this.defaultApplication;
+    }
+    return Object.values(this.childApplications).find(
+      (app) => {
+        var _a2;
+        return ((_a2 = app.vercel) == null ? void 0 : _a2.projectId) === projectId;
+      }
+    );
+  }
+  /**
+   * Returns the default application. This can throw if the default application
+   * is undefined ( )
+   */
+  getDefaultApplication() {
+    if (!this.defaultApplication) {
+      throw new MicrofrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    return this.defaultApplication;
+  }
+  /**
+   * Returns the configured port for the local proxy
+   */
+  getLocalProxyPort() {
+    var _a, _b;
+    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_PORT;
+  }
+  /**
+   * Serializes the class back to the Schema type.
+   *
+   * NOTE: This is used when writing the config to disk and must always match the input Schema
+   */
+  toSchemaJson() {
+    return this.serialized.config;
+  }
+  toClientConfig() {
+    const applications = Object.fromEntries(
+      Object.entries(this.childApplications).map(([name, application]) => [
+        name,
+        {
+          default: false,
+          routing: application.routing
+        }
+      ])
+    );
+    if (this.defaultApplication) {
+      applications[this.defaultApplication.name] = {
+        default: true
+      };
+    }
+    return new MicrofrontendConfigClient({
+      applications
+    });
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/routing-v2/get-domain-from-environment.ts
+function getDomainFromEnvironment({
+  app,
+  target
+}) {
+  var _a;
+  const mfeProjects = JSON.parse(
+    process.env.VERCEL_MICROFRONTENDS_PROJECTS ?? "[]"
+  );
+  if (mfeProjects.length === 0) {
+    throw new Error("Missing related microfrontends project information");
+  }
+  if (!((_a = app.vercel) == null ? void 0 : _a.projectId)) {
+    throw new Error(`Missing applications[${app.name}].vercel.projectId`);
+  }
+  const vercelProject = mfeProjects.find(
+    (p) => {
+      var _a2;
+      return p.project.id === ((_a2 = app.vercel) == null ? void 0 : _a2.projectId);
+    }
+  );
+  if (!vercelProject) {
+    throw new Error(
+      `Missing related microfrontends project information for application "${app.name}"`
+    );
+  }
+  const domain = target === "preview" && vercelProject.preview.branch ? vercelProject.preview.branch : vercelProject.production.alias ?? vercelProject.production.url;
+  if (!domain) {
+    throw new Error(
+      `Missing domain for target "${target}" in application "${app.name}"`
+    );
+  }
+  return domain.startsWith("https://") ? domain : `https://${domain}`;
+}
+
+// src/next-v2/testing/index.ts
+function expandWildcards(path) {
+  if (path.includes("/:path*") || path.includes("/:slug*")) {
+    return [
+      path === "/:path*" || path === "/:slug*" ? "/" : path.replace("/:path*", "").replace("/:slug*", ""),
+      path.replace("/:path*", "/foo").replace("/:slug*", "/foo"),
+      path.replace("/:path*", "/foo/bar").replace("/:slug*", "/foo/bar")
+    ];
+  }
+  if (path.includes("/:path+") || path.includes("/:slug+")) {
+    return [
+      path.replace("/:path+", "/foo").replace("/:slug+", "/foo"),
+      path.replace("/:path+", "/foo/bar").replace("/:slug+", "/foo/bar")
+    ];
+  }
+  if (path.includes("/:path") || path.includes("/:slug")) {
+    return [path.replace("/:path", "/foo").replace("/:slug", "/foo")];
+  }
+  return [path];
+}
+function loadMicrofrontendConfigForEdge(path) {
+  const rawMfConfig = (0, import_jsonc_parser2.parse)((0, import_node_fs.readFileSync)(path, "utf-8"));
+  return new MicrofrontendConfigIsomorphic({
+    config: rawMfConfig,
+    meta: { fromApp: "test" }
+  });
+}
+function getAllChildApplicationNames(mfConfig) {
+  return mfConfig.getChildApplications().map((app) => app.name);
+}
+function getLaunchedPathsForApp(mfConfig, appName) {
+  const app = mfConfig.getApplication(appName);
+  if (app instanceof DefaultApplication) {
+    return [];
+  }
+  return [
+    `/${app.getAssetPrefix()}/_next/static`,
+    ...app.routing.filter((group) => !group.flag).flatMap((group) => group.paths.flatMap(expandWildcards))
+  ];
+}
+function getFlaggedPathsForApp(mfConfig, appName) {
+  const app = mfConfig.getApplication(appName);
+  if (app instanceof DefaultApplication) {
+    return [];
+  }
+  return app.routing.filter((group) => Boolean(group.flag)).flatMap((group) => group.paths.flatMap(expandWildcards));
+}
+function getExpectedDomainForApp(mfConfig, appName, env) {
+  const app = mfConfig.getApplication(appName);
+  const defaultApp = mfConfig.getDefaultApplication();
+  if (env === "development") {
+    return app.development.local.toString();
+  }
+  if (["preview", "production"].includes(env)) {
+    const target = env;
+    return getDomainFromEnvironment({ app, target });
+  }
+  return defaultApp.production.toString();
+}
+function getAllMultiZonesPaths(mfConfig) {
+  return mfConfig.getChildApplications().flatMap((app) => {
+    return app.routing.flatMap((group) => group.paths.flatMap(expandWildcards));
+  });
+}
+function urlMatches(middlewareConfig, path, host) {
+  if (!middlewareConfig.matcher) {
+    return false;
+  }
+  const matchers = Array.isArray(middlewareConfig.matcher) ? middlewareConfig.matcher : [middlewareConfig.matcher];
+  for (let matcher of matchers) {
+    matcher = typeof matcher === "string" ? { source: matcher } : matcher;
+    if ((0, import_path_to_regexp3.match)(matcher.source)(path)) {
+      if ((0, import_prepare_destination.matchHas)(
+        new import_web.WebNextRequest(
+          new import_adapter.NextRequestHint({
+            init: { headers: { host } },
+            input: `https://${host}${path}`,
+            page: "unused_placeholder"
+          })
+        ),
+        {},
+        matcher.has,
+        matcher.missing
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function validateMiddlewareConfig(middlewareConfig, microfrontendConfigOrPath, extraProductionMatches) {
+  const microfrontendConfig = typeof microfrontendConfigOrPath === "string" ? loadMicrofrontendConfigForEdge(microfrontendConfigOrPath) : microfrontendConfigOrPath;
+  const errors = [];
+  const usedExtraProductionMatches = /* @__PURE__ */ new Set();
+  for (const application of microfrontendConfig.getChildApplications()) {
+    const matches = [...application.routing];
+    matches.push({
+      paths: [`/${application.getAssetPrefix()}/_next/:path+`]
+    });
+    for (const aMatch of matches) {
+      const isFlagged = Boolean(aMatch.flag);
+      for (const path of aMatch.paths) {
+        const pathsToTest = expandWildcards(path);
+        for (const testPath of pathsToTest) {
+          const productionHost = microfrontendConfig.getDefaultApplication().production.host;
+          const pathForDisplay = `${testPath}${path === testPath ? "" : ` (synthesized from ${path})`}`;
+          if (!urlMatches(middlewareConfig, testPath, "test.nonproduction.host")) {
+            errors.push(
+              `Matcher misconfigured for ${pathForDisplay}. This path should have matched the middleware config on a non-production host, but did not. Microfrontends require a middleware config matcher that matches on this host everywhere but in production. That can be configured with a configuration like this:
+${getSampleMatcher(path, productionHost)}`
+            );
+            break;
+          }
+          const productionUrlMatches = urlMatches(
+            middlewareConfig,
+            testPath,
+            productionHost
+          );
+          if (isFlagged) {
+            if (!productionUrlMatches) {
+              errors.push(
+                `Matcher misconfigured for ${pathForDisplay}. Middleware config matchers for flagged paths should ALWAYS match.`
+              );
+              break;
+            }
+          } else if (productionUrlMatches) {
+            if (extraProductionMatches == null ? void 0 : extraProductionMatches.includes(path)) {
+              usedExtraProductionMatches.add(path);
+            } else {
+              errors.push(
+                `Matcher misconfigured for ${pathForDisplay}. This path matched the middleware config on a production host, but should not have. Microfrontends require a middleware config matcher that matches on this host everywhere but in production. If this is desired, you can add the path the to extraProductionMatches parameter. Otherwise, you can set up a configuration like this:
+${getSampleMatcher(path, productionHost)}`
+              );
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  const unusedExtraProductionMatches = extraProductionMatches == null ? void 0 : extraProductionMatches.filter(
+    (x) => !usedExtraProductionMatches.has(x)
+  );
+  if (unusedExtraProductionMatches == null ? void 0 : unusedExtraProductionMatches.length) {
+    errors.push(
+      `The following paths were passed to the extraProductionMatches parameter but were unused. You probably want to remove them from the extraProductionMatches parameter: ${unusedExtraProductionMatches.join(", ")}`
+    );
+  }
+  if (errors.length > 0) {
+    const message = `Found the following inconsistencies between your microfrontend config ${typeof microfrontendConfigOrPath === "string" ? `(at ${microfrontendConfigOrPath}) ` : ""}and middleware config:
+
+- `;
+    throw new Error(message + errors.join("\n\n- "));
+  }
+}
+function getSampleMatcher(path, host) {
+  return `  {
+    source: '${path}', // This can also be a broader regular expression.
+    missing: [
+      type: 'header',
+      key: 'host',
+      value '${host}',
+    ],
+  }`;
+}
+async function validateMiddlewareOnFlaggedPaths(microfrontendConfigOrPath, middleware) {
+  const initialEnv = process.env.VERCEL_ENV;
+  const initialMfePreviewDomains = process.env.MFE_PREVIEW_DOMAINS;
+  try {
+    const microfrontendConfig = typeof microfrontendConfigOrPath === "string" ? loadMicrofrontendConfigForEdge(microfrontendConfigOrPath) : microfrontendConfigOrPath;
+    const allAppNames = getAllChildApplicationNames(microfrontendConfig);
+    const errors = [];
+    for (const appName of allAppNames) {
+      const flaggedPaths = getFlaggedPathsForApp(microfrontendConfig, appName);
+      if (flaggedPaths.length) {
+        for (const env of ["preview", "production"]) {
+          process.env.VERCEL_ENV = env;
+          for (const path of flaggedPaths) {
+            const expectedHost = getExpectedDomainForApp(
+              microfrontendConfig,
+              appName,
+              env
+            );
+            const expectedDefaultHost = getExpectedDomainForApp(
+              microfrontendConfig,
+              microfrontendConfig.getDefaultApplication().name,
+              env
+            );
+            const requestPath = `${expectedDefaultHost}${path}`;
+            const request = new import_server.NextRequest(requestPath, {
+              headers: { "x-vercel-skip-deployment-existence-check": "1" }
+            });
+            const response = await middleware(
+              request,
+              {}
+            );
+            const expectedUrl = `${expectedHost}${path}`;
+            if (!response) {
+              errors.push(
+                `middleware did not action for ${requestPath} in ${env}. Expected a rewrite to ${expectedUrl}`
+              );
+            } else if (response.status !== 200) {
+              errors.push(
+                `expected 200 status for ${requestPath} in ${env} but got ${response.status}`
+              );
+            } else if (response.headers.get("x-middleware-rewrite") !== expectedUrl) {
+              errors.push(
+                `expected rewrite from ${requestPath} to ${expectedUrl} in ${env}, but got ${response.headers.get("x-middleware-rewrite")}`
+              );
+            }
+          }
+        }
+      }
+    }
+    if (errors.length) {
+      throw new Error(errors.join("\n"));
+    }
+  } finally {
+    process.env.VERCEL_ENV = initialEnv;
+    process.env.MFE_PREVIEW_DOMAINS = initialMfePreviewDomains;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandWildcards,
+  getAllChildApplicationNames,
+  getAllMultiZonesPaths,
+  getExpectedDomainForApp,
+  getFlaggedPathsForApp,
+  getLaunchedPathsForApp,
+  loadMicrofrontendConfigForEdge,
+  validateMiddlewareConfig,
+  validateMiddlewareOnFlaggedPaths
+});
+//# sourceMappingURL=testing.cjs.map