barrelize 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nizami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+# Barrelize
+
+🚀 A modern, lightweight and efficient tool for automatically generating index (barrel) files in your JavaScript and TypeScript projects.
+
+Barrelize simplifies module exports by creating clean, centralized `index.js` or `index.ts` files, reducing boilerplate and improving project organization.
+
+[![NPM Version](https://img.shields.io/npm/v/barrelize)](https://www.npmjs.com/package/barrelize)
+
+[![GitHub License](https://img.shields.io/github/license/nizami/barrelize)
+](https://opensource.org/licenses/MIT)
+
+## Features
+- **Automatic Barrel Generation**: Scans directories and creates index files with exports for all modules.
+- **TypeScript Support**: Seamlessly works with TypeScript projects, preserving type safety.
+- **Customizable**: Configure file patterns, ignore specific files, or customize export styles (named, default, or both).
+- **Recursive**: Optionally generate barrels for nested directories.
+- **CLI & API**: Use via command line for quick setups or integrate programmatically in your build scripts.
+
+### Why Use Barrelize?
+- **Save Time**: Eliminate manual creation and maintenance of barrel files.
+- **Cleaner Imports**: Simplify import statements with a single entry point for each directory.
+- **Scalable**: Ideal for large projects with complex folder structures.
+
+
+## Installation
+
+```bash
+npm install -D barrelize
+```
+
+## Quick Start
+
+1. Initialize configuration (optional):
+
+```bash
+npx barrelize init
+```
+
+2. Generate barrel files:
+
+```bash
+npx barrelize
+```
+
+## CLI Commands
+
+### `barrelize init [config path]`
+
+Creates a `.barrelize` configuration file in your project.
+
+```bash
+npx barrelize init                # Creates .barrelize in current directory
+npx barrelize init barrelize.json # Creates config at specified path
+```
+
+### `barrelize [config path]`
+
+Generates barrel (index) files based on your configuration.
+
+```bash
+npx barrelize                   # Uses default .barrelize config
+npx barrelize -c barrelize.json # Uses custom config file
+```
+
+## Configuration
+
+Create a `.barrelize` file in your project root:
+
+```json
+{
+  "directories": [
+    {
+      "path": "src",
+      "include": ["**/*.ts", "**/*.tsx"],
+      "exclude": ["**/*.test.ts", "**/*.spec.ts"],
+      "order": ["types", "constants", "utils"],
+      "keepFileExtension": true,
+      "replace": [
+        {
+          "find": ".ts$",
+          "replacement": ""
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Example
+
+Before:
+
+```
+src/
+  ├── types.ts
+  ├── constants.ts
+  ├── utils.ts
+  └── components/
+      ├── Button.tsx
+      └── Input.tsx
+```
+
+After running `barrelize`:
+
+```
+src/
+  ├── types.ts
+  ├── constants.ts
+  ├── utils.ts
+  ├── index.ts           # New!
+  └── components/
+      ├── Button.tsx
+      └── Input.tsx
+```
+
+Generated `src/index.ts`:
+
+```typescript
+export * from './types';
+export * from './constants';
+export * from './utils';
+export * from './components/Button.tsx';
+export * from './components/Input.tsx';
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © Nizami

package/bin/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {cliInit} from '../lib/index.js';
+
+cliInit();

package/lib/index.js

@@ -0,0 +1,771 @@
+import JSON5 from "json5";
+import { writeFile, readFile } from "node:fs/promises";
+import { glob } from "glob";
+import { existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { cac } from "cac";
+const name = "barrelize";
+const version = "1.0.0";
+function cliInit() {
+  const cli = cac(name);
+  cli.command("[config path]", `Generate 'index.ts' files for all directories`).action(async (config) => {
+    await runGenerateCommand({ configPath: config || ".barrelize" });
+  });
+  cli.command("init [config path]", "Create .barrelize config file if does not exist").example("barrelize init").example("barrelize init .barrelize").example("barrelize init root/.barrelize").action(async (path = ".barrelize") => {
+    await runInitCommand(path);
+  });
+  cli.help();
+  cli.version(version);
+  try {
+    cli.parse();
+  } catch (error) {
+    if (error instanceof Error) {
+      logError(error.message);
+    } else {
+      logError(String(error));
+    }
+  }
+}
+var _accessExpressionAsString = {};
+var hasRequired_accessExpressionAsString;
+function require_accessExpressionAsString() {
+  if (hasRequired_accessExpressionAsString) return _accessExpressionAsString;
+  hasRequired_accessExpressionAsString = 1;
+  Object.defineProperty(_accessExpressionAsString, "__esModule", { value: true });
+  _accessExpressionAsString._accessExpressionAsString = void 0;
+  const _accessExpressionAsString$1 = (str) => variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
+  _accessExpressionAsString._accessExpressionAsString = _accessExpressionAsString$1;
+  const variable = (str) => reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+  const reserved = (str) => RESERVED.has(str);
+  const RESERVED = /* @__PURE__ */ new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with"
+  ]);
+  return _accessExpressionAsString;
+}
+var _accessExpressionAsStringExports = /* @__PURE__ */ require_accessExpressionAsString();
+var _validateReport = {};
+var hasRequired_validateReport;
+function require_validateReport() {
+  if (hasRequired_validateReport) return _validateReport;
+  hasRequired_validateReport = 1;
+  Object.defineProperty(_validateReport, "__esModule", { value: true });
+  _validateReport._validateReport = void 0;
+  const _validateReport$1 = (array) => {
+    const reportable = (path) => {
+      if (array.length === 0)
+        return true;
+      const last = array[array.length - 1].path;
+      return path.length > last.length || last.substring(0, path.length) !== path;
+    };
+    return (exceptable, error) => {
+      if (exceptable && reportable(error.path))
+        array.push(error);
+      return false;
+    };
+  };
+  _validateReport._validateReport = _validateReport$1;
+  return _validateReport;
+}
+var _validateReportExports = /* @__PURE__ */ require_validateReport();
+var _createStandardSchema = {};
+var hasRequired_createStandardSchema;
+function require_createStandardSchema() {
+  if (hasRequired_createStandardSchema) return _createStandardSchema;
+  hasRequired_createStandardSchema = 1;
+  Object.defineProperty(_createStandardSchema, "__esModule", { value: true });
+  _createStandardSchema._createStandardSchema = void 0;
+  const _createStandardSchema$1 = (fn) => Object.assign(fn, {
+    "~standard": {
+      version: 1,
+      vendor: "typia",
+      validate: (input) => {
+        const result = fn(input);
+        if (result.success) {
+          return {
+            value: result.data
+          };
+        } else {
+          return {
+            issues: result.errors.map((error) => ({
+              message: `expected ${error.expected}, got ${error.value}`,
+              path: typiaPathToStandardSchemaPath(error.path)
+            }))
+          };
+        }
+      }
+    }
+  });
+  _createStandardSchema._createStandardSchema = _createStandardSchema$1;
+  var PathParserState;
+  (function(PathParserState2) {
+    PathParserState2[PathParserState2["Start"] = 0] = "Start";
+    PathParserState2[PathParserState2["Property"] = 1] = "Property";
+    PathParserState2[PathParserState2["StringKey"] = 2] = "StringKey";
+    PathParserState2[PathParserState2["NumberKey"] = 3] = "NumberKey";
+  })(PathParserState || (PathParserState = {}));
+  const typiaPathToStandardSchemaPath = (path) => {
+    if (!path.startsWith("$input")) {
+      throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+    }
+    const segments = [];
+    let currentSegment = "";
+    let state = PathParserState.Start;
+    let index = "$input".length - 1;
+    while (index < path.length - 1) {
+      index++;
+      const char = path[index];
+      if (state === PathParserState.Property) {
+        if (char === "." || char === "[") {
+          segments.push({
+            key: currentSegment
+          });
+          state = PathParserState.Start;
+        } else if (index === path.length - 1) {
+          currentSegment += char;
+          segments.push({
+            key: currentSegment
+          });
+          index++;
+          state = PathParserState.Start;
+        } else {
+          currentSegment += char;
+        }
+      } else if (state === PathParserState.StringKey) {
+        if (char === '"') {
+          segments.push({
+            key: JSON.parse(currentSegment + char)
+          });
+          index += 2;
+          state = PathParserState.Start;
+        } else if (char === "\\") {
+          currentSegment += path[index];
+          index++;
+          currentSegment += path[index];
+        } else {
+          currentSegment += char;
+        }
+      } else if (state === PathParserState.NumberKey) {
+        if (char === "]") {
+          segments.push({
+            key: Number.parseInt(currentSegment)
+          });
+          index++;
+          state = PathParserState.Start;
+        } else {
+          currentSegment += char;
+        }
+      }
+      if (state === PathParserState.Start && index < path.length - 1) {
+        const newChar = path[index];
+        currentSegment = "";
+        if (newChar === "[") {
+          if (path[index + 1] === '"') {
+            state = PathParserState.StringKey;
+            index++;
+            currentSegment = '"';
+          } else {
+            state = PathParserState.NumberKey;
+          }
+        } else if (newChar === ".") {
+          state = PathParserState.Property;
+        } else {
+          throw new Error("Unreachable: pointer points invalid character");
+        }
+      }
+    }
+    if (state !== PathParserState.Start) {
+      throw new Error(`Failed to parse path: ${JSON.stringify(path)}`);
+    }
+    return segments;
+  };
+  return _createStandardSchema;
+}
+var _createStandardSchemaExports = /* @__PURE__ */ require_createStandardSchema();
+const validateGenerateOptions = (() => {
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.configPath && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["configPath"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.configPath || _report(_exceptionable, {
+    path: _path + ".configPath",
+    expected: "string",
+    value: input.configPath
+  }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["configPath"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let errors;
+  let _report;
+  return _createStandardSchemaExports._createStandardSchema((input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = _validateReportExports._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _report(true, {
+        path: _path + "",
+        expected: "GenerateCommandOptions",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "GenerateCommandOptions",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  });
+})();
+async function runGenerateCommand(options) {
+  const validatedOptions = validateGenerateOptions(options);
+  if (!validatedOptions.success) {
+    logValidationError(`Invalid 'generate' command options`, validatedOptions);
+    return;
+  }
+  if (!existsSync(options.configPath)) {
+    logError(`Couldn't find barrelize config file with path '${options.configPath}'`);
+    return;
+  }
+  const config = await parseConfig(options.configPath);
+  const validatedConfig = validateConfig(config);
+  if (!validatedConfig.success) {
+    logValidationError(`Invalid barrelize config`, validatedConfig);
+    return;
+  }
+  const rootPath = resolve(dirname(options.configPath));
+  await generateBarrels(rootPath, validatedConfig.data);
+}
+const configTemplate = {
+  directories: [
+    {
+      path: "src",
+      include: ["**/*.ts"],
+      exclude: ["**/*.test.ts"],
+      order: ["models", "api"],
+      indexFilePath: "index.ts"
+    }
+  ]
+};
+async function runInitCommand(baseConfigFilePath) {
+  const configFilePath = resolve(process.cwd(), baseConfigFilePath);
+  if (existsSync(configFilePath)) {
+    logWarning(`Config file '${configFilePath}' already exists`);
+    return;
+  }
+  const configDirectoryPath = dirname(configFilePath);
+  if (!existsSync(configDirectoryPath)) {
+    logWarning(`Directory '${configDirectoryPath}' does not exist`);
+    return;
+  }
+  const configTemplateJson = JSON.stringify(configTemplate, null, 2);
+  await writeFile(configFilePath, configTemplateJson);
+  console.log(colorize(baseConfigFilePath, TerminalColor.CYAN), colorize(`file created`, TerminalColor.GRAY));
+  console.log(colorize(configTemplateJson, TerminalColor.GREEN));
+}
+const validateConfig = (() => {
+  const _io0 = (input, _exceptionable = true) => Array.isArray(input.directories) && input.directories.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["directories"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "string" === typeof input.path && (Array.isArray(input.include) && input.include.every((elem, _index2) => "string" === typeof elem)) && (Array.isArray(input.exclude) && input.exclude.every((elem, _index3) => "string" === typeof elem)) && (void 0 === input.order || Array.isArray(input.order) && input.order.every((elem, _index4) => "string" === typeof elem)) && (void 0 === input.indexFilePath || "string" === typeof input.indexFilePath) && (void 0 === input.keepFileExtension || "boolean" === typeof input.keepFileExtension) && (void 0 === input.replace || Array.isArray(input.replace) && input.replace.every((elem, _index5) => "object" === typeof elem && null !== elem && _io2(elem, _exceptionable))) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["path", "include", "exclude", "order", "indexFilePath", "keepFileExtension", "replace"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => "string" === typeof input.find && "string" === typeof input.replacement && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["find", "replacement"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.directories) || _report(_exceptionable, {
+    path: _path + ".directories",
+    expected: "Array<__type>",
+    value: input.directories
+  })) && input.directories.map((elem, _index6) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".directories[" + _index6 + "]",
+    expected: "__type",
+    value: elem
+  })) && _vo1(elem, _path + ".directories[" + _index6 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".directories[" + _index6 + "]",
+    expected: "__type",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".directories",
+    expected: "Array<__type>",
+    value: input.directories
+  }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["directories"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.path || _report(_exceptionable, {
+    path: _path + ".path",
+    expected: "string",
+    value: input.path
+  }), (Array.isArray(input.include) || _report(_exceptionable, {
+    path: _path + ".include",
+    expected: "Array<string>",
+    value: input.include
+  })) && input.include.map((elem, _index7) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".include[" + _index7 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".include",
+    expected: "Array<string>",
+    value: input.include
+  }), (Array.isArray(input.exclude) || _report(_exceptionable, {
+    path: _path + ".exclude",
+    expected: "Array<string>",
+    value: input.exclude
+  })) && input.exclude.map((elem, _index8) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".exclude[" + _index8 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".exclude",
+    expected: "Array<string>",
+    value: input.exclude
+  }), void 0 === input.order || (Array.isArray(input.order) || _report(_exceptionable, {
+    path: _path + ".order",
+    expected: "(Array<string> | undefined)",
+    value: input.order
+  })) && input.order.map((elem, _index9) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".order[" + _index9 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".order",
+    expected: "(Array<string> | undefined)",
+    value: input.order
+  }), void 0 === input.indexFilePath || "string" === typeof input.indexFilePath || _report(_exceptionable, {
+    path: _path + ".indexFilePath",
+    expected: "(string | undefined)",
+    value: input.indexFilePath
+  }), void 0 === input.keepFileExtension || "boolean" === typeof input.keepFileExtension || _report(_exceptionable, {
+    path: _path + ".keepFileExtension",
+    expected: "(boolean | undefined)",
+    value: input.keepFileExtension
+  }), void 0 === input.replace || (Array.isArray(input.replace) || _report(_exceptionable, {
+    path: _path + ".replace",
+    expected: "(Array<__type>.o1 | undefined)",
+    value: input.replace
+  })) && input.replace.map((elem, _index10) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".replace[" + _index10 + "]",
+    expected: "__type.o1",
+    value: elem
+  })) && _vo2(elem, _path + ".replace[" + _index10 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".replace[" + _index10 + "]",
+    expected: "__type.o1",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".replace",
+    expected: "(Array<__type>.o1 | undefined)",
+    value: input.replace
+  }), 3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["path", "include", "exclude", "order", "indexFilePath", "keepFileExtension", "replace"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.find || _report(_exceptionable, {
+    path: _path + ".find",
+    expected: "string",
+    value: input.find
+  }), "string" === typeof input.replacement || _report(_exceptionable, {
+    path: _path + ".replacement",
+    expected: "string",
+    value: input.replacement
+  }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["find", "replacement"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let errors;
+  let _report;
+  return _createStandardSchemaExports._createStandardSchema((input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = _validateReportExports._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _report(true, {
+        path: _path + "",
+        expected: "Config",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "Config",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  });
+})();
+const validateOutputConfig = (() => {
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.cwd && (Array.isArray(input.directories) && input.directories.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, _exceptionable))) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["cwd", "directories"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => Array.isArray(input.files) && input.files.every((elem, _index2) => "string" === typeof elem) && (void 0 === input.order || Array.isArray(input.order) && input.order.every((elem, _index3) => "string" === typeof elem)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["files", "order"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.cwd || _report(_exceptionable, {
+    path: _path + ".cwd",
+    expected: "string",
+    value: input.cwd
+  }), (Array.isArray(input.directories) || _report(_exceptionable, {
+    path: _path + ".directories",
+    expected: "Array<__type>",
+    value: input.directories
+  })) && input.directories.map((elem, _index4) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".directories[" + _index4 + "]",
+    expected: "__type",
+    value: elem
+  })) && _vo1(elem, _path + ".directories[" + _index4 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".directories[" + _index4 + "]",
+    expected: "__type",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".directories",
+    expected: "Array<__type>",
+    value: input.directories
+  }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["cwd", "directories"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo1 = (input, _path, _exceptionable = true) => [(Array.isArray(input.files) || _report(_exceptionable, {
+    path: _path + ".files",
+    expected: "Array<string>",
+    value: input.files
+  })) && input.files.map((elem, _index5) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".files[" + _index5 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".files",
+    expected: "Array<string>",
+    value: input.files
+  }), void 0 === input.order || (Array.isArray(input.order) || _report(_exceptionable, {
+    path: _path + ".order",
+    expected: "(Array<string> | undefined)",
+    value: input.order
+  })) && input.order.map((elem, _index6) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".order[" + _index6 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".order",
+    expected: "(Array<string> | undefined)",
+    value: input.order
+  }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["files", "order"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsStringExports._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let errors;
+  let _report;
+  return _createStandardSchemaExports._createStandardSchema((input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = _validateReportExports._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _report(true, {
+        path: _path + "",
+        expected: "OutputConfig",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "OutputConfig",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  });
+})();
+async function parseConfig(configPath) {
+  const configJson = (await readFile(configPath)).toString();
+  try {
+    return JSON5.parse(configJson);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      const referenceMatches = error.message.match(/at (\d+:\d+)/);
+      const reasonMatches = error.message.match(/(?<=JSON5: ).*?(?= at \d+:\d+)/);
+      if (referenceMatches && reasonMatches) {
+        const reference = `${configPath}:${referenceMatches[1]}`;
+        const reason = reasonMatches[0];
+        logError(`Barrelize json config syntax error: ${reason} at ${reference}:`);
+        return null;
+      }
+    }
+    console.error(error);
+    return null;
+  }
+}
+const DEFAULT_INDEX_FILE_PATH = "index.ts";
+async function generateBarrels(rootPath, config) {
+  for (const directoryConfig of config.directories) {
+    const indexFileBasePath = directoryConfig.indexFilePath ?? DEFAULT_INDEX_FILE_PATH;
+    const indexFileRelativePath = join(directoryConfig.path, indexFileBasePath);
+    const indexFileAbsolutePath = resolve(rootPath, indexFileRelativePath);
+    const indexDirectory = dirname(indexFileAbsolutePath);
+    if (!existsSync(indexDirectory)) {
+      console.error(logWarning(`Index directory '${indexDirectory}' does not exist - skipping`));
+      console.error(logWarning(`  Please verify the directory path in your configuration`));
+      continue;
+    }
+    const files = await generateBarrel(rootPath, directoryConfig);
+    const content = files.map((x) => `export * from './${x}';`).join("\n");
+    await writeFile(indexFileAbsolutePath, content);
+    console.log(
+      colorize(indexFileRelativePath, TerminalColor.CYAN),
+      colorize(`exports ${files.length} file${files.length > 1 ? "s" : ""}`, TerminalColor.GRAY)
+    );
+  }
+}
+async function generateBarrel(rootPath, directoryConfig) {
+  const ignore = [...directoryConfig.exclude, "**/index.ts", "**/index.js"];
+  const cwd = resolve(rootPath, directoryConfig.path);
+  let files = await glob(directoryConfig.include, { cwd, ignore, nodir: true, includeChildMatches: true });
+  files = files.map((file) => file.replace(/\\/g, "/"));
+  files = handleFileExtension(directoryConfig, files);
+  files = handleOrder(directoryConfig, files);
+  files = handlePathReplacement(directoryConfig, files);
+  return files;
+}
+function handleFileExtension(config, files) {
+  if (!config.keepFileExtension) {
+    return files.map((file) => file.replace(/\.ts$/, ""));
+  }
+  return files;
+}
+function handlePathReplacement(config, files) {
+  if (!config.replace?.length) {
+    return files;
+  }
+  for (let i = 0; i < config.replace.length; i++) {
+    const { find, replacement } = config.replace[i];
+    try {
+      const regexp = new RegExp(find);
+      files = files.map((file) => file.replace(regexp, replacement));
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        logError(
+          error.message.replace(
+            "Invalid regular expression:",
+            `Invalid regular expression number ${i + 1} in config.`
+          )
+        );
+      } else {
+        logWarning(`Invalid regular expression number ${i + 1}`);
+      }
+    }
+  }
+  return files;
+}
+function handleOrder(config, files) {
+  files = files.sort((a, b) => a.localeCompare(b));
+  if (!config.order?.length) {
+    return files;
+  }
+  return files.sort((a, b) => sortPathWeight(config.order, b) - sortPathWeight(config.order, a));
+}
+function sortPathWeight(order, path) {
+  const orderIndex = order.findIndex((x) => path.startsWith(x));
+  if (orderIndex >= 0) {
+    return (order.length - orderIndex) * 100 - path.split("/").length;
+  }
+  return -path.split("/").length;
+}
+var TerminalColor = /* @__PURE__ */ ((TerminalColor2) => {
+  TerminalColor2[TerminalColor2["BLACK"] = 0] = "BLACK";
+  TerminalColor2[TerminalColor2["RED"] = 1] = "RED";
+  TerminalColor2[TerminalColor2["GREEN"] = 2] = "GREEN";
+  TerminalColor2[TerminalColor2["YELLOW"] = 3] = "YELLOW";
+  TerminalColor2[TerminalColor2["BLUE"] = 4] = "BLUE";
+  TerminalColor2[TerminalColor2["MAGENTA"] = 5] = "MAGENTA";
+  TerminalColor2[TerminalColor2["CYAN"] = 6] = "CYAN";
+  TerminalColor2[TerminalColor2["WHITE"] = 7] = "WHITE";
+  TerminalColor2[TerminalColor2["GRAY"] = 60] = "GRAY";
+  return TerminalColor2;
+})(TerminalColor || {});
+function colorize(text, foreground, background) {
+  if (background == null) {
+    return `\x1B[${30 + foreground}m${text}\x1B[0m`;
+  }
+  return `\x1B[${30 + foreground}m\x1B[${40 + background}m${text}\x1B[0m`;
+}
+function logError(message) {
+  console.log(colorize(message, TerminalColor.RED));
+}
+function logWarning(message) {
+  console.log(colorize(message, TerminalColor.YELLOW));
+}
+function logInfo(message) {
+  console.log(colorize(message, TerminalColor.BLUE));
+}
+function logValidationError(message, validation) {
+  const formatError = (e) => {
+    const property = e.path.replace("$input.", "");
+    if (e.expected === "undefined") {
+      return `Property '${property}' is not allowed in configuration`;
+    }
+    if (e.value === void 0) {
+      return `Missing required property '${property}' in configuration`;
+    }
+    return `Invalid type for property '${property}'`;
+  };
+  const errors = validation.errors.map((x) => `  ` + formatError(x)).join("\n");
+  const text = `${message}:
+${errors}`;
+  logError(text);
+}
+export {
+  TerminalColor,
+  cliInit,
+  colorize,
+  generateBarrels,
+  logError,
+  logInfo,
+  logValidationError,
+  logWarning,
+  parseConfig,
+  runGenerateCommand,
+  runInitCommand,
+  validateConfig,
+  validateOutputConfig
+};

package/lib/src/cli/cli.d.ts

@@ -0,0 +1 @@
+export declare function cliInit(): void;

package/lib/src/cli/commands/generate-command-options.d.ts

@@ -0,0 +1,3 @@
+export type GenerateCommandOptions = {
+    configPath: string;
+};

package/lib/src/cli/commands/generate-command.d.ts

@@ -0,0 +1,2 @@
+import { GenerateCommandOptions } from '../../index.ts';
+export declare function runGenerateCommand(options: GenerateCommandOptions): Promise<void>;

package/lib/src/cli/commands/init-command.d.ts

@@ -0,0 +1 @@
+export declare function runInitCommand(baseConfigFilePath: string): Promise<void>;

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

@@ -0,0 +1,15 @@
+export type Config = {
+    directories: {
+        path: string;
+        include: string[];
+        exclude: string[];
+        order?: string[];
+        indexFilePath?: string;
+        keepFileExtension?: boolean;
+        replace?: {
+            find: string;
+            replacement: string;
+        }[];
+    }[];
+};
+export declare const validateConfig: ((input: unknown) => import('typia').IValidation<Config>) & import('@standard-schema/spec').StandardSchemaV1<unknown, Config>;

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

@@ -0,0 +1,8 @@
+export type OutputConfig = {
+    cwd: string;
+    directories: {
+        files: string[];
+        order?: string[];
+    }[];
+};
+export declare const validateOutputConfig: ((input: unknown) => import('typia').IValidation<OutputConfig>) & import('@standard-schema/spec').StandardSchemaV1<unknown, OutputConfig>;

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

@@ -0,0 +1,2 @@
+import { Config } from '../index.ts';
+export declare function parseConfig(configPath: string): Promise<Config | null>;

package/lib/src/generate/generate-barrels.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../index.ts';
+export declare function generateBarrels(rootPath: string, config: Config): Promise<void>;

package/lib/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from './cli/cli';
+export * from './cli/commands/generate-command';
+export * from './cli/commands/generate-command-options';
+export * from './cli/commands/init-command';
+export * from './config/config';
+export * from './config/output-config';
+export * from './config/parse-config';
+export * from './generate/generate-barrels';
+export * from './log/colorize';
+export * from './log/log';
+export * from './log/log-validation-error';

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

@@ -0,0 +1,12 @@
+export declare enum TerminalColor {
+    BLACK = 0,
+    RED = 1,
+    GREEN = 2,
+    YELLOW = 3,
+    BLUE = 4,
+    MAGENTA = 5,
+    CYAN = 6,
+    WHITE = 7,
+    GRAY = 60
+}
+export declare function colorize(text: string, foreground: TerminalColor, background?: TerminalColor): string;

package/lib/src/log/log-validation-error.d.ts

@@ -0,0 +1,2 @@
+import { IValidation } from 'typia';
+export declare function logValidationError(message: string, validation: IValidation.IFailure): void;

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

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

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "barrelize",
+  "version": "1.0.0",
+  "description": "Automatically generating index (barrel) files",
+  "scripts": {
+    "build": "vite build",
+    "prepare": "ts-patch install",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com/nizami/barrelize"
+  },
+  "keywords": [
+    "barrels",
+    "typescript",
+    "index",
+    "file"
+  ],
+  "author": "Nizami",
+  "license": "MIT",
+  "dependencies": {
+    "cac": "^6.7.14",
+    "glob": "^11.0.2",
+    "json5": "^2.2.3"
+  },
+  "devDependencies": {
+    "@ryoppippi/unplugin-typia": "^2.2.1",
+    "@types/node": "^22.15.17",
+    "ts-patch": "^3.3.0",
+    "typescript": "~5.8.3",
+    "typia": "^9.2.0",
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.3",
+    "vitest": "^3.1.3"
+  },
+  "bin": {
+    "barrelize": "./bin/cli.js"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/src/index.d.ts",
+      "import": "./lib/index.js"
+    }
+  }
+}