barrelize 1.4.0 → 1.4.2

package/README.md

@@ -109,9 +109,9 @@ Create a `.barrelize` file in your project root. The configuration file uses JSO
       // Export configuration for different file patterns
       "exports": {
         "**/*.ts": {
-          // Include specific members (default: [])
+          // Include specific members using string or regex patterns (default: [])
           "includeMembers": ["MyClass", "/^.*Service$/"],
-          // Exclude specific members (default: [])
+          // Exclude specific members using string or regex patterns (default: [])
           "excludeMembers": ["internal", "/^_.*$/"],
           // Map member patterns to export names
           "map": {
@@ -119,6 +119,8 @@ Create a `.barrelize` file in your project root. The configuration file uses JSO
             "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)

package/lib/index.js

@@ -591,7 +591,7 @@ class CAC extends EventEmitter {
 }
 const cac = (name2 = "") => new CAC(name2);
 const name = "barrelize";
-const version = "1.3.1";
+const version = "1.4.1";
 function cliInit() {
   const cli = cac(name);
   cli.command("[config path]", `Generate barrel files`).action(async (config) => {
@@ -943,6 +943,11 @@ function logWarning(message) {
 function logInfo(message) {
   console.log(colorize(message, TerminalColor.BLUE));
 }
+function logDebug(message) {
+  if (process.argv.includes("--verbose")) {
+    console.log(colorize(message, TerminalColor.MAGENTA));
+  }
+}
 const INITIAL_CONFIG = {
   $schema: "node_modules/barrelize/schema.json",
   barrels: [
@@ -996,8 +1001,8 @@ const validateConfig = (() => {
       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.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", "asteriskIfAllExported", "typePrefixIfPossible"].some((prop) => key2 === prop))
+  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)
@@ -1202,6 +1207,10 @@ const validateConfig = (() => {
     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)",
@@ -1211,7 +1220,7 @@ const validateConfig = (() => {
     expected: "(boolean | undefined)",
     value: input.typePrefixIfPossible
   }), 0 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key2) => {
-    if (["includeMembers", "excludeMembers", "map", "asteriskIfAllExported", "typePrefixIfPossible"].some((prop) => key2 === prop))
+    if (["includeMembers", "excludeMembers", "map", "skipMapMembersIfNotExists", "asteriskIfAllExported", "typePrefixIfPossible"].some((prop) => key2 === prop))
       return true;
     const value = input[key2];
     if (void 0 === value)
@@ -16806,7 +16815,7 @@ function requireLib() {
 var libExports = requireLib();
 async function extractExports(sourcePath) {
   if (!existsSync(sourcePath)) {
-    logWarning(`Source path '${sourcePath}' does not exist`);
+    logDebug(`Source path '${sourcePath}' does not exist`);
     return [];
   }
   const options = {
@@ -16821,7 +16830,9 @@ async function extractExportsFromFile(sourcePath, options) {
     const ast = parseFileContent(content);
     return extractExportsFromAst(ast, options);
   } catch (error) {
-    console.error(`Failed to process file '${sourcePath}':`, error);
+    if (error instanceof Error) {
+      logDebug(`Failed to process file '${sourcePath}': ${error.message}`);
+    }
     return [];
   }
 }
@@ -16853,7 +16864,7 @@ async function extractExportsFromAst(ast, options) {
       if (options.recursive) {
         const normalizedPath = normalizeSourcePath(node.source.value, options);
         if (!normalizedPath) {
-          logWarning(`Exported module path '${normalizedPath}' does not exist`);
+          logDebug(`Exported module path '${normalizedPath}' does not exist`);
         } else {
           const innerExports = await extractExportsFromFile(normalizedPath, options);
           exports.push(...innerExports);
@@ -23577,65 +23588,83 @@ async function fillExports(rootDir, exportPaths, config) {
   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;
   for (const pathInfo of exportPaths) {
     const resolvedPath = resolve(rootDir, pathInfo.originalPath);
-    let allExportMembers = await getExportedMembers(resolvedPath);
-    if (!allExportMembers.length) {
-      continue;
-    }
+    const allExportMembers = await getExportedMembers(resolvedPath);
     const exportMemberList = await filterExportMembers(allExportMembers, includeRegexes, excludeRegexes);
-    const exportMemberMap = getExportMemberMap(mapRegexes, allExportMembers);
-    if (exportMemberMap.has("*")) {
+    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 { exportInfo, newName } of exportMemberMap.values()) {
-      pathInfo.exports.push(formatExportMember(typePrefixIfPossible, exportInfo, newName));
+    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));
+        pathInfo.exports.push(
+          formatExportMember(typePrefixIfPossible, exportInfo.exportKind, exportInfo.name)
+        );
       }
     }
   }
 }
-function formatExportMember(typePrefixIfPossible, exportInfo, newName) {
-  const typeIfNeeded = typePrefixIfPossible && exportInfo.exportKind === "type" ? "type " : "";
+function formatExportMember(typePrefixIfPossible, exportKind, name2, newName) {
+  const typeIfNeeded = typePrefixIfPossible && exportKind === "type" ? "type " : "";
   if (newName) {
-    return `${typeIfNeeded}${exportInfo.name} as ${newName}`;
+    return `${typeIfNeeded}${name2} as ${newName}`;
   } else {
-    return `${typeIfNeeded}${exportInfo.name}`;
+    return `${typeIfNeeded}${name2}`;
   }
 }
-function getExportMemberMap(mapRegexes, exportMembers) {
+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 });
+        continue;
+      }
       if (find !== replacement) {
         const exportInfo = exportMembers.find((x) => x.name === find);
         if (exportInfo) {
-          exportMemberMap.set(find, { exportInfo, newName: replacement });
-          if (find === "*") {
-            return exportMemberMap;
-          }
+          exportMemberMap.set(find, {
+            exportKind: exportInfo.exportKind,
+            oldName: exportInfo.name,
+            newName: replacement
+          });
         }
       }
-    } else {
-      exportMembers.forEach((exportInfo) => {
-        if (find.test(exportInfo.name)) {
-          const newName = exportInfo.name.replace(find, replacement);
-          if (exportInfo.name !== newName) {
-            exportMemberMap.set(exportInfo.name, { exportInfo, newName });
-          }
-        }
-      });
+      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
+          });
+        }
+      }
+    });
   }
   return exportMemberMap;
 }
@@ -23731,6 +23760,7 @@ export {
   handlePathReplace,
   handlePaths,
   indexFileExportedPaths,
+  logDebug,
   logError,
   logInfo,
   logValidationError,

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

@@ -121,6 +121,11 @@ export type ExportsConfig = {
              */
             [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

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

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

package/lib/src/log/log.d.ts

@@ -1,3 +1,4 @@
 export declare function logError(message: string): void;
 export declare function logWarning(message: string): void;
 export declare function logInfo(message: string): void;
+export declare function logDebug(message: string): void;

package/package.json

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

package/schema.json

@@ -189,6 +189,12 @@
               "*": "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",