bun-workspaces 1.9.0 → 1.11.0

package/src/workspaces/workspacePattern.mjs

@@ -12,95 +12,183 @@ const WORKSPACE_PATTERN_NEGATION_PREFIXES = [
   WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX,
 ];
 const WORKSPACE_PATTERN_SEPARATOR = ":";
+const WORKSPACE_PATTERN_REGEX_PREFIX = "re:";
+const validateRegexSource = (source, originalPattern) => {
+  try {
+    new RegExp(source);
+  } catch (cause) {
+    throw new WORKSPACE_PATTERN_ERRORS.InvalidWorkspacePattern(
+      `Invalid regex in workspace pattern "${originalPattern}": ${cause.message}`,
+    );
+  }
+};
 const parseWorkspacePattern = (pattern) => {
   const negationPrefix = WORKSPACE_PATTERN_NEGATION_PREFIXES.find((prefix) =>
     pattern.startsWith(prefix),
   );
   const isNegated = !!negationPrefix;
-  const patternValue = negationPrefix
+  const afterNegation = negationPrefix
     ? pattern.slice(negationPrefix.length)
     : pattern;
+  // The "@root" selector resolves to the project's root workspace. Recognized
+  // immediately after optional negation, so "not:@root" / "!@root" also work.
+  // A target-scoped value of "@root" (e.g. "name:@root") is treated as a literal,
+  // not a root selector.
+  if (afterNegation === /* inlined export .ROOT_WORKSPACE_SELECTOR */ "@root") {
+    return {
+      target: "default",
+      value: /* inlined export .ROOT_WORKSPACE_SELECTOR */ "@root",
+      isNegated,
+      isRegex: false,
+      isRootSelector: true,
+    };
+  }
+  // "re:" before any target consumes the rest as a regex against the default target.
+  // e.g. "re:path:foo" → default-target regex over literal source "path:foo".
+  if (afterNegation.startsWith(WORKSPACE_PATTERN_REGEX_PREFIX)) {
+    const value = afterNegation.slice(WORKSPACE_PATTERN_REGEX_PREFIX.length);
+    validateRegexSource(value, pattern);
+    return {
+      target: "default",
+      value,
+      isNegated,
+      isRegex: true,
+      isRootSelector: false,
+    };
+  }
   const target = TARGETS.find((target) =>
-    patternValue.startsWith(target + WORKSPACE_PATTERN_SEPARATOR),
+    afterNegation.startsWith(target + WORKSPACE_PATTERN_SEPARATOR),
   );
   if (!target) {
     return {
       target: "default",
-      value: patternValue,
+      value: afterNegation,
       isNegated,
+      isRegex: false,
+      isRootSelector: false,
     };
   }
-  const value = patternValue.slice(
+  const afterTarget = afterNegation.slice(
     target.length + WORKSPACE_PATTERN_SEPARATOR.length,
   );
+  if (afterTarget.startsWith(WORKSPACE_PATTERN_REGEX_PREFIX)) {
+    const value = afterTarget.slice(WORKSPACE_PATTERN_REGEX_PREFIX.length);
+    validateRegexSource(value, pattern);
+    return {
+      target,
+      value,
+      isNegated,
+      isRegex: true,
+      isRootSelector: false,
+    };
+  }
   return {
     target,
-    value,
+    value: afterTarget,
     isNegated,
+    isRegex: false,
+    isRootSelector: false,
   };
 };
-const stringifyWorkspacePattern = (pattern) => {
-  return `${pattern.target}${WORKSPACE_PATTERN_SEPARATOR}${pattern.value}`;
-};
 const PATTERN_TARGET_HANDLERS = {
-  default: (pattern, workspaces, wildcardRegex) => {
-    return workspaces.filter((workspace) => {
-      return (
-        (pattern.value.includes("*")
-          ? wildcardRegex.test(workspace.name)
-          : workspace.name === pattern.value) ||
-        workspace.aliases.some((alias) =>
-          pattern.value.includes("*")
-            ? wildcardRegex.test(alias)
-            : alias === pattern.value,
-        )
+  default: (pattern, workspaces) => {
+    // Plain string at the default target matches name OR alias. Wildcard and
+    // regex forms intentionally narrow to name only to avoid ambiguity — use
+    // an explicit "alias:" prefix to match aliases by wildcard/regex.
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) => regex.test(workspace.name));
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        wildcardRegex.test(workspace.name),
       );
-    });
+    }
+    return workspaces.filter(
+      (workspace) =>
+        workspace.name === pattern.value ||
+        workspace.aliases.includes(pattern.value),
+    );
   },
-  name: (pattern, workspaces, wildcardRegex) => {
-    return workspaces.filter((workspace) => {
-      return pattern.value.includes("*")
-        ? wildcardRegex.test(workspace.name)
-        : workspace.name === pattern.value;
-    });
+  name: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) => regex.test(workspace.name));
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        wildcardRegex.test(workspace.name),
+      );
+    }
+    return workspaces.filter((workspace) => workspace.name === pattern.value);
   },
-  alias: (pattern, workspaces, wildcardRegex) => {
-    return workspaces.filter((workspace) => {
-      return pattern.value.includes("*")
-        ? workspace.aliases.some((alias) => wildcardRegex.test(alias))
-        : workspace.aliases.includes(pattern.value);
-    });
+  alias: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.aliases.some((alias) => regex.test(alias)),
+      );
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.aliases.some((alias) => wildcardRegex.test(alias)),
+      );
+    }
+    return workspaces.filter((workspace) =>
+      workspace.aliases.includes(pattern.value),
+    );
   },
   path: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      // Normalize backslashes so regex sources stay portable: a single
+      // forward-slash-based regex works on both Windows and POSIX paths.
+      return workspaces.filter((workspace) =>
+        regex.test(workspace.path.replaceAll("\\", "/")),
+      );
+    }
     return workspaces.filter((workspace) =>
       new bun.Glob(pattern.value.replace(/\/+$/, "")).match(workspace.path),
     );
   },
-  tag: (pattern, workspaces, wildcardRegex) => {
+  tag: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.tags.some((tag) => regex.test(tag)),
+      );
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.tags.some((tag) => wildcardRegex.test(tag)),
+      );
+    }
     return workspaces.filter((workspace) =>
-      pattern.value.includes("*")
-        ? workspace.tags.some((tag) => wildcardRegex.test(tag))
-        : workspace.tags.includes(pattern.value),
+      workspace.tags.includes(pattern.value),
     );
   },
 };
-const matchWorkspacesByPattern = (pattern, workspaces) =>
-  PATTERN_TARGET_HANDLERS[pattern.target](
-    pattern,
-    workspaces,
-    createWildcardRegex(pattern.value),
-  );
-const matchWorkspacesByPatterns = (patterns, workspaces) => {
+const matchWorkspacesByPattern = (pattern, workspaces, rootWorkspace) => {
+  if (pattern.isRootSelector) {
+    return rootWorkspace ? [rootWorkspace] : [];
+  }
+  return PATTERN_TARGET_HANDLERS[pattern.target](pattern, workspaces);
+};
+const matchWorkspacesByPatterns = (patterns, workspaces, rootWorkspace) => {
   const parsedPatterns = patterns.map(parseWorkspacePattern);
   const excludePatterns = parsedPatterns.filter((pattern) => pattern.isNegated);
   const includePatterns = parsedPatterns.filter(
     (pattern) => !pattern.isNegated,
   );
   const excludeWorkspaces = excludePatterns.flatMap((pattern) =>
-    matchWorkspacesByPattern(pattern, workspaces),
+    matchWorkspacesByPattern(pattern, workspaces, rootWorkspace),
   );
   const includeWorkspaces = includePatterns.flatMap((pattern) =>
-    matchWorkspacesByPattern(pattern, workspaces),
+    matchWorkspacesByPattern(pattern, workspaces, rootWorkspace),
   );
   return includeWorkspaces.filter(
     (workspace, index, arr) =>
@@ -118,8 +206,8 @@ export {
   WORKSPACE_PATTERN_NEGATION_PREFIX,
   WORKSPACE_PATTERN_NEGATION_PREFIXES,
   WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX,
+  WORKSPACE_PATTERN_REGEX_PREFIX,
   WORKSPACE_PATTERN_SEPARATOR,
   matchWorkspacesByPatterns,
   parseWorkspacePattern,
-  stringifyWorkspacePattern,
 };