barrelize 1.4.2 → 1.5.0

package/README.md

@@ -17,10 +17,10 @@ Barrelize simplifies module exports by creating clean, centralized `index.js` or
 - **Recursive**: Optionally generate barrels for nested directories.
 - **CLI & API**: Use via command line for quick setups or integrate programmatically in your build scripts.
 - **Smart Export Control**: Fine-grained control over what gets exported and how:
-  - Include/exclude specific members using string or regex patterns
-  - Map member names to custom export names
-  - Automatic type-only exports detection
-  - Support for asterisk (\*) exports when appropriate
+  - Export specific members, namespaces, or use regex patterns
+  - Support for custom export names and transformations
+  - Support for asterisk (\*) exports
+  - Flexible export path manipulation
 - **Flexible Path Handling**: Replace patterns in export paths using string or regular expressions
 - **Customizable Formatting**: Control bracket spacing, quotes, semicolons, and newlines
 
@@ -108,24 +108,12 @@ Create a `.barrelize` file in your project root. The configuration file uses JSO
       },
       // Export configuration for different file patterns
       "exports": {
-        "**/*.ts": {
-          // Include specific members using string or regex patterns (default: [])
-          "includeMembers": ["MyClass", "/^.*Service$/"],
-          // Exclude specific members using string or regex patterns (default: [])
-          "excludeMembers": ["internal", "/^_.*$/"],
-          // Map member patterns to export names
-          "map": {
-            "/^.+Util$/": "util",
-            "default": "lib",
-            "*": "services"
-          },
-          // Skip mapping members if they don't exist in source (default: true)
-          "skipMapMembersIfNotExists": true,
-          // Use * export when all members are exported (default: true)
-          "asteriskIfAllExported": true,
-          // Add 'type' prefix for type-only exports (default: true)
-          "typePrefixIfPossible": true
-        }
+        // Glob pattern exports file with string or regular expression patterns
+        "**/*.ts": [
+          "* as lib", // Export all as namespace
+          "/(.+)Config$/ as $1LibConfig", // Rename exports matching pattern
+          "util" // Export specific member
+        ]
       },
       // Override global formatting settings per barrel
       "bracketSpacing": true,

package/lib/index.js

@@ -591,7 +591,7 @@ class CAC extends EventEmitter {
 }
 const cac = (name2 = "") => new CAC(name2);
 const name = "barrelize";
-const version = "1.4.1";
+const version = "1.4.2";
 function cliInit() {
   const cli = cac(name);
   cli.command("[config path]", `Generate barrel files`).action(async (config) => {
@@ -999,21 +999,7 @@ const validateConfig = (() => {
     const value = input[key2];
     if (void 0 === value)
       return true;
-    return "object" === typeof value && null !== value && false === Array.isArray(value) && _io4(value, _exceptionable);
-  });
-  const _io4 = (input, _exceptionable = true) => (void 0 === input.includeMembers || Array.isArray(input.includeMembers) && input.includeMembers.every((elem, _index5) => "string" === typeof elem)) && (void 0 === input.excludeMembers || Array.isArray(input.excludeMembers) && input.excludeMembers.every((elem, _index6) => "string" === typeof elem)) && (void 0 === input.map || "object" === typeof input.map && null !== input.map && false === Array.isArray(input.map) && _io5(input.map, _exceptionable)) && (void 0 === input.skipMapMembersIfNotExists || "boolean" === typeof input.skipMapMembersIfNotExists) && (void 0 === input.asteriskIfAllExported || "boolean" === typeof input.asteriskIfAllExported) && (void 0 === input.typePrefixIfPossible || "boolean" === typeof input.typePrefixIfPossible) && (0 === Object.keys(input).length || Object.keys(input).every((key2) => {
-    if (["includeMembers", "excludeMembers", "map", "skipMapMembersIfNotExists", "asteriskIfAllExported", "typePrefixIfPossible"].some((prop) => key2 === prop))
-      return true;
-    const value = input[key2];
-    if (void 0 === value)
-      return true;
-    return false;
-  }));
-  const _io5 = (input, _exceptionable = true) => Object.keys(input).every((key2) => {
-    const value = input[key2];
-    if (void 0 === value)
-      return true;
-    return "string" === typeof value;
+    return Array.isArray(value) && value.every((elem, _index5) => "string" === typeof elem);
   });
   const _vo0 = (input, _path, _exceptionable = true) => [void 0 === input.$schema || "string" === typeof input.$schema || _report(_exceptionable, {
     path: _path + ".$schema",
@@ -1039,12 +1025,12 @@ const validateConfig = (() => {
     path: _path + ".barrels",
     expected: "Array<BarrelConfig>",
     value: input.barrels
-  })) && input.barrels.map((elem, _index7) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
-    path: _path + ".barrels[" + _index7 + "]",
+  })) && input.barrels.map((elem, _index6) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
+    path: _path + ".barrels[" + _index6 + "]",
     expected: "BarrelConfig",
     value: elem
-  })) && _vo1(elem, _path + ".barrels[" + _index7 + "]", _exceptionable) || _report(_exceptionable, {
-    path: _path + ".barrels[" + _index7 + "]",
+  })) && _vo1(elem, _path + ".barrels[" + _index6 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".barrels[" + _index6 + "]",
     expected: "BarrelConfig",
     value: elem
   })).every((flag) => flag) || _report(_exceptionable, {
@@ -1075,8 +1061,8 @@ const validateConfig = (() => {
     path: _path + ".include",
     expected: "(Array<string> | undefined)",
     value: input.include
-  })) && input.include.map((elem, _index8) => "string" === typeof elem || _report(_exceptionable, {
-    path: _path + ".include[" + _index8 + "]",
+  })) && input.include.map((elem, _index7) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".include[" + _index7 + "]",
     expected: "string",
     value: elem
   })).every((flag) => flag) || _report(_exceptionable, {
@@ -1087,8 +1073,8 @@ const validateConfig = (() => {
     path: _path + ".exclude",
     expected: "(Array<string> | undefined)",
     value: input.exclude
-  })) && input.exclude.map((elem, _index9) => "string" === typeof elem || _report(_exceptionable, {
-    path: _path + ".exclude[" + _index9 + "]",
+  })) && input.exclude.map((elem, _index8) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".exclude[" + _index8 + "]",
     expected: "string",
     value: elem
   })).every((flag) => flag) || _report(_exceptionable, {
@@ -1099,8 +1085,8 @@ const validateConfig = (() => {
     path: _path + ".order",
     expected: "(Array<string> | undefined)",
     value: input.order
-  })) && input.order.map((elem, _index10) => "string" === typeof elem || _report(_exceptionable, {
-    path: _path + ".order[" + _index10 + "]",
+  })) && input.order.map((elem, _index9) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".order[" + _index9 + "]",
     expected: "string",
     value: elem
   })).every((flag) => flag) || _report(_exceptionable, {
@@ -1117,11 +1103,11 @@ const validateConfig = (() => {
     value: input.replace
   }), void 0 === input.exports || ("object" === typeof input.exports && null !== input.exports && false === Array.isArray(input.exports) || _report(_exceptionable, {
     path: _path + ".exports",
-    expected: "(ExportsConfig | undefined)",
+    expected: "(__type.o1 | undefined)",
     value: input.exports
   })) && _vo3(input.exports, _path + ".exports", _exceptionable) || _report(_exceptionable, {
     path: _path + ".exports",
-    expected: "(ExportsConfig | undefined)",
+    expected: "(__type.o1 | undefined)",
     value: input.exports
   }), void 0 === input.bracketSpacing || "boolean" === typeof input.bracketSpacing || _report(_exceptionable, {
     path: _path + ".bracketSpacing",
@@ -1165,79 +1151,17 @@ const validateConfig = (() => {
     const value = input[key2];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value && false === Array.isArray(value) || _report(_exceptionable, {
+    return (Array.isArray(value) || _report(_exceptionable, {
       path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key2),
-      expected: "__type.o1",
+      expected: "Array<string>",
       value
-    })) && _vo4(value, _path + _accessExpressionAsStringExports._accessExpressionAsString(key2), _exceptionable) || _report(_exceptionable, {
-      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key2),
-      expected: "__type.o1",
-      value
-    });
-  }).every((flag) => flag)].every((flag) => flag);
-  const _vo4 = (input, _path, _exceptionable = true) => [void 0 === input.includeMembers || (Array.isArray(input.includeMembers) || _report(_exceptionable, {
-    path: _path + ".includeMembers",
-    expected: "(Array<string> | undefined)",
-    value: input.includeMembers
-  })) && input.includeMembers.map((elem, _index11) => "string" === typeof elem || _report(_exceptionable, {
-    path: _path + ".includeMembers[" + _index11 + "]",
-    expected: "string",
-    value: elem
-  })).every((flag) => flag) || _report(_exceptionable, {
-    path: _path + ".includeMembers",
-    expected: "(Array<string> | undefined)",
-    value: input.includeMembers
-  }), void 0 === input.excludeMembers || (Array.isArray(input.excludeMembers) || _report(_exceptionable, {
-    path: _path + ".excludeMembers",
-    expected: "(Array<string> | undefined)",
-    value: input.excludeMembers
-  })) && input.excludeMembers.map((elem, _index12) => "string" === typeof elem || _report(_exceptionable, {
-    path: _path + ".excludeMembers[" + _index12 + "]",
-    expected: "string",
-    value: elem
-  })).every((flag) => flag) || _report(_exceptionable, {
-    path: _path + ".excludeMembers",
-    expected: "(Array<string> | undefined)",
-    value: input.excludeMembers
-  }), void 0 === input.map || ("object" === typeof input.map && null !== input.map && false === Array.isArray(input.map) || _report(_exceptionable, {
-    path: _path + ".map",
-    expected: "(__type.o2 | undefined)",
-    value: input.map
-  })) && _vo5(input.map, _path + ".map", _exceptionable) || _report(_exceptionable, {
-    path: _path + ".map",
-    expected: "(__type.o2 | undefined)",
-    value: input.map
-  }), void 0 === input.skipMapMembersIfNotExists || "boolean" === typeof input.skipMapMembersIfNotExists || _report(_exceptionable, {
-    path: _path + ".skipMapMembersIfNotExists",
-    expected: "(boolean | undefined)",
-    value: input.skipMapMembersIfNotExists
-  }), void 0 === input.asteriskIfAllExported || "boolean" === typeof input.asteriskIfAllExported || _report(_exceptionable, {
-    path: _path + ".asteriskIfAllExported",
-    expected: "(boolean | undefined)",
-    value: input.asteriskIfAllExported
-  }), void 0 === input.typePrefixIfPossible || "boolean" === typeof input.typePrefixIfPossible || _report(_exceptionable, {
-    path: _path + ".typePrefixIfPossible",
-    expected: "(boolean | undefined)",
-    value: input.typePrefixIfPossible
-  }), 0 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key2) => {
-    if (["includeMembers", "excludeMembers", "map", "skipMapMembersIfNotExists", "asteriskIfAllExported", "typePrefixIfPossible"].some((prop) => key2 === prop))
-      return true;
-    const value = input[key2];
-    if (void 0 === value)
-      return true;
-    return _report(_exceptionable, {
-      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key2),
-      expected: "undefined",
-      value
-    });
-  }).every((flag) => flag))].every((flag) => flag);
-  const _vo5 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key2) => {
-    const value = input[key2];
-    if (void 0 === value)
-      return true;
-    return "string" === typeof value || _report(_exceptionable, {
-      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key2),
+    })) && value.map((elem, _index10) => "string" === typeof elem || _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key2) + "[" + _index10 + "]",
       expected: "string",
+      value: elem
+    })).every((flag) => flag) || _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key2),
+      expected: "Array<string>",
       value
     });
   }).every((flag) => flag)].every((flag) => flag);
@@ -16900,15 +16824,16 @@ function formatExportLine(path2, config, barrelConfig) {
   const bracketSpacingIfNeeded = barrelConfig.bracketSpacing ?? config.bracketSpacing ?? DEFAULT_CONFIG.bracketSpacing ? " " : "";
   const quote = barrelConfig.singleQuote ?? config.singleQuote ?? DEFAULT_CONFIG.singleQuote ? "'" : '"';
   const semiIfNeeded = barrelConfig.semi ?? config.semi ?? DEFAULT_CONFIG.semi ? ";" : "";
+  const fromPartText = `from ${quote}./${path2.modifiedPath}${quote}${semiIfNeeded}`;
   if (!path2.exports?.length) {
-    return `export * from ${quote}./${path2.modifiedPath}${quote}${semiIfNeeded}`;
-  }
-  const members = path2.exports.join(", ");
-  if (path2.exports.length === 1 && path2.exports[0].startsWith("*")) {
-    return `export ${members} from ${quote}./${path2.modifiedPath}${quote}${semiIfNeeded}`;
+    return `export * ${fromPartText}`;
   }
-  return `export {${bracketSpacingIfNeeded}${members}${bracketSpacingIfNeeded}} from ${quote}./${path2.modifiedPath}${quote}${semiIfNeeded}`;
+  const asteriskMembers = path2.exports.filter((x) => x.startsWith("*")).map((x) => `export ${x} ${fromPartText}`).join("\n");
+  const asteriskMembersText = asteriskMembers.length ? asteriskMembers + "\n" : "";
+  const members = path2.exports.filter((x) => !x.startsWith("*")).join(", ");
+  return `${asteriskMembersText}export {${bracketSpacingIfNeeded}${members}${bracketSpacingIfNeeded}} ${fromPartText}`;
 }
+const BARRELIZE_CONTENT_REGEX = /(?<=\/\/ *barrelize-start *\n)[\s\S]*(?= *\/\/ *barrelize-end)/;
 async function generateBarrels(configDir, configPath, config) {
   for (const barrelConfig of config.barrels) {
     const indexFileBasePath = barrelConfig.name ?? DEFAULT_CONFIG.name;
@@ -16920,13 +16845,16 @@ async function generateBarrels(configDir, configPath, config) {
       console.error(logWarning(`  Please verify the directory path in your '${configPath}' configuration`));
       continue;
     }
-    const exportPaths = await handlePaths(configDir, barrelConfig);
-    const newLineIfNeeded = barrelConfig.insertFinalNewline ?? config.insertFinalNewline ?? DEFAULT_CONFIG.insertFinalNewline ? "\n" : "";
-    const newContent = exportPaths.map((x) => formatExportLine(x, config, barrelConfig)).join("\n") + newLineIfNeeded;
-    const exportedText = `${exportPaths.length} file${plural(exportPaths)} exported`;
+    const newExportPaths = await handlePaths(configDir, barrelConfig);
+    const insertFinalNewline = barrelConfig.insertFinalNewline ?? config.insertFinalNewline ?? DEFAULT_CONFIG.insertFinalNewline;
+    let newContent = newExportPaths.map((x) => formatExportLine(x, config, barrelConfig)).join("\n");
+    const exportedText = `${newExportPaths.length} file${plural(newExportPaths)} exported`;
     if (existsSync(indexFileAbsolutePath)) {
-      const oldContent = (await readFile(indexFileAbsolutePath)).toString();
-      if (newContent === oldContent) {
+      const oldFileContent = (await readFile(indexFileAbsolutePath)).toString();
+      const barrelizeMatch = oldFileContent.match(BARRELIZE_CONTENT_REGEX);
+      const barrelizeContent = barrelizeMatch?.at(0);
+      newContent += insertFinalNewline || barrelizeMatch ? "\n" : "";
+      if ((barrelizeContent ?? oldFileContent) === newContent) {
         console.log(
           colorize("IGNORE", TerminalColor.GRAY),
           colorize(indexFileRelativePath, TerminalColor.CYAN),
@@ -16934,11 +16862,15 @@ async function generateBarrels(configDir, configPath, config) {
         );
         continue;
       }
-      const oldPaths = await indexFileExportedPaths(oldContent);
-      await writeFile(indexFileAbsolutePath, newContent);
+      if (barrelizeMatch) {
+        await writeFile(indexFileAbsolutePath, oldFileContent.replace(BARRELIZE_CONTENT_REGEX, newContent));
+      } else {
+        await writeFile(indexFileAbsolutePath, newContent);
+      }
+      const oldExportPaths = await getExportedPathsFromContent(barrelizeContent ?? oldFileContent);
       const { insertions, deletions } = pathsDifferences(
-        oldPaths,
-        exportPaths.map((x) => x.modifiedPath)
+        oldExportPaths,
+        newExportPaths.map((x) => x.modifiedPath)
       );
       const insertionsText = insertions.length > 0 ? `, ${insertions.length} insertion${plural(insertions)}` : "";
       const deletionsText = deletions.length > 0 ? `, ${deletions.length} deletion${plural(deletions)}` : "";
@@ -16950,6 +16882,7 @@ async function generateBarrels(configDir, configPath, config) {
       printDifferences(insertions, deletions);
       continue;
     }
+    newContent += insertFinalNewline ? "\n" : "";
     await writeFile(indexFileAbsolutePath, newContent);
     console.log(
       colorize("CREATE", TerminalColor.GRAY),
@@ -16969,6 +16902,11 @@ function printDifferences(insertions, deletions) {
 function plural(array) {
   return array.length > 1 ? "s" : "";
 }
+const EXPORT_PATH_REGEX = /(?<='\.\/).+(?=')/g;
+async function getExportedPathsFromContent(content) {
+  const matches = content.match(EXPORT_PATH_REGEX);
+  return matches?.map((x) => x) ?? [];
+}
 var balancedMatch;
 var hasRequiredBalancedMatch;
 function requireBalancedMatch() {
@@ -23533,10 +23471,6 @@ async function globPaths(rootDir, barrelConfig) {
   paths = paths.map((file) => file.replace(/\\/g, "/"));
   return paths;
 }
-async function indexFileExportedPaths(indexFileContent) {
-  const matches = indexFileContent.match(/(?<='\.\/).+(?=')/g);
-  return matches?.map((x) => x) ?? [];
-}
 function pathsDifferences(newPaths, oldPaths) {
   const insertions = newPaths.filter((x) => !oldPaths.includes(x));
   const deletions = oldPaths.filter((x) => !newPaths.includes(x));
@@ -23574,108 +23508,58 @@ function rsTest(rs, s) {
 }
 async function handlePathExports(rootDir, barrelConfig, exportPaths) {
   const configExports = barrelConfig.exports ?? DEFAULT_CONFIG.exports;
-  for (const [globPattern, mapConfig] of Object.entries(configExports)) {
-    if (!mapConfig.map && mapConfig.asteriskIfAllExported) {
+  for (const [globPattern, exportMembers] of Object.entries(configExports)) {
+    if (!exportMembers.length) {
       continue;
     }
     const intersectionPaths = await getIntersectionPaths(rootDir, globPattern, exportPaths);
-    await fillExports(rootDir, intersectionPaths, mapConfig);
+    await fillExports(rootDir, intersectionPaths, exportMembers);
   }
 }
-async function fillExports(rootDir, exportPaths, config) {
-  const includeRegexes = config.includeMembers?.map((x) => tryParseRegex(x) ?? x);
-  const excludeRegexes = config.excludeMembers?.map((x) => tryParseRegex(x) ?? x);
-  const mapRegexes = config.map ? Object.entries(config.map).map(([k, v]) => [tryParseRegex(k) ?? k, v]) : null;
-  const asteriskIfAllExported = config.asteriskIfAllExported ?? true;
-  const typePrefixIfPossible = config.typePrefixIfPossible ?? true;
-  const skipMapMembersIfNotExists = config.skipMapMembersIfNotExists ?? true;
+async function fillExports(rootDir, exportPaths, exportMembers) {
+  const parsedMembers = exportMembers.map((x) => {
+    const [find, replacement] = x.split(/\s+as\s+/);
+    return {
+      member: tryParseRegex(find) ?? find,
+      toMember: replacement
+    };
+  }) ?? [];
   for (const pathInfo of exportPaths) {
-    const resolvedPath = resolve(rootDir, pathInfo.originalPath);
-    const allExportMembers = await getExportedMembers(resolvedPath);
-    const exportMemberList = await filterExportMembers(allExportMembers, includeRegexes, excludeRegexes);
-    const exportMemberMap = getExportMemberMap(allExportMembers, mapRegexes, skipMapMembersIfNotExists);
-    const asteriskMapItem = exportMemberMap.get("*");
-    if (asteriskMapItem) {
-      pathInfo.exports = [
-        formatExportMember(
-          typePrefixIfPossible,
-          asteriskMapItem.exportKind,
-          asteriskMapItem.oldName,
-          asteriskMapItem.newName
-        )
-      ];
-      continue;
-    }
-    if (asteriskIfAllExported && !exportMemberMap.size && exportMemberList.length === allExportMembers.length) {
-      continue;
-    }
     pathInfo.exports = [];
-    for (const { exportKind, oldName, newName } of exportMemberMap.values()) {
-      pathInfo.exports.push(formatExportMember(typePrefixIfPossible, exportKind, oldName, newName));
-    }
-    for (const exportInfo of exportMemberList) {
-      if (!exportMemberMap.has(exportInfo.name)) {
-        pathInfo.exports.push(
-          formatExportMember(typePrefixIfPossible, exportInfo.exportKind, exportInfo.name)
-        );
+    const resolvedPath = resolve(rootDir, pathInfo.originalPath);
+    const allExportInfos = await getExportedMembers(resolvedPath);
+    const map = /* @__PURE__ */ new Map();
+    const setMap = (fromMember, toMember, exportKind) => {
+      fromMember = fromMember.trim();
+      toMember = toMember.trim();
+      if (map.has(toMember) && fromMember === toMember) {
+        return;
       }
-    }
-  }
-}
-function formatExportMember(typePrefixIfPossible, exportKind, name2, newName) {
-  const typeIfNeeded = typePrefixIfPossible && exportKind === "type" ? "type " : "";
-  if (newName) {
-    return `${typeIfNeeded}${name2} as ${newName}`;
-  } else {
-    return `${typeIfNeeded}${name2}`;
-  }
-}
-function getExportMemberMap(exportMembers, mapRegexes, skipMapMembersIfNotExists) {
-  const exportMemberMap = /* @__PURE__ */ new Map();
-  if (!mapRegexes?.length) {
-    return exportMemberMap;
-  }
-  for (const [find, replacement] of mapRegexes) {
-    if (typeof find === "string") {
-      if (!skipMapMembersIfNotExists || find === "*") {
-        exportMemberMap.set(find, { oldName: find, newName: replacement });
+      map.set(toMember, { name: fromMember, exportKind });
+    };
+    for (const { member, toMember } of parsedMembers) {
+      if (typeof member === "string") {
+        const exportInfo = allExportInfos.find((x) => x.name === member);
+        setMap(member, toMember ?? member, exportInfo?.exportKind);
         continue;
       }
-      if (find !== replacement) {
-        const exportInfo = exportMembers.find((x) => x.name === find);
-        if (exportInfo) {
-          exportMemberMap.set(find, {
-            exportKind: exportInfo.exportKind,
-            oldName: exportInfo.name,
-            newName: replacement
-          });
-        }
+      const foundExportInfos = allExportInfos.filter((x) => member.test(x.name));
+      for (const exportInfo of foundExportInfos) {
+        setMap(exportInfo.name, exportInfo.name.replace(member, toMember ?? exportInfo.name));
       }
-      continue;
     }
-    exportMembers.forEach((exportInfo) => {
-      if (find.test(exportInfo.name)) {
-        const newName = exportInfo.name.replace(find, replacement);
-        if (exportInfo.name !== newName) {
-          exportMemberMap.set(exportInfo.name, {
-            exportKind: exportInfo.exportKind,
-            oldName: exportInfo.name,
-            newName
-          });
-        }
-      }
-    });
+    for (const [newName, info] of map) {
+      pathInfo.exports.push(formatExportMember(info.exportKind, info.name, newName));
+    }
   }
-  return exportMemberMap;
 }
-async function filterExportMembers(exportMembers, include, exclude) {
-  if (include?.length) {
-    exportMembers = exportMembers.filter((member) => include.some((rs) => rsTest(rs, member.name)));
-  }
-  if (exclude?.length) {
-    exportMembers = exportMembers.filter((member) => exclude.some((rs) => !rsTest(rs, member.name)));
+function formatExportMember(exportKind, name2, newName) {
+  const typeIfNeeded = exportKind === "type" ? "type " : "";
+  if (name2 !== newName) {
+    return `${typeIfNeeded}${name2} as ${newName}`;
+  } else {
+    return `${typeIfNeeded}${name2}`;
   }
-  return [...exportMembers];
 }
 async function getIntersectionPaths(rootDir, globPattern, exportPaths) {
   let paths = await glob(globPattern, {
@@ -23754,12 +23638,12 @@ export {
   extractExportsFromFile,
   formatExportLine,
   generateBarrels,
+  getExportedPathsFromContent,
   globPaths,
   handlePathExports,
   handlePathOrder,
   handlePathReplace,
   handlePaths,
-  indexFileExportedPaths,
   logDebug,
   logError,
   logInfo,

package/lib/src/config/barrel-config.d.ts

@@ -0,0 +1,68 @@
+export type BarrelConfig = {
+    /**
+     * Root directory to start from (support glob pattern)
+     * @default ''
+     */
+    root?: string;
+    /**
+     * Name of the index file (e.g. index.ts or some/path/index.ts)
+     * @default 'index.ts'
+     */
+    name?: string;
+    /**
+     * Files to include in the barrel (supports glob patterns)
+     * @default ['**\/*.ts']
+     */
+    include?: string[];
+    /**
+     * Files to exclude from the barrel (supports glob patterns)
+     * @default []
+     */
+    exclude?: string[];
+    /**
+     * Ordering of exports
+     * @default []
+     */
+    order?: string[];
+    /**
+     * String or regular expression patterns to find and replace in export paths (e.g. {"\\.ts$": "", "my-custom-export-path.ts": "my-path.ts"})
+     * @default {'/\\.ts$/': ''}
+     */
+    replace?: {
+        /**
+         * String or regular expression pattern to find in export paths (e.g. "\\.ts$", "my-custom-export-path.ts")
+         */
+        [key: string]: string;
+    };
+    /**
+     * Configuration for exports in barrel files
+     * @default {'**\/*.ts': {}}
+     */
+    exports?: {
+        /**
+         * Glob pattern exports file with string or regular expression patterns
+         * (e.g. "**\/*service.ts": ["* as lib", "/(.+)Config$/ as $1LibConfig", "util"])
+         */
+        [key: string]: string[];
+    };
+    /**
+     * Use spaces between brackets in exports
+     * @default true
+     */
+    bracketSpacing?: boolean;
+    /**
+     * Use single quotes for exports
+     * @default true
+     */
+    singleQuote?: boolean;
+    /**
+     * Add semicolons after exports
+     * @default true
+     */
+    semi?: boolean;
+    /**
+     * Add newline at end of file
+     * @default true
+     */
+    insertFinalNewline?: boolean;
+};

package/lib/src/config/config.d.ts

@@ -1,3 +1,4 @@
+import { BarrelConfig } from '../index.ts';
 export type Config = {
     /**
      * Path to the JSON schema file that will be used for configuration validation
@@ -35,109 +36,6 @@ export type Config = {
      */
     barrels: BarrelConfig[];
 };
-export type BarrelConfig = {
-    /**
-     * Root directory to start from (support glob pattern)
-     * @default ''
-     */
-    root?: string;
-    /**
-     * Name of the index file (e.g. index.ts or some/path/index.ts)
-     * @default 'index.ts'
-     */
-    name?: string;
-    /**
-     * Files to include in the barrel (supports glob patterns)
-     * @default ['**\/*.ts']
-     */
-    include?: string[];
-    /**
-     * Files to exclude from the barrel (supports glob patterns)
-     * @default []
-     */
-    exclude?: string[];
-    /**
-     * Ordering of exports
-     * @default []
-     */
-    order?: string[];
-    /**
-     * String or regular expression patterns to find and replace in export paths (e.g. {"\\.ts$": "", "my-custom-export-path.ts": "my-path.ts"})
-     * @default {'/\\.ts$/': ''}
-     */
-    replace?: {
-        /**
-         * String or regular expression pattern to find in export paths (e.g. "\\.ts$", "my-custom-export-path.ts")
-         */
-        [key: string]: string;
-    };
-    /**
-     * Configuration for exports in barrel files
-     * @default {'**\/*.ts': {}}
-     */
-    exports?: ExportsConfig;
-    /**
-     * Use spaces between brackets in exports
-     * @default true
-     */
-    bracketSpacing?: boolean;
-    /**
-     * Use single quotes for exports
-     * @default true
-     */
-    singleQuote?: boolean;
-    /**
-     * Add semicolons after exports
-     * @default true
-     */
-    semi?: boolean;
-    /**
-     * Add newline at end of file
-     * @default true
-     */
-    insertFinalNewline?: boolean;
-};
-export type ExportsConfig = {
-    /**
-     * Glob pattern exports file (e.g. "**\/*service.ts")
-     */
-    [key: string]: {
-        /**
-         * String or regular expression pattern of members to include in exports
-         * @default []
-         */
-        includeMembers?: string[];
-        /**
-         * String or regular expression pattern of members to exclude from exports
-         * @default []
-         */
-        excludeMembers?: string[];
-        /** Map of member name patterns to export names using string or regular expressions (e.g. {"/^.+Util$/": "util"}, {"default": "lib", "*": "services"})
-         * @default {'*': 'lib'}
-         */
-        map?: {
-            /**
-             * String or regular expression pattern to find in member name (e.g. "/^.+Util$/", "default", "*")
-             */
-            [key: string]: string;
-        };
-        /**
-         * Whether to skip mapping members if they don't export in the source file
-         * @default true
-         */
-        skipMapMembersIfNotExists?: boolean;
-        /**
-         * Use asterisk (*) export when all members from the file are exported
-         * @default true
-         */
-        asteriskIfAllExported?: boolean;
-        /**
-         * Add 'type' prefix for type-only exports when possible
-         * @default true
-         */
-        typePrefixIfPossible?: boolean;
-    };
-};
 export declare const INITIAL_CONFIG: Config;
 export declare const DEFAULT_CONFIG: Required<BarrelConfig>;
 export declare const validateConfig: ((input: unknown) => import('typia').IValidation<Config>) & import('@standard-schema/spec').StandardSchemaV1<unknown, Config>;

package/lib/src/config/exports-config.d.ts

@@ -0,0 +1,22 @@
+export type ExportsConfig = {
+    /**
+     * Glob pattern exports file (e.g. "**\/*service.ts")
+     */
+    [key: string]: {
+        /**
+         * String or regular expression pattern of export members
+         * @default []
+         */
+        members?: string[];
+        /**
+         * Whether to skip mapping members if they don't export in the source file
+         * @default true
+         */
+        skipMapMembersIfNotExists?: boolean;
+        /**
+         * Add 'type' prefix for type-only exports when possible
+         * @default true
+         */
+        typePrefixIfPossible?: boolean;
+    };
+};

package/lib/src/generate/get-exported-paths-from-content.d.ts

@@ -0,0 +1 @@
+export declare function getExportedPathsFromContent(content: string): Promise<string[]>;

package/lib/src/generate/handlers/handle-path-exports.d.ts

@@ -1,7 +1,2 @@
-import { BarrelConfig, ExportInfo, ExportPathInfo } from '../../index.ts';
-export type MapReplacement = {
-    exportKind?: ExportInfo['exportKind'];
-    oldName: string;
-    newName: string;
-};
+import { BarrelConfig, ExportPathInfo } from '../../index.ts';
 export declare function handlePathExports(rootDir: string, barrelConfig: BarrelConfig, exportPaths: ExportPathInfo[]): Promise<void>;

package/lib/src/index.d.ts

@@ -5,15 +5,17 @@ export * from './cli/commands/init-command';
 export * from './log/colorize';
 export * from './log/log-validation-error';
 export * from './log/log';
+export * from './config/barrel-config';
 export * from './config/config';
+export * from './config/exports-config';
 export * from './config/parse-config';
 export * from './extract-exports/extract-exports-options';
 export * from './extract-exports/extract-exports';
 export * from './generate/export-path-info';
 export * from './generate/format-export-line';
 export * from './generate/generate-barrels';
+export * from './generate/get-exported-paths-from-content';
 export * from './generate/glob-paths';
-export * from './generate/index-file-exported-paths';
 export * from './generate/paths-differences';
 export * from './regex/try-parse-regex';
 export * from './generate/handlers/handle-path-exports';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barrelize",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Automatically generating index (barrel) files",
   "scripts": {
     "build": "npm run schema && vite build",

package/schema.json

@@ -119,7 +119,15 @@
           }
         },
         "exports": {
-          "$ref": "#/definitions/ExportsConfig",
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Glob pattern exports file with string or regular expression patterns (e.g. \"**\\/*service.ts\": [\"* as lib\", \"/(.+)Config$/ as $1LibConfig\", \"util\"])",
+            "markdownDescription": "Glob pattern exports file with string or regular expression patterns\n(e.g. \"**\\/*service.ts\": [\"* as lib\", \"/(.+)Config$/ as $1LibConfig\", \"util\"])"
+          },
           "description": "Configuration for exports in barrel files",
           "markdownDescription": "Configuration for exports in barrel files",
           "default": {
@@ -152,66 +160,6 @@
         }
       },
       "additionalProperties": false
-    },
-    "ExportsConfig": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "properties": {
-          "includeMembers": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "String or regular expression pattern of members to include in exports",
-            "markdownDescription": "String or regular expression pattern of members to include in exports",
-            "default": []
-          },
-          "excludeMembers": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "String or regular expression pattern of members to exclude from exports",
-            "markdownDescription": "String or regular expression pattern of members to exclude from exports",
-            "default": []
-          },
-          "map": {
-            "type": "object",
-            "additionalProperties": {
-              "type": "string",
-              "description": "String or regular expression pattern to find in member name (e.g. \"/^.+Util$/\", \"default\", \"*\")",
-              "markdownDescription": "String or regular expression pattern to find in member name (e.g. \"/^.+Util$/\", \"default\", \"*\")"
-            },
-            "description": "Map of member name patterns to export names using string or regular expressions (e.g. {\"/^.+Util$/\": \"util\"}, {\"default\": \"lib\", \"*\": \"services\"})",
-            "markdownDescription": "Map of member name patterns to export names using string or regular expressions (e.g. {\"/^.+Util$/\": \"util\"}, {\"default\": \"lib\", \"*\": \"services\"})",
-            "default": {
-              "*": "lib"
-            }
-          },
-          "skipMapMembersIfNotExists": {
-            "type": "boolean",
-            "description": "Whether to skip mapping members if they don't export in the source file",
-            "markdownDescription": "Whether to skip mapping members if they don't export in the source file",
-            "default": true
-          },
-          "asteriskIfAllExported": {
-            "type": "boolean",
-            "description": "Use asterisk (*) export when all members from the file are exported",
-            "markdownDescription": "Use asterisk (*) export when all members from the file are exported",
-            "default": true
-          },
-          "typePrefixIfPossible": {
-            "type": "boolean",
-            "description": "Add 'type' prefix for type-only exports when possible",
-            "markdownDescription": "Add 'type' prefix for type-only exports when possible",
-            "default": true
-          }
-        },
-        "additionalProperties": false,
-        "description": "Glob pattern exports file (e.g. \"**\\/*service.ts\")",
-        "markdownDescription": "Glob pattern exports file (e.g. \"**\\/*service.ts\")"
-      }
     }
   }
 }

package/lib/src/generate/index-file-exported-paths.d.ts

@@ -1 +0,0 @@
-export declare function indexFileExportedPaths(indexFileContent: string): Promise<string[]>;