@vercel/microfrontends 1.0.1-canary.3 → 1.0.1-canary.4

package/dist/experimental/sveltekit.cjs

@@ -44,8 +44,8 @@ function displayLocalProxyInfo(port) {
 }
 
 // src/config/microfrontends/server/index.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path8 = require("path");
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path9 = require("path");
 
 // src/config/overrides/constants.ts
 var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
@@ -228,21 +228,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path5) {
-    if (!path5.startsWith("/")) {
+  getApplicationNameForPath(path6) {
+    if (!path6.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path5]) {
-      return this.pathCache[path5];
+    if (this.pathCache[path6]) {
+      return this.pathCache[path6];
     }
-    const pathname = new URL(path5, "https://example.com").pathname;
+    const pathname = new URL(path6, "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[path5] = name;
+              this.pathCache[path6] = name;
               return name;
             }
           }
@@ -255,7 +255,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path5] = defaultApplication[0];
+    this.pathCache[path6] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -277,18 +277,18 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
     const childApp = app;
     for (const pathMatch of childApp.routing) {
-      for (const path5 of pathMatch.paths) {
-        const maybeError = validatePathExpression(path5);
+      for (const path6 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path6);
         if (maybeError) {
           errors.push(maybeError);
         } else {
-          const existing = pathsByApplicationId.get(path5);
+          const existing = pathsByApplicationId.get(path6);
           if (existing) {
             existing.applications.push(id);
           } else {
-            pathsByApplicationId.set(path5, {
+            pathsByApplicationId.set(path6, {
               applications: [id],
-              matcher: (0, import_path_to_regexp2.pathToRegexp)(path5),
+              matcher: (0, import_path_to_regexp2.pathToRegexp)(path6),
               applicationId: id
             });
           }
@@ -297,24 +297,24 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  for (const [path5, { applications: ids, matcher, applicationId }] of entries) {
+  for (const [path6, { applications: ids, matcher, applicationId }] of entries) {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path5}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path6}" for applications "${ids.join(", ")}"`
       );
     }
     for (const [
       matchPath,
       { applications: matchIds, applicationId: matchApplicationId }
     ] of entries) {
-      if (path5 === matchPath) {
+      if (path6 === matchPath) {
         continue;
       }
       if (applicationId === matchApplicationId) {
         continue;
       }
       if (matcher.test(matchPath)) {
-        const source = `"${path5}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+        const source = `"${path6}" 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}`
@@ -330,39 +330,42 @@ var validateConfigPaths = (applicationConfigsById) => {
   }
 };
 var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
-function validatePathExpression(path5) {
+function validatePathExpression(path6) {
   try {
-    const tokens = (0, import_path_to_regexp2.parse)(path5);
-    if (/(?<!\\)\{/.test(path5)) {
-      return `Optional paths are not supported: ${path5}`;
+    const tokens = (0, import_path_to_regexp2.parse)(path6);
+    if (/(?<!\\)\{/.test(path6)) {
+      return `Optional paths are not supported: ${path6}`;
     }
-    if (/(?<!\\|\()\?/.test(path5)) {
-      return `Optional paths are not supported: ${path5}`;
+    if (/(?<!\\|\()\?/.test(path6)) {
+      return `Optional paths are not supported: ${path6}`;
     }
-    if (/\/[^/]*(?<!\\):[^/]*(?<!\\):[^/]*/.test(path5)) {
-      return `Only one wildcard is allowed per path segment: ${path5}`;
+    if (/\/[^/]*(?<!\\):[^/]*(?<!\\):[^/]*/.test(path6)) {
+      return `Only one wildcard is allowed per path segment: ${path6}`;
     }
     for (let i = 0; i < tokens.length; i++) {
       const token = tokens[i];
       if (token === void 0) {
-        return `token ${i} in ${path5} is undefined, this shouldn't happen`;
+        return `token ${i} in ${path6} is undefined, this shouldn't happen`;
       }
       if (typeof token !== "string") {
+        if (!token.name) {
+          return `Only named wildcards are allowed: ${path6} (hint: add ":path" to the wildcard)`;
+        }
         if (token.pattern !== PATH_DEFAULT_PATTERN && // Allows (a|b|c) and ((?!a|b|c).*) regex
         // Only limited regex is supported for now, due to performance considerations
         !/^(?<allowed>[\w]+(?:\|[^|()]+)+)$|^\(\?!(?<disallowed>[\w]+(?:\|[^|()]+)+)\)\.\*$/.test(
           token.pattern
         )) {
-          return `Path ${path5} cannot use unsupported regular expression wildcard`;
+          return `Path ${path6} cannot use unsupported regular expression wildcard`;
         }
         if (token.modifier && i !== tokens.length - 1) {
-          return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path5}. Modifiers are only allowed in the last path component`;
+          return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path6}. Modifiers are only allowed in the last path component`;
         }
       }
     }
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
-    return `Path ${path5} could not be parsed into regexp: ${message}`;
+    return `Path ${path6} could not be parsed into regexp: ${message}`;
   }
   return void 0;
 }
@@ -1074,6 +1077,9 @@ function isMonorepo({
     if (import_node_fs4.default.existsSync(import_node_path4.default.join(repositoryRoot, "vlt-workspaces.json"))) {
       return true;
     }
+    if (process.env.NX_WORKSPACE_ROOT === import_node_path4.default.resolve(repositoryRoot)) {
+      return true;
+    }
     const packageJsonPath = import_node_path4.default.join(repositoryRoot, "package.json");
     if (!import_node_fs4.default.existsSync(packageJsonPath)) {
       return false;
@@ -1119,8 +1125,42 @@ function findConfig({ dir }) {
   return null;
 }
 
-// src/config/microfrontends/server/utils/get-output-file-path.ts
+// src/config/microfrontends/utils/get-application-context.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
+function getApplicationContext(opts) {
+  if (opts?.appName) {
+    return { name: opts.appName };
+  }
+  if (process.env.NX_TASK_TARGET_PROJECT) {
+    return { name: process.env.NX_TASK_TARGET_PROJECT };
+  }
+  try {
+    const packageJsonString = import_node_fs7.default.readFileSync(
+      import_node_path7.default.join(opts?.packageRoot || ".", "package.json"),
+      "utf-8"
+    );
+    const packageJson = JSON.parse(packageJsonString);
+    if (!packageJson.name) {
+      throw new MicrofrontendError(
+        `package.json file missing required field "name"`,
+        {
+          type: "packageJson",
+          subtype: "missing_field_name",
+          source: "@vercel/microfrontends/next"
+        }
+      );
+    }
+    return { name: packageJson.name };
+  } catch (err) {
+    throw MicrofrontendError.handle(err, {
+      fileName: "package.json"
+    });
+  }
+}
+
+// src/config/microfrontends/server/utils/get-output-file-path.ts
+var import_node_path8 = __toESM(require("path"), 1);
 
 // src/config/microfrontends/server/constants.ts
 var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
@@ -1128,7 +1168,7 @@ var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
 
 // src/config/microfrontends/server/utils/get-output-file-path.ts
 function getOutputFilePath() {
-  return import_node_path7.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+  return import_node_path8.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
 }
 
 // src/config/microfrontends/server/validation.ts
@@ -1467,8 +1507,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    import_node_fs7.default.mkdirSync((0, import_node_path8.dirname)(outputPath), { recursive: true });
-    import_node_fs7.default.writeFileSync(
+    import_node_fs8.default.mkdirSync((0, import_node_path9.dirname)(outputPath), { recursive: true });
+    import_node_fs8.default.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -1554,14 +1594,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     }
     try {
       const packageRoot = findPackageRoot(directory);
-      const packageJsonPath = (0, import_node_path8.join)(packageRoot, "package.json");
-      const packageJson = JSON.parse(
-        import_node_fs7.default.readFileSync(packageJsonPath, "utf-8")
-      );
-      if (!packageJson.name) {
-        throw new Error(`No name found in package.json at ${packageJsonPath}`);
-      }
-      const configMeta = meta ?? { fromApp: packageJson.name };
+      const { name: appName } = getApplicationContext({ packageRoot });
+      const configMeta = meta ?? { fromApp: appName };
       const maybeConfig = findConfig({ dir: packageRoot });
       if (maybeConfig) {
         return MicrofrontendsServer.fromFile({
@@ -1576,7 +1610,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       if (isMonorepo2) {
         const defaultPackage = findDefaultMicrofrontendsPackage({
           repositoryRoot,
-          applicationName: packageJson.name
+          applicationName: appName
         });
         const maybeConfigFromDefault = findConfig({ dir: defaultPackage });
         if (maybeConfigFromDefault) {
@@ -1606,7 +1640,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     options
   }) {
     try {
-      const configJson = import_node_fs7.default.readFileSync(filePath, "utf-8");
+      const configJson = import_node_fs8.default.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
       if (!isMainConfig(config) && options?.resolveMainConfig) {
         const repositoryRoot = findRepositoryRoot();
@@ -1654,7 +1688,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = import_node_fs7.default.readFileSync(filePath, "utf-8");
+      const config = import_node_fs8.default.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
         throw new MicrofrontendError(
@@ -1685,33 +1719,6 @@ var MicrofrontendsServer = class extends Microfrontends {
   }
 };
 
-// src/config/microfrontends/utils/get-application-context.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-function getApplicationContext(opts) {
-  if (opts?.appName) {
-    return { name: opts.appName };
-  }
-  try {
-    const packageJsonString = import_node_fs8.default.readFileSync("./package.json", "utf-8");
-    const packageJson = JSON.parse(packageJsonString);
-    if (!packageJson.name) {
-      throw new MicrofrontendError(
-        `package.json file missing required field "name"`,
-        {
-          type: "packageJson",
-          subtype: "missing_field_name",
-          source: "@vercel/microfrontends/next"
-        }
-      );
-    }
-    return { name: packageJson.name };
-  } catch (err) {
-    throw MicrofrontendError.handle(err, {
-      fileName: "package.json"
-    });
-  }
-}
-
 // src/sveltekit/config/index.ts
 function withMicrofrontends(config, opts) {
   const { name: fromApp } = getApplicationContext(opts);