@ts-ioc-container/bundler 1.5.0 → 2.1.0

package/cjm/cli/Application.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+const DomainException_1 = require("../exceptions/DomainException");
+const decorators_1 = require("./decorators");
+const IErrorHandler_1 = require("./IErrorHandler");
+const usage_1 = require("./usage");
+const COMMAND_ALIASES = {
+    '--help': 'help',
+    '-h': 'help',
+    '--version': 'version',
+    '-v': 'version',
+};
+function parseCommandAndAction(argv) {
+    const [first, maybeAction] = argv;
+    if (!first)
+        throw new DomainException_1.MissingCommandError(usage_1.USAGE);
+    const command = COMMAND_ALIASES[first] ?? first;
+    const action = maybeAction && !maybeAction.startsWith('-') ? maybeAction : decorators_1.DEFAULT_ACTION;
+    return { command, action };
+}
+class Application {
+    scope;
+    errorHandler;
+    static bootstrap(container) {
+        return new Application(container, IErrorHandler_1.IErrorHandlerKey.resolve(container));
+    }
+    constructor(scope, errorHandler) {
+        this.scope = scope;
+        this.errorHandler = errorHandler;
+    }
+    run(...argv) {
+        try {
+            const { command, action } = parseCommandAndAction(argv);
+            if (!this.scope.hasRegistration(command))
+                throw new DomainException_1.UnknownCommandError(command);
+            const controller = this.scope.resolve(command);
+            const collector = new ts_ioc_container_1.HookCollector({
+                key: action,
+                createExecutionContext: (0, ts_ioc_container_1.createHookContextFactory)({ args: argv }),
+            });
+            const actions = collector.getActions(controller, { scope: this.scope });
+            if (actions.length === 0)
+                throw new DomainException_1.UnknownActionError(command, action);
+            for (const item of actions)
+                (0, ts_ioc_container_1.toTask)(item)();
+            return 0;
+        }
+        catch (error) {
+            return this.errorHandler.handleError(error);
+        }
+        finally {
+            this.scope.dispose();
+        }
+    }
+}
+exports.Application = Application;

package/cjm/cli/IErrorHandler.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IErrorHandlerKey = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.IErrorHandlerKey = new ts_ioc_container_1.SingleToken('IErrorHandler');

package/cjm/cli/decorators.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onDefault = exports.action = exports.DEFAULT_ACTION = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.DEFAULT_ACTION = 'default';
+const action = (name, ...hooks) => (0, ts_ioc_container_1.hook)(name, (0, ts_ioc_container_1.sequential)(...hooks));
+exports.action = action;
+const onDefault = (...hooks) => (0, exports.action)(exports.DEFAULT_ACTION, ...hooks);
+exports.onDefault = onDefault;

package/cjm/cli/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USAGE = exports.IErrorHandlerKey = exports.Application = exports.validate = exports.parseOptions = exports.commandArgs = exports.onDefault = exports.DEFAULT_ACTION = exports.action = void 0;
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "action", { enumerable: true, get: function () { return decorators_1.action; } });
+Object.defineProperty(exports, "DEFAULT_ACTION", { enumerable: true, get: function () { return decorators_1.DEFAULT_ACTION; } });
+Object.defineProperty(exports, "onDefault", { enumerable: true, get: function () { return decorators_1.onDefault; } });
+var options_1 = require("./options");
+Object.defineProperty(exports, "commandArgs", { enumerable: true, get: function () { return options_1.commandArgs; } });
+Object.defineProperty(exports, "parseOptions", { enumerable: true, get: function () { return options_1.parseOptions; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return options_1.validate; } });
+var Application_1 = require("./Application");
+Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return Application_1.Application; } });
+var IErrorHandler_1 = require("./IErrorHandler");
+Object.defineProperty(exports, "IErrorHandlerKey", { enumerable: true, get: function () { return IErrorHandler_1.IErrorHandlerKey; } });
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "USAGE", { enumerable: true, get: function () { return usage_1.USAGE; } });

package/cjm/cli/options.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.parseOptions = exports.commandArgs = void 0;
+const node_util_1 = require("node:util");
+const zod_1 = require("zod");
+const DomainException_1 = require("../exceptions/DomainException");
+const commandArgs = ({ args = [] }) => args.map(String);
+exports.commandArgs = commandArgs;
+const parseOptions = (options) => (argv) => {
+    const firstFlag = argv.findIndex((arg) => arg.startsWith('-'));
+    try {
+        return { ...(0, node_util_1.parseArgs)({ args: firstFlag >= 0 ? argv.slice(firstFlag) : [], options, strict: true }).values };
+    }
+    catch (e) {
+        throw new DomainException_1.UsageError(e.message);
+    }
+};
+exports.parseOptions = parseOptions;
+const validate = (schema) => (value) => {
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new DomainException_1.UsageError(zod_1.z.prettifyError(result.error));
+    return result.data;
+};
+exports.validate = validate;

package/cjm/cli/usage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USAGE = void 0;
+exports.USAGE = [
+    'Usage: ts-ioc-container <command> [options]',
+    '       tic is a shortcut for ts-ioc-container',
+    '',
+    'Commands:',
+    '  ts-ioc-container build [--config <path>]... [--check]   generate one bundle per *.bundle.{json,yaml,yml} config',
+    '                                                          (none: one bundle from tsconfig.json, all defaults)',
+    '  ts-ioc-container help                                   show this help',
+    '  ts-ioc-container version                                show the version',
+    '',
+    'Options:',
+    '  -c, --config <path>   build only this config; repeatable (default: every *.bundle.{json,yaml,yml} of the package, else tsconfig.json)',
+    '  --check               write nothing; exit 1 when a generated bundle is out of date',
+    '  -h, --help            show this help',
+    '  -v, --version         show the version',
+].join('\n');

package/cjm/domain/CliIo.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIo = exports.CliIoKey = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.CliIoKey = new ts_ioc_container_1.SingleToken('CliIo');
+const processIo = () => ({ cwd: process.cwd(), stdout: console.log, stderr: console.error });
+exports.processIo = processIo;

package/cjm/domain/GlobalConfig.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalConfig = exports.GlobalConfigKey = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.GlobalConfigKey = new ts_ioc_container_1.SingleToken('GlobalConfig');
+const globalConfig = (key) => ({ scope }) => exports.GlobalConfigKey.resolve(scope)[key];
+exports.globalConfig = globalConfig;

package/cjm/exceptions/DomainException.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleBundlesError = exports.UsageError = exports.UnknownActionError = exports.UnknownCommandError = exports.MissingCommandError = exports.NamespaceNotFoundError = exports.TicConfigError = exports.TicError = void 0;
+class TicError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = new.target.name;
+    }
+}
+exports.TicError = TicError;
+class TicConfigError extends TicError {
+    constructor(message) {
+        super('INVALID_CONFIG', message);
+    }
+}
+exports.TicConfigError = TicConfigError;
+class NamespaceNotFoundError extends TicError {
+    constructor(message) {
+        super('NAMESPACE_NOT_FOUND', message);
+    }
+}
+exports.NamespaceNotFoundError = NamespaceNotFoundError;
+class MissingCommandError extends TicError {
+    constructor(usage) {
+        super('MISSING_COMMAND', `missing command\n${usage}`);
+    }
+}
+exports.MissingCommandError = MissingCommandError;
+class UnknownCommandError extends TicError {
+    constructor(command) {
+        super('UNKNOWN_COMMAND', `unknown command "${command}"`);
+    }
+}
+exports.UnknownCommandError = UnknownCommandError;
+class UnknownActionError extends TicError {
+    constructor(command, action) {
+        super('UNKNOWN_ACTION', `unknown action "${action}" for command "${command}"`);
+    }
+}
+exports.UnknownActionError = UnknownActionError;
+class UsageError extends TicError {
+    constructor(message) {
+        super('USAGE', message);
+    }
+}
+exports.UsageError = UsageError;
+class StaleBundlesError extends TicError {
+    constructor(count) {
+        super('STALE_BUNDLES', `${count} generated bundle${count === 1 ? ' is' : 's are'} out of date — run \`tic build\``);
+    }
+}
+exports.StaleBundlesError = StaleBundlesError;

package/cjm/exceptions/ExceptionHandler.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandler = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+const IErrorHandler_1 = require("../cli/IErrorHandler");
+const ConsoleLogger_1 = require("../services/ConsoleLogger");
+const DomainException_1 = require("./DomainException");
+let ExceptionHandler = class ExceptionHandler {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    handleError(error) {
+        if (error instanceof DomainException_1.TicError)
+            this.logger.error(error.message);
+        else
+            this.logger.error(error instanceof Error ? (error.stack ?? error.message) : String(error));
+        return 1;
+    }
+};
+exports.ExceptionHandler = ExceptionHandler;
+exports.ExceptionHandler = ExceptionHandler = __decorate([
+    (0, ts_ioc_container_1.register)(IErrorHandler_1.IErrorHandlerKey, (0, ts_ioc_container_1.singleton)()),
+    __param(0, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(ConsoleLogger_1.ILoggerKey))),
+    __metadata("design:paramtypes", [Object])
+], ExceptionHandler);

package/cjm/features/build/BuildConfig.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSuffix = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_BUNDLE_NAME = exports.DEFAULT_EXTENDS = void 0;
+exports.toClassName = toClassName;
+exports.resolveConfig = resolveConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const DomainException_1 = require("../../exceptions/DomainException");
+const glob_1 = require("./domain/glob");
+exports.DEFAULT_EXTENDS = './tsconfig.json';
+exports.DEFAULT_BUNDLE_NAME = 'base';
+exports.DEFAULT_DECORATORS = ['register'];
+exports.DEFAULT_EXCLUDE = [
+    '**/*.spec.ts',
+    '**/*.test.ts',
+    '**/*.spec.tsx',
+    '**/*.test.tsx',
+    '**/__tests__/**',
+    '**/node_modules/**',
+];
+const BUNDLE_NAME = /^[A-Za-z][\w-]*$/;
+const expected = (what) => ({ error: `expected ${what}` });
+const nonEmptyString = () => zod_1.z.string(expected('a non-empty string')).min(1, expected('a non-empty string'));
+const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+const strings = (what, minItems) => zod_1.z
+    .custom((value) => Array.isArray(value) && value.length >= minItems && value.every(isNonEmptyString), expected(what))
+    .meta({ type: 'array', items: { type: 'string', minLength: 1 }, ...(minItems > 0 && { minItems }) });
+const stringList = () => strings('an array of strings', 0);
+const nonEmptyStringList = () => strings('a non-empty array of strings', 1);
+const PATH_SCHEMA = zod_1.z.union([
+    nonEmptyString(),
+    zod_1.z.object({
+        path: nonEmptyString(),
+        recursive: zod_1.z.boolean(expected('a boolean')).default(true),
+    }, expected('a string or an object with "path"')),
+], expected('a string or an object with "path"'));
+const FILES_SCHEMA = zod_1.z
+    .strictObject({
+    paths: zod_1.z
+        .array(PATH_SCHEMA, expected('a non-empty array'))
+        .min(1, expected('a non-empty array'))
+        .optional()
+        .describe("Folders to scan instead of the extended tsconfig's file set: paths relative to this file (./src/services) or tsconfig paths aliases (@app/services). Required when there is no tsconfig to extend."),
+    include: nonEmptyStringList()
+        .optional()
+        .describe('Globs a file must match one of, e.g. ["**/*.service.ts", "**/*.repository.ts"]. Default: every source file.'),
+    exclude: stringList()
+        .default(exports.DEFAULT_EXCLUDE)
+        .describe('Globs of files never read. Replaces the default when given. A non-empty list that omits a default glob makes `tic build` warn.'),
+}, expected('an object'))
+    .describe('Which files this bundle reads and parses — decided by path alone, before parsing. The candidates are what the extended tsconfig compiles, or the folders in `paths` when given. A candidate is parsed when it matches one of `include` and none of `exclude`. Globs are relative to this file. With a file naming convention, `include` keeps every other file unread.');
+const CLASSES_SCHEMA = zod_1.z
+    .strictObject({
+    export: zod_1.z
+        .enum(['any', 'named', 'default'], expected('"any", "named" or "default"'))
+        .default('any')
+        .describe('Which exports count.'),
+    decorators: stringList()
+        .default(exports.DEFAULT_DECORATORS)
+        .describe('The class must carry one of these decorators, recognised by name (e.g. "register", or a composed decorator). Default ["register"]; [] requires none.'),
+    name: nonEmptyString()
+        .optional()
+        .describe('Glob the class name must match, e.g. "*Service". An anonymous default export is named after its file.'),
+    excludeClasses: nonEmptyStringList()
+        .optional()
+        .describe('Class names to drop after selection, e.g. one test double sitting next to the real registration in the same file.'),
+    excludeName: nonEmptyString()
+        .optional()
+        .describe('Glob the class name must NOT match, e.g. "*Mock". An anonymous default export is named after its file.'),
+}, expected('an object'))
+    .describe('Which classes of a parsed file are registered. A class is selected when it is exported, not abstract, and meets every criterion set here; by default that is every exported class decorated with @register.');
+exports.BUNDLE_CONFIG_SCHEMA = zod_1.z.strictObject({
+    $schema: zod_1.z.string().optional(),
+    output: nonEmptyString()
+        .optional()
+        .describe("The bundle file (convention: *.bundle.ts). Default `<root>/<name>.bundle.ts`: <root> is the tsconfig's rootDir, else the common folder of the files it compiles. Required when there is no tsconfig to extend."),
+    name: zod_1.z
+        .string(expected('letters, digits, "-" or "_", starting with a letter'))
+        .regex(BUNDLE_NAME, expected('letters, digits, "-" or "_", starting with a letter'))
+        .optional()
+        .describe('The bundle\'s name: letters, digits, "-" and "_", starting with a letter. Default: this file\'s stem (production.bundle.json → production), else "base". It names the default output (production.bundle.ts) and the generated IContainerModule class (ProductionBundle).'),
+    tags: stringList().default([]).describe('Tags associated with the bundle.'),
+    extends: nonEmptyString()
+        .optional()
+        .meta({ default: exports.DEFAULT_EXTENDS })
+        .describe("The tsconfig this bundle builds on, like a tsconfig's own `extends`: what it compiles (`files` / `include` / `exclude`) is the bundle's file set unless `files.paths` overrides it, and its `paths` aliases and module resolution shape the generated imports. Relative to this file. The default may be absent; a tsconfig named here must exist."),
+    importExtension: zod_1.z
+        .string(expected('a string'))
+        .optional()
+        .describe('Extension of generated imports, e.g. ".js". Inferred from the tsconfig: ".js" under node16/nodenext resolution, none otherwise.'),
+    files: FILES_SCHEMA.optional(),
+    classes: CLASSES_SCHEMA.optional(),
+}, expected('an object'));
+function formatPath(segments) {
+    const formatted = segments
+        .map((segment) => (typeof segment === 'number' ? `[${segment}]` : `.${String(segment)}`))
+        .join('')
+        .replace(/^\./, '');
+    return formatted || 'config';
+}
+function matchedBranch(issue) {
+    const typeMatched = issue.errors.filter((branch) => branch.every((inner) => inner.code !== 'invalid_type' || inner.path.length > 0));
+    return typeMatched.length === 1 ? typeMatched[0] : undefined;
+}
+function formatIssue(issue, prefix = []) {
+    const at = [...prefix, ...issue.path];
+    if (issue.code === 'unrecognized_keys')
+        return issue.keys.map((key) => `${formatPath([...at, key])}: unknown field`);
+    const branch = issue.code === 'invalid_union' ? matchedBranch(issue) : undefined;
+    if (branch)
+        return branch.flatMap((inner) => formatIssue(inner, at));
+    return [`${formatPath(at)}: ${issue.message}`];
+}
+const formatIssues = (error) => error.issues.flatMap((issue) => formatIssue(issue)).join('; ');
+function toFileSelector(files) {
+    if (files === undefined)
+        return { exclude: exports.DEFAULT_EXCLUDE.map(glob_1.globToRegExp) };
+    return {
+        paths: files.paths?.map((entry) => (typeof entry === 'string' ? { path: entry, recursive: true } : entry)),
+        include: files.include?.map(glob_1.globToRegExp),
+        exclude: files.exclude.map(glob_1.globToRegExp),
+    };
+}
+function toClassSelector(classes) {
+    if (classes === undefined)
+        return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
+    const { decorators, name, excludeName, ...rest } = classes;
+    return {
+        ...rest,
+        decorators: decorators.length > 0 ? decorators : undefined,
+        name: name === undefined ? undefined : (0, glob_1.globToRegExp)(name),
+        excludeName: excludeName === undefined ? undefined : (0, glob_1.globToRegExp)(excludeName),
+    };
+}
+function excludeWarnings(files) {
+    const exclude = files?.exclude ?? [];
+    if (exclude.length === 0)
+        return [];
+    const missing = exports.DEFAULT_EXCLUDE.filter((glob) => !exclude.includes(glob));
+    if (missing.length === 0)
+        return [];
+    return [
+        `files.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
+            `add them back`,
+    ];
+}
+exports.CONFIG_FILE_SUFFIXES = ['.bundle.json', '.bundle.yaml', '.bundle.yml'];
+const configSuffix = (file) => exports.CONFIG_FILE_SUFFIXES.find((suffix) => file.endsWith(suffix));
+exports.configSuffix = configSuffix;
+function configStem(file) {
+    const base = node_path_1.default.basename(file);
+    const suffix = (0, exports.configSuffix)(base);
+    const stem = suffix ? base.slice(0, -suffix.length) : '';
+    return BUNDLE_NAME.test(stem) ? stem : undefined;
+}
+function toClassName(name) {
+    const words = name.split(/[-_]+/).filter(Boolean);
+    return `${words.map((word) => word[0].toUpperCase() + word.slice(1)).join('')}Bundle`;
+}
+function resolveConfig(content, file) {
+    const result = exports.BUNDLE_CONFIG_SCHEMA.safeParse(content);
+    if (!result.success)
+        throw new DomainException_1.TicConfigError(formatIssues(result.error));
+    const { output, name, tags, extends: tsconfig, importExtension, files, classes } = result.data;
+    const dir = node_path_1.default.dirname(file);
+    const bundleName = name ?? configStem(file) ?? exports.DEFAULT_BUNDLE_NAME;
+    return {
+        file,
+        dir,
+        output: output === undefined ? undefined : node_path_1.default.resolve(dir, output),
+        name: bundleName,
+        className: toClassName(bundleName),
+        tags,
+        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_EXTENDS), required: tsconfig !== undefined },
+        importExtension,
+        files: toFileSelector(files),
+        classes: toClassSelector(classes),
+        warnings: excludeWarnings(files),
+    };
+}

package/cjm/features/build/BuildController.js

@@ -0,0 +1,91 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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;
+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");
+const GlobalConfig_1 = require("../../domain/GlobalConfig");
+const DomainException_1 = require("../../exceptions/DomainException");
+const ConsoleLogger_1 = require("../../services/ConsoleLogger");
+const OutputService_1 = require("../../services/OutputService");
+const BundleBuilder_1 = require("./services/BundleBuilder");
+const TicConfigService_1 = require("./services/TicConfigService");
+exports.BUILD_OPTIONS = zod_1.z.object({
+    config: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    check: zod_1.z.boolean().default(false),
+});
+const buildArgs = (0, cli_1.parseOptions)({
+    config: { type: 'string', short: 'c', multiple: true },
+    check: { type: 'boolean' },
+});
+const VERB = { written: 'wrote', unchanged: 'unchanged', stale: 'stale' };
+const plural = (n) => `${n} registration${n === 1 ? '' : 's'}`;
+let BuildController = class BuildController {
+    cwd;
+    configs;
+    builder;
+    output;
+    logger;
+    constructor(cwd, configs, builder, output, logger) {
+        this.cwd = cwd;
+        this.configs = configs;
+        this.builder = builder;
+        this.output = output;
+        this.logger = logger;
+    }
+    build(options) {
+        let stale = 0;
+        for (const config of this.configs.discover(options.config)) {
+            const name = config === undefined ? TicConfigService_1.TSCONFIG_FILE : node_path_1.default.relative(this.cwd, config);
+            try {
+                const { output, warnings } = this.builder.build({ config, check: options.check });
+                for (const warning of warnings)
+                    this.logger.warn(`${name}: ${warning}`);
+                const { status, file, registrations } = output;
+                this.output.write(`${VERB[status].padEnd(10)}${node_path_1.default.relative(this.cwd, file)} (${plural(registrations)})`);
+                if (status === 'stale')
+                    stale++;
+            }
+            catch (e) {
+                if (e instanceof DomainException_1.TicError)
+                    e.message = `${name}: ${e.message}`;
+                throw e;
+            }
+        }
+        if (stale > 0)
+            throw new DomainException_1.StaleBundlesError(stale);
+    }
+};
+exports.BuildController = BuildController;
+__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([
+    (0, ts_ioc_container_1.register)('build'),
+    __param(0, (0, ts_ioc_container_1.inject)((0, GlobalConfig_1.globalConfig)('cwd'))),
+    __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)(BundleBuilder_1.IBundleBuilderKey))),
+    __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", [String, Object, Object, Object, Object])
+], BuildController);

package/cjm/features/build/BuildModule.js

@@ -0,0 +1,16 @@
+"use strict";
+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 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(TicConfigService_1.TicConfigService));
+    }
+}
+exports.BuildModule = BuildModule;

package/cjm/{ImportPaths.js → features/build/domain/ImportPaths.js}

@@ -37,14 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportPaths = void 0;
-exports.normalizeAliasName = normalizeAliasName;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const ts = __importStar(require("typescript"));
-const errors_1 = require("./errors");
+const DomainException_1 = require("../../../exceptions/DomainException");
 const glob_1 = require("./glob");
 const SOURCE_EXTENSION = /\.(tsx?|mts|cts)$/;
-const NO_INPUTS = 18003;
 const isDirectory = (dir) => (0, node_fs_1.existsSync)(dir) && (0, node_fs_1.statSync)(dir).isDirectory();
 const isRelative = (spec) => spec.startsWith('.') || node_path_1.default.isAbsolute(spec);
 function splitWildcard(pattern) {
@@ -54,20 +52,9 @@ function splitWildcard(pattern) {
 class ImportPaths {
     aliases;
     extension;
-    static load(tsconfig, importExtension) {
-        if (!(0, node_fs_1.existsSync)(tsconfig.file)) {
-            if (tsconfig.required)
-                throw new errors_1.TicConfigError(`tsconfig not found: ${tsconfig.file}`);
-            return new ImportPaths([], importExtension ?? '');
-        }
-        const { config, error } = ts.readConfigFile(tsconfig.file, ts.sys.readFile);
-        const parsed = ts.parseJsonConfigFileContent(config, ts.sys, node_path_1.default.dirname(tsconfig.file), undefined, tsconfig.file);
-        const [fatal] = [error, ...parsed.errors].filter((d) => !!d && d.code !== NO_INPUTS);
-        if (fatal) {
-            throw new errors_1.TicConfigError(`${tsconfig.file}: ${ts.flattenDiagnosticMessageText(fatal.messageText, '\n')}`);
-        }
-        const { paths = {}, baseUrl, pathsBasePath, moduleResolution } = parsed.options;
-        const base = baseUrl ?? (typeof pathsBasePath === 'string' ? pathsBasePath : node_path_1.default.dirname(tsconfig.file));
+    static fromOptions(options, tsconfigFile, importExtension) {
+        const { paths = {}, baseUrl, pathsBasePath, moduleResolution } = options;
+        const base = baseUrl ?? (typeof pathsBasePath === 'string' ? pathsBasePath : node_path_1.default.dirname(tsconfigFile));
         const aliases = Object.entries(paths).map(([pattern, targets]) => ({
             pattern,
             targets: targets.map((target) => (0, glob_1.toPosix)(node_path_1.default.resolve(base, target))),
@@ -88,7 +75,7 @@ class ImportPaths {
             if (found)
                 return node_path_1.default.normalize(found);
         }
-        throw new errors_1.NamespaceNotFoundError(`namespace "${namespace}" is neither a folder relative to ${baseDir} nor a tsconfig paths alias of one`);
+        throw new DomainException_1.NamespaceNotFoundError(`namespace "${namespace}" is neither a folder relative to ${baseDir} nor a tsconfig paths alias of one`);
     }
     specifier(fromFile, toFile) {
         const target = (0, glob_1.toPosix)(toFile);
@@ -99,12 +86,6 @@ class ImportPaths {
         const relative = (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(fromFile), bare));
         return `${relative.startsWith('.') ? relative : `./${relative}`}${this.extension}`;
     }
-    aliasName(file) {
-        const target = (0, glob_1.toPosix)(file);
-        const bare = target.replace(SOURCE_EXTENSION, '');
-        const best = this.bestAlias(target, bare);
-        return best && normalizeAliasName(best.pattern);
-    }
     bestAlias(target, bare) {
         let best;
         for (const { pattern, targets } of this.aliases) {
@@ -132,17 +113,14 @@ class ImportPaths {
         const wildcard = splitWildcard(aliasTarget);
         if (!wildcard) {
             const exact = aliasTarget === file || aliasTarget.replace(SOURCE_EXTENSION, '') === bare;
-            return exact && !splitWildcard(pattern) ? { spec: pattern, score: Infinity, pattern } : undefined;
+            return exact && !splitWildcard(pattern) ? { spec: pattern, score: Infinity } : undefined;
         }
         const [prefix, suffix] = wildcard;
         if (!bare.startsWith(prefix) || !bare.endsWith(suffix) || bare.length < prefix.length + suffix.length) {
             return undefined;
         }
         const captured = bare.slice(prefix.length, bare.length - suffix.length);
-        return { spec: `${pattern.replace('*', captured)}${this.extension}`, score: prefix.length, pattern };
+        return { spec: `${pattern.replace('*', captured)}${this.extension}`, score: prefix.length };
     }
 }
 exports.ImportPaths = ImportPaths;
-function normalizeAliasName(pattern) {
-    return pattern.replace(/^@/, '').replace(/\/?\*$/, '');
-}