@ts-ioc-container/bundler 2.0.0 → 3.0.0

package/cjm/features/build/BuildConfig.js

@@ -0,0 +1,146 @@
+"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 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 scanned 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.');
+const COMPILER_OPTIONS_SCHEMA = zod_1.z
+    .looseObject({
+    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.'),
+    classes: CLASSES_SCHEMA.optional(),
+    paths: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.array(zod_1.z.string()))
+        .optional()
+        .describe('tsconfig `paths`: aliases the generated imports are written in.'),
+    rootDir: zod_1.z
+        .string()
+        .optional()
+        .describe('tsconfig `rootDir`: where the default output (<rootDir>/<name>.bundle.ts) goes.'),
+}, expected('an object'))
+    .describe("tsconfig `compilerOptions`, plus the bundler's own `importExtension` and `classes`. Every other option is handed to TypeScript on top of the extended tsconfig's, which validates it.");
+const tsconfigGlobs = (field) => stringList().optional().describe(`tsconfig \`${field}\`: replaces the extended tsconfig's. Relative to this file.`);
+exports.BUNDLE_CONFIG_SCHEMA = zod_1.z.strictObject({
+    $schema: zod_1.z.string().optional(),
+    extends: nonEmptyString()
+        .optional()
+        .meta({ default: exports.DEFAULT_EXTENDS })
+        .describe("The tsconfig this bundle extends, as a tsconfig's own `extends`: its file set, `paths` aliases and module resolution apply unless this file overrides them. Relative to this file. The default may be absent; a tsconfig named here must exist."),
+    output: nonEmptyString()
+        .optional()
+        .describe('The bundle file (convention: *.bundle.ts). Default `<root>/<name>.bundle.ts`: <root> is the compiled rootDir, else the common folder of the files compiled.'),
+    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).'),
+    include: tsconfigGlobs('include'),
+    exclude: tsconfigGlobs('exclude'),
+    compilerOptions: COMPILER_OPTIONS_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 formatIssue(issue) {
+    if (issue.code === 'unrecognized_keys') {
+        return issue.keys.map((key) => `${formatPath([...issue.path, key])}: unknown field`);
+    }
+    return [`${formatPath(issue.path)}: ${issue.message}`];
+}
+const formatIssues = (error) => error.issues.flatMap((issue) => formatIssue(issue)).join('; ');
+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),
+    };
+}
+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, extends: tsconfig, include, exclude, compilerOptions = {} } = result.data;
+    const { importExtension, classes, ...tsCompilerOptions } = compilerOptions;
+    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),
+        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_EXTENDS), required: tsconfig !== undefined },
+        overrides: { include, exclude, compilerOptions: tsCompilerOptions },
+        importExtension,
+        classes: toClassSelector(classes),
+    };
+}

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,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportPaths = void 0;
-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 glob_1 = require("./glob");
 const SOURCE_EXTENSION = /\.(tsx?|mts|cts)$/;
-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) {
     const star = pattern.indexOf('*');
     return star === -1 ? undefined : [pattern.slice(0, star), pattern.slice(star + 1)];
@@ -66,17 +62,6 @@ class ImportPaths {
         this.aliases = aliases;
         this.extension = extension;
     }
-    resolveNamespace(namespace, baseDir) {
-        const folder = node_path_1.default.resolve(baseDir, namespace);
-        if (isDirectory(folder))
-            return folder;
-        if (!isRelative(namespace)) {
-            const found = [namespace, `${namespace}/`].flatMap((spec) => this.aliasTargets(spec)).find(isDirectory);
-            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`);
-    }
     specifier(fromFile, toFile) {
         const target = (0, glob_1.toPosix)(toFile);
         const bare = target.replace(SOURCE_EXTENSION, '');
@@ -97,18 +82,6 @@ class ImportPaths {
         }
         return best;
     }
-    aliasTargets(spec) {
-        return this.aliases.flatMap(({ pattern, targets }) => {
-            const wildcard = splitWildcard(pattern);
-            if (!wildcard)
-                return pattern === spec ? targets : [];
-            const [prefix, suffix] = wildcard;
-            if (!spec.startsWith(prefix) || !spec.endsWith(suffix) || spec.length < prefix.length + suffix.length)
-                return [];
-            const captured = spec.slice(prefix.length, spec.length - suffix.length);
-            return targets.map((target) => target.replace('*', captured));
-        });
-    }
     matchAlias(pattern, aliasTarget, file, bare) {
         const wildcard = splitWildcard(aliasTarget);
         if (!wildcard) {

package/cjm/features/build/domain/configFiles.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPackageRoot = findPackageRoot;
+exports.findConfigFiles = findConfigFiles;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const DomainException_1 = require("../../../exceptions/DomainException");
+const BuildConfig_1 = require("../BuildConfig");
+function findPackageRoot(dir) {
+    const start = node_path_1.default.resolve(dir);
+    for (let current = start;; current = node_path_1.default.dirname(current)) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(current, 'package.json')))
+            return current;
+        if (node_path_1.default.dirname(current) === current)
+            return start;
+    }
+}
+function findConfigFiles(dir) {
+    const files = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && (0, BuildConfig_1.configSuffix)(entry.name) !== undefined)
+        .map((entry) => entry.name)
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const byStem = new Map();
+    for (const file of files) {
+        const stem = file.slice(0, -(0, BuildConfig_1.configSuffix)(file).length);
+        const other = byStem.get(stem);
+        if (other)
+            throw new DomainException_1.TicConfigError(`${other} and ${file} describe the same bundle; keep one`);
+        byStem.set(stem, file);
+    }
+    return files.map((file) => node_path_1.default.join(dir, file));
+}

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

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GENERATED_HEADER = void 0;
+exports.BUNDLE_PROTOCOL = exports.GENERATED_HEADER = void 0;
+exports.bundleView = bundleView;
 exports.emitBundle = emitBundle;
-const render_1 = require("./render");
+const HandlebarsRenderService_1 = require("../../../services/HandlebarsRenderService");
 exports.GENERATED_HEADER = '// Generated by `tic build`';
+exports.BUNDLE_PROTOCOL = 'Bundle.ts.hbs';
 const RUNTIME_IMPORTS = ['IContainer', 'IContainerModule', 'IRegistration', 'Registration'];
-function emitBundle({ name, configPath, paths, tsconfigPath, classes }) {
+function bundleView({ name, configPath, classes }) {
     const taken = new Set([...RUNTIME_IMPORTS, 'registrations', name]);
     const uniqueName = (wanted) => {
         let candidate = wanted;
@@ -25,12 +27,8 @@ function emitBundle({ name, configPath, paths, tsconfigPath, classes }) {
             entry.named.push(binding === cls.exportName ? binding : `${cls.exportName} as ${binding}`);
         return binding;
     });
-    return (0, render_1.renderProtocol)('Bundle.ts.hbs', {
-        configPath,
-        paths,
-        tsconfigPath,
-        name,
-        imports: [...byFile.values()],
-        registrations: bindings,
-    });
+    return { configPath, name, imports: [...byFile.values()], registrations: bindings };
+}
+function emitBundle(input) {
+    return (0, HandlebarsRenderService_1.renderProtocol)(exports.BUNDLE_PROTOCOL, bundleView(input));
 }

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

@@ -37,7 +37,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSourceFile = void 0;
-exports.listSourceFiles = listSourceFiles;
 exports.findClasses = findClasses;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
@@ -46,23 +45,6 @@ const SOURCE_FILE = /\.(tsx?|mts|cts)$/;
 const DECLARATION_FILE = /\.d\.[mc]?tsx?$/;
 const isSourceFile = (file) => SOURCE_FILE.test(file) && !DECLARATION_FILE.test(file);
 exports.isSourceFile = isSourceFile;
-function listSourceFiles(dir, recursive, isExcluded) {
-    const files = [];
-    const walk = (current) => {
-        for (const entry of (0, node_fs_1.readdirSync)(current, { withFileTypes: true })) {
-            const full = node_path_1.default.join(current, entry.name);
-            if (entry.isDirectory()) {
-                if (recursive && entry.name !== 'node_modules')
-                    walk(full);
-            }
-            else if ((0, exports.isSourceFile)(entry.name) && !isExcluded(full)) {
-                files.push(full);
-            }
-        }
-    };
-    walk(dir);
-    return files.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-}
 const hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === kind);
 function decoratorName(decorator, imports) {
     const callee = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;

package/cjm/features/build/domain/tokenCollisions.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenCollisions = tokenCollisions;
+function tokenCollisions(classes) {
+    const owners = new Map();
+    for (const cls of classes) {
+        for (const token of cls.tokens) {
+            const group = owners.get(token) ?? [];
+            if (!group.some((owner) => owner.className === cls.className))
+                group.push(cls);
+            owners.set(token, group);
+        }
+    }
+    return [...owners]
+        .filter(([, group]) => group.length > 1 && !scopeDisjoint(group))
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .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 compilerOptions.classes.excludeClasses`);
+    });
+}
+function scopeDisjoint(group) {
+    const [first, ...rest] = group;
+    return first.decoratorCalls.some(({ name, args }) => rest.every((cls) => {
+        const same = cls.decoratorCalls.find((call) => call.name === name);
+        return same !== undefined && same.args.join('\u0000') !== args.join('\u0000');
+    }));
+}

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

@@ -40,7 +40,7 @@ exports.loadTsconfig = loadTsconfig;
 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 ImportPaths_1 = require("./ImportPaths");
 const scan_1 = require("./scan");
 const NO_INPUTS = 18003;
@@ -57,22 +57,28 @@ function commonDir(files) {
     }
     return first.slice(0, length).join(node_path_1.default.sep) || node_path_1.default.sep;
 }
-function loadTsconfig(tsconfig, importExtension) {
-    if (!(0, node_fs_1.existsSync)(tsconfig.file)) {
-        if (tsconfig.required)
-            throw new errors_1.TicConfigError(`tsconfig not found: ${tsconfig.file}`);
-        return { importPaths: new ImportPaths_1.ImportPaths([], importExtension ?? '') };
+function asTsconfig(config) {
+    if (!(0, node_fs_1.existsSync)(config.tsconfig.file)) {
+        if (config.tsconfig.required)
+            throw new DomainException_1.TicConfigError(`tsconfig not found: ${config.tsconfig.file}`);
+        return { config: config.overrides };
     }
-    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);
+    if (config.file === config.tsconfig.file)
+        return ts.readConfigFile(config.file, ts.sys.readFile);
+    return { config: { extends: config.tsconfig.file, ...config.overrides } };
+}
+function loadTsconfig(config) {
+    const { config: json, error } = asTsconfig(config);
+    const configFileName = config.file === config.tsconfig.file ? config.file : undefined;
+    const parsed = ts.parseJsonConfigFileContent(json ?? {}, ts.sys, config.dir, undefined, configFileName);
     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')}`);
+        throw new DomainException_1.TicConfigError(`${config.file}: ${ts.flattenDiagnosticMessageText(fatal.messageText, '\n')}`);
     }
     const fileNames = parsed.fileNames.map((file) => node_path_1.default.resolve(file));
     return {
-        importPaths: ImportPaths_1.ImportPaths.fromOptions(parsed.options, tsconfig.file, importExtension),
+        importPaths: ImportPaths_1.ImportPaths.fromOptions(parsed.options, config.file, config.importExtension),
         fileNames,
-        rootDir: parsed.options.rootDir ?? commonDir(fileNames.filter(scan_1.isSourceFile)) ?? node_path_1.default.dirname(tsconfig.file),
+        rootDir: parsed.options.rootDir ?? commonDir(fileNames.filter(scan_1.isSourceFile)) ?? config.dir,
     };
 }

package/cjm/features/build/services/BundleBuilder.js

@@ -0,0 +1,93 @@
+"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.BundleBuilder = exports.IBundleBuilderKey = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ts_ioc_container_1 = require("ts-ioc-container");
+const GlobalConfig_1 = require("../../../domain/GlobalConfig");
+const HandlebarsRenderService_1 = require("../../../services/HandlebarsRenderService");
+const NodeFileSystemService_1 = require("../../../services/NodeFileSystemService");
+const BuildConfig_1 = require("../BuildConfig");
+const configFiles_1 = require("../domain/configFiles");
+const emit_1 = require("../domain/emit");
+const glob_1 = require("../domain/glob");
+const scan_1 = require("../domain/scan");
+const tokenCollisions_1 = require("../domain/tokenCollisions");
+const tsconfig_1 = require("../domain/tsconfig");
+const TicConfigService_1 = require("./TicConfigService");
+const DEFAULT_EXCLUDE_GLOBS = BuildConfig_1.DEFAULT_EXCLUDE.map(glob_1.globToRegExp);
+exports.IBundleBuilderKey = new ts_ioc_container_1.SingleToken('IBundleBuilder');
+let BundleBuilder = class BundleBuilder {
+    cwd;
+    configs;
+    fs;
+    renderer;
+    constructor(cwd, configs, fs, renderer) {
+        this.cwd = cwd;
+        this.configs = configs;
+        this.fs = fs;
+        this.renderer = renderer;
+    }
+    build({ config, check = false } = {}) {
+        const resolved = config === undefined
+            ? (0, BuildConfig_1.resolveConfig)({ extends: BuildConfig_1.DEFAULT_EXTENDS }, node_path_1.default.join((0, configFiles_1.findPackageRoot)(this.cwd), TicConfigService_1.TSCONFIG_FILE))
+            : this.configs.load(node_path_1.default.resolve(this.cwd, config));
+        const { output, content, registrations, warnings } = this.generate(resolved);
+        const current = this.fs.fileExists(output) ? this.fs.readFile(output) : undefined;
+        const status = current === content ? 'unchanged' : check ? 'stale' : 'written';
+        if (status === 'written')
+            this.fs.writeFile(output, content);
+        return {
+            config: resolved.file,
+            output: { file: output, bundle: resolved.className, status, registrations, content },
+            warnings,
+        };
+    }
+    generate(config) {
+        const { importPaths: paths, fileNames, rootDir } = (0, tsconfig_1.loadTsconfig)(config);
+        const output = config.output ?? node_path_1.default.join(rootDir, `${config.name}.bundle.ts`);
+        const isExcluded = (file) => {
+            if (file === output)
+                return true;
+            const filename = (0, glob_1.toPosix)(node_path_1.default.relative(config.dir, file));
+            return DEFAULT_EXCLUDE_GLOBS.some((glob) => glob.test(filename));
+        };
+        const files = fileNames.filter((file) => (0, scan_1.isSourceFile)(file) && !isExcluded(file));
+        const classes = files
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+            .flatMap((file) => {
+            const text = this.fs.readFile(file);
+            return text.startsWith(emit_1.GENERATED_HEADER) ? [] : (0, scan_1.findClasses)(file, config.classes, text);
+        })
+            .map((cls) => ({ ...cls, specifier: paths.specifier(output, cls.file) }));
+        const content = this.renderer.render(emit_1.BUNDLE_PROTOCOL, (0, emit_1.bundleView)({
+            name: config.className,
+            configPath: (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(output), config.file)),
+            classes,
+        }));
+        return { output, content, registrations: classes.length, warnings: (0, tokenCollisions_1.tokenCollisions)(classes) };
+    }
+};
+exports.BundleBuilder = BundleBuilder;
+exports.BundleBuilder = BundleBuilder = __decorate([
+    (0, ts_ioc_container_1.register)(exports.IBundleBuilderKey),
+    __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)(NodeFileSystemService_1.IFileSystemServiceKey))),
+    __param(3, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(HandlebarsRenderService_1.IRenderServiceKey))),
+    __metadata("design:paramtypes", [String, Object, Object, Object])
+], BundleBuilder);

package/cjm/features/build/services/TicConfigService.js

@@ -0,0 +1,68 @@
+"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.TicConfigService = exports.ITicConfigServiceKey = exports.TSCONFIG_FILE = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ts_ioc_container_1 = require("ts-ioc-container");
+const yaml_1 = require("yaml");
+const GlobalConfig_1 = require("../../../domain/GlobalConfig");
+const DomainException_1 = require("../../../exceptions/DomainException");
+const NodeFileSystemService_1 = require("../../../services/NodeFileSystemService");
+const BuildConfig_1 = require("../BuildConfig");
+const configFiles_1 = require("../domain/configFiles");
+exports.TSCONFIG_FILE = 'tsconfig.json';
+exports.ITicConfigServiceKey = new ts_ioc_container_1.SingleToken('ITicConfigService');
+let TicConfigService = class TicConfigService {
+    cwd;
+    fs;
+    constructor(cwd, fs) {
+        this.cwd = cwd;
+        this.fs = fs;
+    }
+    load(file) {
+        if (!this.fs.fileExists(file))
+            throw new DomainException_1.TicConfigError(`config file not found: ${file}`);
+        return (0, BuildConfig_1.resolveConfig)(parseConfig(file, this.fs.readFile(file)), file);
+    }
+    discover(named) {
+        if (named.length > 0)
+            return named.map((config) => node_path_1.default.resolve(this.cwd, config));
+        const root = (0, configFiles_1.findPackageRoot)(this.cwd);
+        const found = (0, configFiles_1.findConfigFiles)(root);
+        if (found.length > 0)
+            return found;
+        if (this.fs.fileExists(node_path_1.default.join(root, exports.TSCONFIG_FILE)))
+            return [undefined];
+        throw new DomainException_1.TicConfigError(`no *.bundle.{json,yaml,yml} or ${exports.TSCONFIG_FILE} in ${root}; name a config with --config`);
+    }
+};
+exports.TicConfigService = TicConfigService;
+exports.TicConfigService = TicConfigService = __decorate([
+    (0, ts_ioc_container_1.register)(exports.ITicConfigServiceKey),
+    __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)(NodeFileSystemService_1.IFileSystemServiceKey))),
+    __metadata("design:paramtypes", [String, Object])
+], TicConfigService);
+function parseConfig(file, text) {
+    const yaml = file.endsWith('.yaml') || file.endsWith('.yml');
+    try {
+        return yaml ? ((0, yaml_1.parse)(text) ?? {}) : JSON.parse(text);
+    }
+    catch (e) {
+        throw new DomainException_1.TicConfigError(`${file} is not valid ${yaml ? 'YAML' : 'JSON'}: ${e.message}`);
+    }
+}