@ts-ioc-container/bundler 6.0.0 → 8.0.0

package/AGENTS.md

@@ -7,10 +7,11 @@ nothing here runs inside the container, and the core package is not changed by
 it.
 
 - The CLI is `ts-ioc-container`, with `tic` as a shortcut (both `bin` entries,
-  same program): `tic build [<config>]` is a Unix filter. It reads the config
-  file `<config>` (JSON for `.json`, YAML for `.yaml` / `.yml`) — or, without
-  one or with `-`, config text from stdin (parsed as YAML, which covers JSON) —
-  and prints the bundle to **stdout**; it writes nothing. Saving is the shell's
+  same program): `tic build [<config>...]` is a Unix filter. It reads the config
+  file `<config>` (JSON for `.json`, YAML for `.yaml` / `.yml`) — several are
+  merged left to right into one bundle — or, without one or with `-`, config
+  text from stdin (parsed as YAML, which covers JSON; never merged) — and
+  prints the bundle to **stdout**; it writes nothing. Saving is the shell's
   job: `tic build app.bundle.json > src/di/app.bundle.ts`,
   `cat dev.bundle.json | tic build > src/di/dev.bundle.ts`; CI checks with
   `tic build app.bundle.json | diff - src/di/app.bundle.ts`. Warnings and errors
@@ -20,7 +21,7 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   bundle works wherever it is saved; a selected class no alias covers fails the
   build naming its file. There are no relative imports.
 - Config fields (schema: `tic.schema.json`), flat: `paths` with `paths.include`
-  required; `className`, `name`, `tsconfig`, `importExtension` optional.
+  required; `match`, `name`, `tsconfig`, `importExtension` optional.
   Relative paths resolve against the config file; for piped text, against the
   working directory. `name` defaults to the file's stem (`prod.bundle.json` →
   `prod`) and is required for piped text or a file named otherwise; the class
@@ -31,9 +32,9 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   name and generated imports are written in (most specific alias, else a
   relative path) — and the module resolution that sets the import extension.
 - Selection has two stages, `paths: { include, exclude }` and
-  `className: { ..., glob, exclude }`. `paths` is always an object (a string
-  or a list in its place is an error); `className` also takes a string or a
-  list as a shortcut for `className.glob`. `paths` decides by path which files
+  `match: { ..., glob, exclude }`. `paths` is always an object (a string
+  or a list in its place is an error); `match` also takes a string or a
+  list as a shortcut for `match.glob`. `paths` decides by path which files
   are read and parsed at all. `paths.include` (required: one folder or a
   non-empty list) names the folders scanned, always with their sub-folders —
   relative to the config file (`./src/services`) or tsconfig aliases
@@ -43,8 +44,8 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   catch-all `"*"` aliases are skipped; default: test files, `__tests__/`,
   `node_modules/`; a non-empty value replaces it, and the build warns if it drops
   a default). Files `tic build` generated are never input.
-- `className: { export, decorators, glob, exclude }` (or `className: '*Service'`
-  / `['*Service', '*Repository']` = `className.glob`, default `export` and
+- `match: { export, decorators, glob, exclude }` (or `match: '*Service'`
+  / `['*Service', '*Repository']` = `match.glob`, default `export` and
   `decorators`) then picks classes of the parsed files; default is every exported,
   non-abstract class decorated with `@register` (`decorators` defaults to
   `["register"]`; `[]` requires none); positive criteria must all hold — `glob` is one glob
@@ -54,12 +55,23 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   two selected classes pass the same plain-identifier first decorator argument (a
   same-token heuristic), unless a decorator they share has differing arguments
   (scope-gated, e.g. `@perPage('a')` vs `@perPage('b')`).
+- Several configs merge like webpack-merge (`mergeConfigs`):
+  `tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts`.
+  Objects merge field by field; the list fields `paths.include`,
+  `paths.exclude`, `match.glob`, `match.exclude` and `match.decorators`
+  concatenate without duplicates (a later config only adds); any other value
+  set later replaces an earlier one; the `match` shorthand merges as
+  `match.glob`. Each file is validated alone (`BUNDLE_CONFIG_FILE_SCHEMA`:
+  `paths` optional; errors name the file), the merged result as one config
+  (`BUNDLE_CONFIG_SCHEMA`). Defaults apply to the merged config only. The last
+  file names the bundle unless one sets `name`; all must sit in one folder.
 - Never edit a `*.bundle.ts` by hand — change the classes or the config and
   rerun `tic build`.
 - Unknown config fields are errors, at every level.
-- Programmatic API: `build({ config, cwd })` or `build({ text, cwd })` returns
+- Programmatic API: `build({ config, cwd })` (`config`: a file or a list merged
+  left to right) or `build({ text, cwd })` returns
   `{ content, bundle, registrations, warnings }` and writes nothing;
-  `loadConfig(file)`, `run(argv, io)` (`io.stdin` backs piped configs); every error the
+  `loadConfig(file | files)`, `run(argv, io)` (`io.stdin` backs piped configs); every error the
   bundler raises on purpose is a `TicError` with a stable `code`
   (`TicConfigError` = `INVALID_CONFIG`, `NamespaceNotFoundError`, `UsageError`,
   …).
@@ -69,7 +81,8 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   `@onDefault(invoke)` action (a word in the action position that names no
   declared action is the default action's argument: `tic build <config>`), which parses its own options with
   `@inject(pipe(commandArgs, parseOptions(spec), validate(SCHEMA)))`. Work lives in
-  services behind tokens (`IBundleBuilderKey`, `ITicConfigServiceKey`, …); pure
-  logic in `lib/features/build/domain/`. A new command is a controller plus a module.
+  services behind tokens (`IBundleServiceKey`, `ITicConfigServiceKey`, …); pure
+  logic in `lib/features/bundle/domain/`. A new command is a controller plus a module.
 - The config schema is `BUNDLE_CONFIG_SCHEMA` (zod); `tic.schema.json` is generated
-  from it with `pnpm run generate:schema` — never edit it by hand.
+  from its per-file variant `BUNDLE_CONFIG_FILE_SCHEMA` with `pnpm run generate:schema`
+  — never edit it by hand.

package/README.md

@@ -33,11 +33,12 @@ below use the shortcut.
 ## Build
 
 ```bash
-tic build [<config>]
+tic build [<config>...]
 ```
 
 `tic build` prints the bundle to **stdout** and writes nothing. `<config>` is a
-config file — JSON for `.json`, YAML for `.yaml` / `.yml`. Without it (or with
+config file — JSON for `.json`, YAML for `.yaml` / `.yml`. Several are
+[merged](#merging-configs) left to right into one bundle. Without one (or with
 `-`) the config is read from **stdin**. Warnings and errors go to stderr, so
 they never end up in the bundle.
 
@@ -46,6 +47,9 @@ they never end up in the bundle.
 tic build app.bundle.json > src/di/app.bundle.ts
 tic build prod.bundle.yml > src/di/prod.bundle.ts
 
+# several configs merged into one bundle, like webpack-merge
+tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts
+
 # the config piped in — it has no file name, so it sets `name` ("name": "dev")
 cat dev.bundle.json | tic build > src/di/dev.bundle.ts
 tic build < dev.bundle.yml > src/di/dev.bundle.ts
@@ -69,8 +73,9 @@ covers is an error naming its file; add a `paths` entry for its folder.
 
 Relative paths in a config file resolve against the file; in a piped config,
 against the working directory. The bundle is named after the config file —
-`prod.bundle.json` exports `ProdBundle` — unless the config sets `name`, which a
-piped config, or a file not named `<name>.bundle.json`, must.
+`prod.bundle.json` exports `ProdBundle`; of several merged, after the last —
+unless the config sets `name`, which a piped config, or a file not named
+`<name>.bundle.json`, must.
 
 ## Configure
 
@@ -94,8 +99,8 @@ paths:
 
 | Field             | Default                                       | Meaning                                                                                                     |
 | ----------------- | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `paths`           | — (required)                                  | Which files are parsed — see [Selecting files](#selecting-files)                                            |
-| `className`       | exported classes with `@register`             | Which classes of a parsed file are registered — see [Selecting classes](#selecting-classes)                 |
+| `paths`           | — (required)                                  | Which files are parsed — see [Selecting files](#selecting-files). Merged configs need it in one of them     |
+| `match`           | exported classes with `@register`             | Which classes of a parsed file are registered — see [Selecting classes](#selecting-classes)                 |
 | `name`            | the config file's (`app.bundle.json` → `app`) | The bundle's name: names the class, `AppBundle`. Required for a piped config or a file named otherwise      |
 | `tsconfig`        | `./tsconfig.json`                             | Source of the `paths` aliases every import is written through, and of the import extension — never of files |
 | `importExtension` | `.js` under node16/nodenext, else none        | Extension of generated imports                                                                              |
@@ -105,31 +110,37 @@ unnoticed.
 
 ## Several bundles
 
-Need more than one bundle — per environment, per app? Keep a config per bundle
-and build each one:
+Need more than one bundle — per environment, per app? Keep what they share in
+one config, what each adds in another, and build each environment from both:
 
 ```bash
 for env in prod dev test; do
-  tic build "$env.bundle.yml" > "src/di/$env.bundle.ts"
+  tic build common.bundle.yml "$env.bundle.yml" > "src/di/$env.bundle.ts"
 done
 ```
 
 ```json
 {
   "scripts": {
-    "bundle": "tic build app.bundle.json > src/di/app.bundle.ts",
-    "bundle:check": "tic build app.bundle.json | diff - src/di/app.bundle.ts"
+    "bundle": "tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts",
+    "bundle:check": "tic build common.bundle.yml prod.bundle.yml | diff - src/di/prod.bundle.ts"
   }
 }
 ```
 
-Each config selects its own files and classes:
-
 ```yaml
-# prod.bundle.yml: services + adapters, minus dev-only *.dev.ts files
+# common.bundle.yml: what every environment registers
 paths:
   include:
     - '@app/services'
+```
+
+Each environment's config adds its own files and classes:
+
+```yaml
+# prod.bundle.yml: + the adapters, minus dev-only *.dev.ts files
+paths:
+  include:
     - ./src/infra
   exclude:
     - '**/*.dev.ts'
@@ -142,15 +153,39 @@ paths:
 ```
 
 ```yaml
-# dev.bundle.yml: the *.dev.ts logger replaces the production one, dropped by class name
+# dev.bundle.yml: + the adapters; the *.dev.ts logger replaces the production one, dropped by class name
 paths:
   include:
-    - '@app/services'
     - ./src/infra
-className:
+match:
   exclude: JsonLogger
 ```
 
+`tic build common.bundle.yml prod.bundle.yml` then scans `@app/services` and
+`./src/infra`, and exports `ProdBundle`.
+
+### Merging configs
+
+`tic build a.bundle.yml b.bundle.yml c.bundle.yml` merges the configs left to
+right, the way webpack-merge merges webpack configs:
+
+- objects merge field by field;
+- list fields — `paths.include`, `paths.exclude`, `match.glob`, `match.exclude`,
+  `match.decorators` — concatenate in order, without duplicates (one folder or
+  glob counts as a list of one), so a later config can only add to them;
+- any other value (`name`, `tsconfig`, `importExtension`, `match.export`) set
+  by a later config replaces an earlier one;
+- the `match` shorthand merges as `match.glob`.
+
+Each config is validated on its own — an error names the file it is in — so a
+shared config may leave `paths` out; the merged config must have
+`paths.include`. Defaults apply to the merged config only: a `paths.exclude` in
+any of them replaces the default excludes, as it does in a single config, so
+list the defaults in the shared config to keep them. The bundle is named after
+the last config, unless one sets `name` — so leave `name` out of a shared
+config. Merged configs must sit in one folder, which their relative paths
+resolve against. A piped config (`-`) is never merged.
+
 A saved bundle is never registered by another build, even when it sits in a
 folder that build scans.
 
@@ -160,7 +195,7 @@ A bundle picks its registrations in two stages:
 
 1. **`paths`** — decided by path alone, before anything is read. Only files that
    pass are parsed.
-2. **`className`** — decided per class, on the files stage 1 let through.
+2. **`match`** — decided per class, on the files stage 1 let through.
 
 Parsing is where the time goes, so point `paths` at the folders that hold your
 registrations, and `exclude` what they should not contribute:
@@ -171,7 +206,7 @@ registrations, and `exclude` what they should not contribute:
     "include": "@app/services",
     "exclude": ["**/*.spec.ts", "**/*.test.ts", "**/__tests__/**", "**/node_modules/**", "**/legacy/**"]
   },
-  "className": { "decorators": ["register"] }
+  "match": { "decorators": ["register"] }
 }
 ```
 
@@ -233,11 +268,11 @@ parses everything, including tests.
 ## Selecting classes
 
 By default every exported, non-abstract class of a parsed file that carries
-`@register` is registered. `className` changes that; a class must meet every
+`@register` is registered. `match` changes that; a class must meet every
 criterion that is set:
 
 ```json
-"className": {
+"match": {
   "export": "named",
   "decorators": ["register", "repository"],
   "glob": "*Service"
@@ -261,7 +296,7 @@ bind the same token, registration is last-wins and the stand-in silently wins.
 matches only itself, so one list drops a class by name and a family by pattern:
 
 ```json
-"className": {
+"match": {
   "decorators": ["repository", "service"],
   "exclude": ["MockDashboardRepository", "*Fake"]
 }
@@ -270,18 +305,18 @@ matches only itself, so one list drops a class by name and a family by pattern:
 `exclude` applies after every other criterion, so it combines with
 `decorators` and `glob` freely.
 
-### The `className` shortcut
+### The `match` shortcut
 
-When the default `export` and `decorators` are all you need, `className`
+When the default `export` and `decorators` are all you need, `match`
 itself can be the class-name globs — a string or a list is a shortcut for
-`className.glob`:
+`match.glob`:
 
 ```yaml
-className: '*Service' # = className: { glob: '*Service' }
+match: '*Service' # = match: { glob: '*Service' }
 ```
 
 ```yaml
-className: ['*Service', '*Repository'] # = className: { glob: ['*Service', '*Repository'] }
+match: ['*Service', '*Repository'] # = match: { glob: ['*Service', '*Repository'] }
 ```
 
 As a safety net, the build warns when two selected classes pass the same
@@ -292,7 +327,7 @@ are not resolved), so it can only be a heuristic:
 ```text
 tic: warning: app.bundle.json: decorator token "IDashboardRepositoryToken" is passed by
 HttpDashboardRepository, MockDashboardRepository; registration is last-wins,
-exclude one with className.exclude
+exclude one with match.exclude
 ```
 
 Classes that are scope-gated are not last-wins, so they do not warn: when the

package/cjm/app.js

@@ -1,16 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createContainer = createContainer;
 exports.run = run;
 exports.build = build;
 exports.loadConfig = loadConfig;
 require("reflect-metadata");
+const node_path_1 = __importDefault(require("node:path"));
 const ts_ioc_container_1 = require("ts-ioc-container");
 const Application_1 = require("./cli/Application");
 const CliIo_1 = require("./domain/CliIo");
-const BuildModule_1 = require("./features/build/BuildModule");
-const TicConfigService_1 = require("./features/build/services/TicConfigService");
-const BundleBuilder_1 = require("./features/build/services/BundleBuilder");
+const BuildModule_1 = require("./features/bundle/BuildModule");
+const TicConfigService_1 = require("./features/bundle/services/TicConfigService");
+const BundleService_1 = require("./features/bundle/services/BundleService");
 const HelpModule_1 = require("./features/help/HelpModule");
 const CommonModule_1 = require("./modules/CommonModule");
 function createContainer(io = (0, CliIo_1.processIo)()) {
@@ -32,8 +36,14 @@ function run(argv, io = (0, CliIo_1.processIo)()) {
     return Application_1.Application.bootstrap(createContainer(io)).run(...argv);
 }
 function build({ cwd = process.cwd(), ...request }) {
-    return withContainer({ ...(0, CliIo_1.processIo)(), cwd }, (container) => BundleBuilder_1.IBundleBuilderKey.resolve(container).build(request));
+    return withContainer({ ...(0, CliIo_1.processIo)(), cwd }, (container) => {
+        const configService = TicConfigService_1.ITicConfigServiceKey.resolve(container);
+        const config = 'text' in request
+            ? configService.parse(request.text, cwd)
+            : configService.load([request.config].flat().map((file) => node_path_1.default.resolve(cwd, file)));
+        return BundleService_1.IBundleServiceKey.resolve(container).bundle(config);
+    });
 }
-function loadConfig(file) {
-    return withContainer((0, CliIo_1.processIo)(), (container) => TicConfigService_1.ITicConfigServiceKey.resolve(container).load(file));
+function loadConfig(files) {
+    return withContainer((0, CliIo_1.processIo)(), (container) => TicConfigService_1.ITicConfigServiceKey.resolve(container).load(files));
 }

package/cjm/cli/usage.js

@@ -6,17 +6,20 @@ exports.USAGE = [
     '       tic is a shortcut for ts-ioc-container',
     '',
     'Commands:',
-    '  ts-ioc-container build [<config>]   print the bundle a config file (.json, .yaml, .yml) describes;',
-    '                                     without one (or with -), read the config from stdin',
-    '  ts-ioc-container help               show this help',
-    '  ts-ioc-container version            show the version',
+    '  ts-ioc-container build [<config>...]   print the bundle a config file (.json, .yaml, .yml) describes;',
+    '                                        several are merged left to right into one bundle;',
+    '                                        without one (or with -), read the config from stdin',
+    '  ts-ioc-container help                  show this help',
+    '  ts-ioc-container version               show the version',
     '',
     'Options:',
     '  -h, --help      show this help',
     '  -v, --version   show the version',
     '',
-    'The bundle goes to stdout and warnings to stderr; saving it is up to you:',
+    'The bundle goes to stdout; the files in it and warnings to stderr.',
+    'Saving it is up to you:',
     '  tic build app.bundle.json > src/di/app.bundle.ts',
+    '  tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts   # merged left to right',
     '  cat app.bundle.yml | tic build > src/di/app.bundle.ts     # config from stdin (must set name)',
     '  tic build app.bundle.json | diff - src/di/app.bundle.ts   # CI: is it current?',
 ].join('\n');

package/cjm/features/{build → bundle}/BuildConfig.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configFormat = exports.STDIN = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_TSCONFIG = void 0;
+exports.configFormat = exports.STDIN = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_FILE_SCHEMA = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_TSCONFIG = void 0;
 exports.parseConfig = parseConfig;
 exports.toClassName = toClassName;
+exports.mergeConfigs = mergeConfigs;
 exports.resolveConfig = resolveConfig;
 const node_path_1 = __importDefault(require("node:path"));
 const yaml_1 = require("yaml");
@@ -42,6 +43,7 @@ const globs = () => globList('a glob or a non-empty array of globs', 1);
 const toList = (value) => (Array.isArray(value) ? value : [value]);
 const toGlobs = (value) => value === undefined ? undefined : toList(value).map(glob_1.globToRegExp);
 const FOLDERS_SCHEMA = zod_1.z.array(nonEmptyString(), expected('a non-empty array')).min(1, expected('a non-empty array'));
+const PATHS_DESCRIPTION = 'Which files this bundle reads and parses — decided by path alone, before parsing. `include` names the folders the files come from; within them a file is parsed unless it matches one of `exclude`. Globs are relative to the config file.';
 const PATHS_SCHEMA = zod_1.z
     .strictObject({
     include: zod_1.z
@@ -51,7 +53,7 @@ const PATHS_SCHEMA = zod_1.z
         .default(exports.DEFAULT_EXCLUDE)
         .describe('Glob, or globs, of files never read, relative to the config file or starting with a tsconfig paths alias (@generated/**, or @generated for the whole folder). Replaces the default when given. A non-empty value that omits a default glob makes `tic build` warn.'),
 }, expected('an object with "include"'))
-    .describe('Which files this bundle reads and parses — decided by path alone, before parsing. `include` names the folders the files come from; within them a file is parsed unless it matches one of `exclude`. Globs are relative to the config file.');
+    .describe(PATHS_DESCRIPTION);
 const CLASS_OBJECT_SCHEMA = zod_1.z.strictObject({
     export: zod_1.z
         .enum(['any', 'named', 'default'], expected('"any", "named" or "default"'))
@@ -93,8 +95,11 @@ exports.BUNDLE_CONFIG_SCHEMA = zod_1.z.strictObject({
         .optional()
         .describe('Extension of generated imports, e.g. ".js". Inferred from the tsconfig: ".js" under node16/nodenext resolution, none otherwise.'),
     paths: PATHS_SCHEMA,
-    className: CLASSES_SCHEMA.optional(),
+    match: CLASSES_SCHEMA.optional(),
 }, expected('an object'));
+exports.BUNDLE_CONFIG_FILE_SCHEMA = exports.BUNDLE_CONFIG_SCHEMA.extend({
+    paths: PATHS_SCHEMA.partial().optional().describe(`${PATHS_DESCRIPTION} Required in the merged config.`),
+});
 function formatPath(segments) {
     const formatted = segments
         .map((segment) => (typeof segment === 'number' ? `[${segment}]` : `.${String(segment)}`))
@@ -122,13 +127,13 @@ function toPathSelector(paths) {
         exclude: toList(paths.exclude),
     };
 }
-function toClassSelector(className) {
-    if (className === undefined)
+function toClassSelector(match) {
+    if (match === undefined)
         return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
-    if (typeof className === 'string' || Array.isArray(className)) {
-        return { export: 'any', decorators: exports.DEFAULT_DECORATORS, glob: toGlobs(className) };
+    if (typeof match === 'string' || Array.isArray(match)) {
+        return { export: 'any', decorators: exports.DEFAULT_DECORATORS, glob: toGlobs(match) };
     }
-    const { decorators, glob, exclude, ...rest } = className;
+    const { decorators, glob, exclude, ...rest } = match;
     return {
         ...rest,
         decorators: decorators.length > 0 ? decorators : undefined,
@@ -170,11 +175,38 @@ function toClassName(name) {
     const words = name.split(/[-_]+/).filter(Boolean);
     return `${words.map((word) => word[0].toUpperCase() + word.slice(1)).join('')}Bundle`;
 }
+const LIST_FIELDS = new Set(['paths.include', 'paths.exclude', 'match.decorators', 'match.glob', 'match.exclude']);
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function mergeInto(base, next, at = '') {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(next)) {
+        const field = `${at}${key}`;
+        const previous = merged[key];
+        if (LIST_FIELDS.has(field)) {
+            merged[key] = [
+                ...new Set([...toList((previous ?? [])), ...toList(value)]),
+            ];
+        }
+        else {
+            merged[key] = isObject(previous) && isObject(value) ? mergeInto(previous, value, `${field}.`) : value;
+        }
+    }
+    return merged;
+}
+const expandMatch = ({ match, ...rest }) => match === undefined ? rest : { ...rest, match: isObject(match) ? match : { glob: match } };
+function mergeConfigs(configs) {
+    return configs.reduce((merged, { file, content }) => {
+        const result = exports.BUNDLE_CONFIG_FILE_SCHEMA.safeParse(content);
+        if (!result.success)
+            throw new DomainException_1.TicConfigError(`${node_path_1.default.basename(file)}: ${formatIssues(result.error)}`);
+        return mergeInto(merged, expandMatch(content));
+    }, {});
+}
 function resolveConfig(content, file) {
     const result = exports.BUNDLE_CONFIG_SCHEMA.safeParse(content);
     if (!result.success)
         throw new DomainException_1.TicConfigError(formatIssues(result.error));
-    const { name, tsconfig, importExtension, paths, className } = result.data;
+    const { name, tsconfig, importExtension, paths, match } = result.data;
     const bundleName = name ?? configStem(file);
     if (bundleName === undefined) {
         throw new DomainException_1.TicConfigError(node_path_1.default.basename(file) === exports.STDIN
@@ -190,7 +222,7 @@ function resolveConfig(content, file) {
         tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_TSCONFIG), required: tsconfig !== undefined },
         importExtension,
         paths: toPathSelector(paths),
-        className: toClassSelector(className),
+        match: toClassSelector(match),
         warnings: excludeWarnings(paths),
     };
 }

package/cjm/features/{build → bundle}/BuildModule.js

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuildModule = void 0;
 const ts_ioc_container_1 = require("ts-ioc-container");
-const BuildController_1 = require("./BuildController");
-const BundleBuilder_1 = require("./services/BundleBuilder");
+const BundleController_1 = require("./BundleController");
+const BundleService_1 = require("./services/BundleService");
+const BundleView_1 = require("./services/BundleView");
 const TicConfigService_1 = require("./services/TicConfigService");
 class BuildModule {
     applyTo(container) {
         container
-            .addRegistration(ts_ioc_container_1.Registration.fromClass(BuildController_1.BuildController))
-            .addRegistration(ts_ioc_container_1.Registration.fromClass(BundleBuilder_1.BundleBuilder))
+            .addRegistration(ts_ioc_container_1.Registration.fromClass(BundleController_1.BundleController))
+            .addRegistration(ts_ioc_container_1.Registration.fromClass(BundleService_1.BundleService))
+            .addRegistration(ts_ioc_container_1.Registration.fromClass(BundleView_1.BundleView))
             .addRegistration(ts_ioc_container_1.Registration.fromClass(TicConfigService_1.TicConfigService));
     }
 }

package/cjm/features/{build/BuildController.js → bundle/BundleController.js}

@@ -11,8 +11,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildController = exports.BUILD_OPTIONS = void 0;
+exports.BundleController = exports.BUILD_OPTIONS = void 0;
+const node_path_1 = __importDefault(require("node:path"));
 const ts_ioc_container_1 = require("ts-ioc-container");
 const zod_1 = require("zod");
 const cli_1 = require("../../cli");
@@ -21,30 +25,44 @@ const DomainException_1 = require("../../exceptions/DomainException");
 const ConsoleLogger_1 = require("../../services/ConsoleLogger");
 const OutputService_1 = require("../../services/OutputService");
 const BuildConfig_1 = require("./BuildConfig");
-const BundleBuilder_1 = require("./services/BundleBuilder");
+const glob_1 = require("./domain/glob");
+const BundleService_1 = require("./services/BundleService");
+const TicConfigService_1 = require("./services/TicConfigService");
 exports.BUILD_OPTIONS = zod_1.z.object({ positionals: zod_1.z.array(zod_1.z.string().min(1)) }).transform(({ positionals }, ctx) => {
-    if (positionals.length > 1) {
-        ctx.addIssue({ code: 'custom', path: ['config'], message: `expected one <config>, got ${positionals.join(' ')}` });
+    if (positionals.length > 1 && positionals.includes(BuildConfig_1.STDIN)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['config'],
+            message: `${BuildConfig_1.STDIN} reads one config from stdin and cannot be merged with config files`,
+        });
         return zod_1.z.NEVER;
     }
-    return { config: positionals[0] ?? BuildConfig_1.STDIN };
+    return { configs: positionals.length > 0 ? positionals : [BuildConfig_1.STDIN] };
 });
 const buildArgs = (0, cli_1.parseOptions)({}, { positionals: true });
-let BuildController = class BuildController {
+let BundleController = class BundleController {
     io;
-    builder;
+    configService;
+    bundleService;
     output;
     logger;
-    constructor(io, builder, output, logger) {
+    constructor(io, configService, bundleService, output, logger) {
         this.io = io;
-        this.builder = builder;
+        this.configService = configService;
+        this.bundleService = bundleService;
         this.output = output;
         this.logger = logger;
     }
-    build({ config }) {
-        const label = config === BuildConfig_1.STDIN ? '<stdin>' : config;
+    bundle({ configs }) {
+        const stdin = configs[0] === BuildConfig_1.STDIN;
+        const label = stdin ? '<stdin>' : configs.join(' + ');
         try {
-            const { content, warnings } = this.builder.build(config === BuildConfig_1.STDIN ? { text: this.stdin() } : { config });
+            const config = stdin
+                ? this.configService.parse(this.stdin(), this.io.cwd)
+                : this.configService.load(configs.map((file) => node_path_1.default.resolve(this.io.cwd, file)));
+            const { content, files, warnings } = this.bundleService.bundle(config);
+            for (const file of files)
+                this.logger.info((0, glob_1.toPosix)(node_path_1.default.relative(this.io.cwd, file)));
             for (const warning of warnings)
                 this.logger.warn(`${label}: ${warning}`);
             this.output.write(content.replace(/\n$/, ''));
@@ -63,19 +81,20 @@ let BuildController = class BuildController {
         return text;
     }
 };
-exports.BuildController = BuildController;
+exports.BundleController = BundleController;
 __decorate([
     (0, cli_1.onDefault)(ts_ioc_container_1.invoke),
     __param(0, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.pipe)(cli_1.commandArgs, buildArgs, (0, cli_1.validate)(exports.BUILD_OPTIONS)))),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], BuildController.prototype, "build", null);
-exports.BuildController = BuildController = __decorate([
+], BundleController.prototype, "bundle", null);
+exports.BundleController = BundleController = __decorate([
     (0, ts_ioc_container_1.register)('build'),
     __param(0, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(CliIo_1.CliIoKey))),
-    __param(1, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(BundleBuilder_1.IBundleBuilderKey))),
-    __param(2, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(OutputService_1.IOutputServiceKey))),
-    __param(3, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(ConsoleLogger_1.ILoggerKey))),
-    __metadata("design:paramtypes", [Object, Object, Object, Object])
-], BuildController);
+    __param(1, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(TicConfigService_1.ITicConfigServiceKey))),
+    __param(2, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(BundleService_1.IBundleServiceKey))),
+    __param(3, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(OutputService_1.IOutputServiceKey))),
+    __param(4, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(ConsoleLogger_1.ILoggerKey))),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object])
+], BundleController);

package/cjm/features/{build → bundle}/domain/tokenCollisions.js

@@ -17,7 +17,7 @@ function tokenCollisions(classes) {
         .map(([token, group]) => {
         const names = group.map((cls) => cls.className);
         return (`decorator token "${token}" is passed by ${names.join(', ')}; ` +
-            `registration is last-wins, exclude one with className.exclude`);
+            `registration is last-wins, exclude one with match.exclude`);
     });
 }
 function scopeDisjoint(group) {