@ts-ioc-container/bundler 0.2.0 → 1.1.0

package/README.md

@@ -56,9 +56,32 @@ below use the shortcut.
 | `bundles[].namespaces`       | —                                         | Folders to scan; `{ path, recursive }` to stop at the folder itself                          |
 | `bundles[].select`           | every exported class                      | Which classes of a file are registered — see [Selecting classes](#selecting-classes)          |
 | `bundles[].exclude`          | test files, `__tests__/`, `node_modules/` | Globs (relative to the config) never scanned; replaces the default                           |
+| `bundles[].additionalExclude`| —                                         | Globs never scanned, added on top of `exclude` (or the defaults) — see [Excluding files](#excluding-files) |
 | `bundles[].filterExports`    | `tic.exports.*` next to the config        | File exporting an `ExportPredicate` — see [Filtering classes](#filtering-classes-after-parsing) |
 | `bundles[].include`          | `tic.include.*` next to the config        | File exporting an `InclusionPredicate` — see [Including files](#including-files-with-a-predicate) |
 
+## Excluding files
+
+By default test files, `__tests__/` and `node_modules/` are never scanned. To
+add one exclusion without restating those defaults, use `additionalExclude`:
+
+```json
+{
+  "bundles": [
+    {
+      "output": "src/di/app.bundle.ts",
+      "namespaces": ["@app/services"],
+      "additionalExclude": ["frontend/api/generated/**", "**/Mock*.ts"]
+    }
+  ]
+}
+```
+
+A non-empty `exclude` replaces the defaults; if it omits a default glob the
+build warns, since test classes usually carry the same `@register` decorators as
+production ones. `exclude: []` deliberately scans everything, including tests —
+combine it with `include` when only some tests should join.
+
 ## Selecting classes
 
 By default every exported, non-abstract class of a scanned file is registered.

package/cjm/build.js

@@ -38,7 +38,7 @@ function build({ config = config_1.DEFAULT_CONFIG_FILE, cwd = process.cwd(), che
         }
         return { file: bundle.output, bundle: bundle.name, status, registrations, content };
     });
-    return { config: resolved.file, outputs };
+    return { config: resolved.file, outputs, warnings: resolved.warnings };
 }
 function predicateResolver({ override, conventional, fileOf, load, }) {
     const loaded = new Map();

package/cjm/cli.js

@@ -62,7 +62,9 @@ function run(argv, io = { cwd: process.cwd(), stdout: console.log, stderr: conso
             return 1;
         }
         const { config, check } = parseBuildArgs(rest);
-        const { outputs } = (0, build_1.build)({ config, check, cwd: io.cwd });
+        const { outputs, warnings } = (0, build_1.build)({ config, check, cwd: io.cwd });
+        for (const warning of warnings)
+            io.stderr(`tic: warning: ${warning}`);
         for (const { status, file, registrations } of outputs) {
             io.stdout(`${VERB[status].padEnd(10)}${node_path_1.default.relative(io.cwd, file)} (${plural(registrations)})`);
         }

package/cjm/config.js

@@ -61,7 +61,7 @@ function toSelector(value, field) {
 function toBundle(value, field, dir) {
     if (!isObject(value))
         return fail(field, 'an object');
-    const { output, name, namespaces, select, exclude, include, filterExports } = value;
+    const { output, name, namespaces, select, exclude, additionalExclude, include, filterExports } = value;
     if (!isNonEmptyString(output))
         return fail(`${field}.output`, 'a non-empty string');
     if (name !== undefined && !isIdentifier(name))
@@ -70,6 +70,9 @@ function toBundle(value, field, dir) {
         return fail(`${field}.namespaces`, 'a non-empty array');
     if (exclude !== undefined && !isStringArray(exclude))
         return fail(`${field}.exclude`, 'an array of strings');
+    if (additionalExclude !== undefined && !isStringArray(additionalExclude)) {
+        return fail(`${field}.additionalExclude`, 'an array of strings');
+    }
     if (include !== undefined && !isNonEmptyString(include))
         return fail(`${field}.include`, 'a non-empty string');
     if (filterExports !== undefined && !isNonEmptyString(filterExports)) {
@@ -80,11 +83,25 @@ function toBundle(value, field, dir) {
         name: name ?? exports.DEFAULT_BUNDLE_NAME,
         namespaces: namespaces.map((ns, i) => toNamespace(ns, `${field}.namespaces[${i}]`)),
         select: toSelector(select, `${field}.select`),
-        exclude: exclude ?? exports.DEFAULT_EXCLUDE,
+        exclude: [...(exclude ?? exports.DEFAULT_EXCLUDE), ...(additionalExclude ?? [])],
         include: include === undefined ? undefined : node_path_1.default.resolve(dir, include),
         filterExports: filterExports === undefined ? undefined : node_path_1.default.resolve(dir, filterExports),
     };
 }
+function excludeWarnings(value, field) {
+    if (!isObject(value))
+        return [];
+    const exclude = value.exclude;
+    if (!isStringArray(exclude) || exclude.length === 0)
+        return [];
+    const missing = exports.DEFAULT_EXCLUDE.filter((glob) => !exclude.includes(glob));
+    if (missing.length === 0)
+        return [];
+    return [
+        `${field}.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
+            `add them back or use ${field}.additionalExclude`,
+    ];
+}
 function resolveConfig(content, file) {
     const dir = node_path_1.default.dirname(file);
     if (!isObject(content))
@@ -102,6 +119,7 @@ function resolveConfig(content, file) {
         tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? 'tsconfig.json'), required: tsconfig !== undefined },
         importExtension,
         bundles: bundles.map((m, i) => toBundle(m, `bundles[${i}]`, dir)),
+        warnings: bundles.flatMap((m, i) => excludeWarnings(m, `bundles[${i}]`)),
     };
 }
 function loadConfig(file) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-ioc-container/bundler",
-  "version": "0.2.0",
+  "version": "1.1.0",
   "description": "Bundles your dependencies into a single container module for ts-ioc-container: the `tic` CLI scans folders (by path or tsconfig alias) and generates one typed bundle that registers every class — `container.useModule(new AppBundle())`.",
   "publishConfig": {
     "access": "public",
@@ -61,7 +61,7 @@
     "typescript": "5.8.3",
     "unplugin-swc": "^1.6.0",
     "vitest": "^4.1.11",
-    "ts-ioc-container": "72.3.2"
+    "ts-ioc-container": "73.0.0"
   },
   "engines": {
     "node": ">= 18"

package/tic.schema.json

@@ -115,7 +115,14 @@
               "**/__tests__/**",
               "**/node_modules/**"
             ],
-            "description": "Globs, relative to this file, of files never scanned. Replaces the default when given."
+            "description": "Globs, relative to this file, of files never scanned. Replaces the default when given; prefer additionalExclude to add one exclusion without restating the defaults. A non-empty list that omits a default glob makes `tic build` warn."
+          },
+          "additionalExclude": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Globs, relative to this file, of files never scanned, added on top of `exclude` (or the default excludes when `exclude` is omitted)."
           },
           "include": {
             "type": "string",

package/typings/build.d.ts

@@ -27,6 +27,8 @@ export interface BuildResult {
     /** Absolute path of the config that was built. */
     config: string;
     outputs: OutputResult[];
+    /** Non-fatal problems found while resolving the config, e.g. an `exclude` that drops a default test glob. */
+    warnings: string[];
 }
 /**
  * Generates one bundle per config entry. Every bundle is generated before any

package/typings/config.d.ts

@@ -35,6 +35,12 @@ export interface BundleConfig {
     select?: ClassSelector;
     /** Globs, relative to the config file, of files never scanned. Replaces {@link DEFAULT_EXCLUDE} when given. */
     exclude?: string[];
+    /**
+     * Globs, relative to the config file, of files never scanned, added on top of
+     * `exclude` (or {@link DEFAULT_EXCLUDE} when `exclude` is omitted). Use this to
+     * add one exclusion without restating the defaults.
+     */
+    additionalExclude?: string[];
     /**
      * A file exporting an `InclusionPredicate`, relative to the config file. Overrides the
      * conventional `tic.include.*` next to the config.
@@ -68,12 +74,15 @@ export interface ResolvedConfig {
     };
     importExtension?: string;
     bundles: ResolvedBundle[];
+    /** Non-fatal problems found while resolving, e.g. an `exclude` that drops a default test glob. */
+    warnings: string[];
 }
 export interface ResolvedBundle {
     output: string;
     name: string;
     namespaces: Required<NamespaceConfig>[];
     select: ResolvedSelector;
+    /** The effective list: the configured `exclude` (or the defaults) followed by `additionalExclude`. */
     exclude: string[];
     /** Absolute path of the bundle's own predicate file, when it names one. */
     include?: string;