@ts-ioc-container/bundler 1.4.0 → 2.0.0

package/cjm/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 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))),
@@ -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(/\/?\*$/, '');
-}

package/cjm/build.js

@@ -3,108 +3,82 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSCONFIG_FILE = void 0;
 exports.build = build;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const config_1 = require("./config");
 const emit_1 = require("./emit");
 const glob_1 = require("./glob");
-const ImportPaths_1 = require("./ImportPaths");
-const exportPredicate_1 = require("./exportPredicate");
-const inclusion_1 = require("./inclusion");
+const errors_1 = require("./errors");
 const scan_1 = require("./scan");
-function build({ config = config_1.DEFAULT_CONFIG_FILE, cwd = process.cwd(), check = false, include, filterExports, } = {}) {
-    const resolved = (0, config_1.loadConfig)(node_path_1.default.resolve(cwd, config));
-    const paths = ImportPaths_1.ImportPaths.load(resolved.tsconfig, resolved.importExtension);
-    const includeFor = predicateResolver({
-        override: include,
-        conventional: (0, inclusion_1.findConventionalPredicate)(resolved.dir),
-        fileOf: (bundle) => bundle.include,
-        load: inclusion_1.loadInclusionPredicate,
-    });
-    const filterExportsFor = predicateResolver({
-        override: filterExports,
-        conventional: (0, exportPredicate_1.findConventionalExportPredicate)(resolved.dir),
-        fileOf: (bundle) => bundle.filterExports,
-        load: exportPredicate_1.loadExportPredicate,
-    });
-    const generated = resolved.bundles.map((bundle, i) => generate(resolved, bundle, `bundles[${i}]`, paths, {
-        include: includeFor(bundle),
-        filterExports: filterExportsFor(bundle),
-    }));
-    const outputs = generated.map(({ bundle, content, registrations }) => {
-        const current = (0, node_fs_1.existsSync)(bundle.output) ? (0, node_fs_1.readFileSync)(bundle.output, 'utf8') : undefined;
-        const status = current === content ? 'unchanged' : check ? 'stale' : 'written';
-        if (status === 'written') {
-            (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(bundle.output), { recursive: true });
-            (0, node_fs_1.writeFileSync)(bundle.output, content);
-        }
-        return { file: bundle.output, bundle: bundle.name, status, registrations, content };
-    });
+const tsconfig_1 = require("./tsconfig");
+exports.TSCONFIG_FILE = 'tsconfig.json';
+function build({ config, cwd = process.cwd(), check = false } = {}) {
+    const resolved = config === undefined
+        ? (0, config_1.resolveConfig)({ extends: config_1.DEFAULT_EXTENDS }, node_path_1.default.join((0, config_1.findPackageRoot)(cwd), exports.TSCONFIG_FILE))
+        : (0, config_1.loadConfig)(node_path_1.default.resolve(cwd, config));
+    const { output, content, registrations, warnings } = generate(resolved);
+    const current = (0, node_fs_1.existsSync)(output) ? (0, node_fs_1.readFileSync)(output, 'utf8') : undefined;
+    const status = current === content ? 'unchanged' : check ? 'stale' : 'written';
+    if (status === 'written') {
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(output), { recursive: true });
+        (0, node_fs_1.writeFileSync)(output, content);
+    }
     return {
         config: resolved.file,
-        outputs,
-        warnings: [...resolved.warnings, ...generated.flatMap((g) => g.warnings)],
-    };
-}
-function predicateResolver({ override, conventional, fileOf, load, }) {
-    const loaded = new Map();
-    return (bundle) => {
-        if (override)
-            return override;
-        const file = fileOf(bundle) ?? conventional;
-        if (file === undefined)
-            return undefined;
-        if (!loaded.has(file))
-            loaded.set(file, load(file));
-        return loaded.get(file);
+        output: { file: output, bundle: resolved.className, status, registrations, content },
+        warnings: [...resolved.warnings, ...warnings],
     };
 }
-function generate(config, bundle, field, paths, { include, filterExports }) {
+function generate(config) {
+    const { importPaths: paths, fileNames, rootDir } = (0, tsconfig_1.loadTsconfig)(config.tsconfig, config.importExtension);
+    const output = config.output ?? (rootDir && node_path_1.default.join(rootDir, `${config.name}.bundle.ts`));
+    if (output === undefined)
+        throw new errors_1.TicConfigError('output: required when there is no tsconfig to extend');
     const relative = (file) => (0, glob_1.toPosix)(node_path_1.default.relative(config.dir, file));
-    const outputs = new Set(config.bundles.map((m) => m.output));
-    const excludes = bundle.exclude.map(glob_1.globToRegExp);
+    const { include, exclude } = config.files;
     const isExcluded = (file) => {
-        if (outputs.has(file))
+        if (file === output)
             return true;
         const filename = relative(file);
-        return excludes.some((glob) => glob.test(filename)) || (include !== undefined && !include({ filename }));
+        if (include && !include.some((glob) => glob.test(filename)))
+            return true;
+        return exclude.some((glob) => glob.test(filename));
     };
     const files = new Set();
-    for (const namespace of bundle.namespaces) {
-        const dir = paths.resolveNamespace(namespace.path, config.dir);
-        for (const file of (0, scan_1.listSourceFiles)(dir, namespace.recursive, isExcluded))
-            files.add(file);
+    if (config.files.paths) {
+        for (const entry of config.files.paths) {
+            const dir = paths.resolveNamespace(entry.path, config.dir);
+            for (const file of (0, scan_1.listSourceFiles)(dir, entry.recursive, isExcluded))
+                files.add(file);
+        }
+    }
+    else if (fileNames) {
+        for (const file of fileNames)
+            if ((0, scan_1.isSourceFile)(file) && !isExcluded(file))
+                files.add(file);
+    }
+    else {
+        throw new errors_1.TicConfigError(`files.paths: required when there is no tsconfig to extend (${config.tsconfig.file} not found)`);
     }
-    const excludedAliases = new Set((bundle.select.excludeAliases ?? []).map(ImportPaths_1.normalizeAliasName));
-    const isAliasExcluded = (file) => {
-        if (excludedAliases.size === 0)
-            return false;
-        const alias = paths.aliasName(file);
-        return alias !== undefined && excludedAliases.has(alias);
-    };
     const classes = [...files]
         .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
-        .flatMap((file) => (0, scan_1.findClasses)(file, bundle.select))
-        .filter((cls) => {
-        if (isAliasExcluded(cls.file))
-            return false;
-        if (!filterExports)
-            return true;
-        const filename = relative(cls.file);
-        const { exportName, className, isDefault, decorators } = cls;
-        return filterExports({ filename, exportName, className, isDefault, decorators, tags: (0, inclusion_1.fileTags)(filename) });
+        .flatMap((file) => {
+        const text = (0, node_fs_1.readFileSync)(file, 'utf8');
+        return text.startsWith(emit_1.GENERATED_HEADER) ? [] : (0, scan_1.findClasses)(file, config.classes, text);
     })
-        .map((cls) => ({ ...cls, specifier: paths.specifier(bundle.output, cls.file) }));
+        .map((cls) => ({ ...cls, specifier: paths.specifier(output, cls.file) }));
     const content = (0, emit_1.emitBundle)({
-        name: bundle.name,
-        configPath: (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(bundle.output), config.file)),
-        namespaces: bundle.namespaces.map((ns) => ns.path),
+        name: config.className,
+        configPath: (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(output), config.file)),
+        paths: config.files.paths?.map((entry) => entry.path),
+        tsconfigPath: (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(output), config.tsconfig.file)),
         classes,
     });
-    return { bundle, content, registrations: classes.length, warnings: tokenCollisions(classes, field) };
+    return { output, content, registrations: classes.length, warnings: tokenCollisions(classes) };
 }
-function tokenCollisions(classes, field) {
+function tokenCollisions(classes) {
     const owners = new Map();
     for (const cls of classes) {
         for (const token of cls.tokens) {
@@ -119,8 +93,8 @@ function tokenCollisions(classes, field) {
         .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
         .map(([token, group]) => {
         const names = group.map((cls) => cls.className);
-        return (`${field}: decorator token "${token}" is passed by ${names.join(', ')}; ` +
-            `registration is last-wins, exclude one with select.excludeClasses`);
+        return (`decorator token "${token}" is passed by ${names.join(', ')}; ` +
+            `registration is last-wins, exclude one with classes.excludeClasses`);
     });
 }
 function scopeDisjoint(group) {

package/cjm/cli.js

@@ -7,16 +7,18 @@ exports.run = run;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const build_1 = require("./build");
+const config_1 = require("./config");
 const errors_1 = require("./errors");
 const USAGE = [
     'Usage: ts-ioc-container <command> [options]',
     '       tic is a shortcut for ts-ioc-container',
     '',
     'Commands:',
-    '  ts-ioc-container build [--config <path>] [--check]   generate the bundles described by tic.config.json',
+    '  ts-ioc-container build [--config <path>]... [--check]   generate one bundle per *.bundle.{json,yaml,yml} config',
+    '                                                          (none: one bundle from tsconfig.json, all defaults)',
     '',
     'Options:',
-    '  -c, --config <path>   config file (default: tic.config.json)',
+    '  -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',
@@ -29,23 +31,35 @@ function version() {
 class UsageError extends errors_1.TicError {
 }
 function parseBuildArgs(args) {
-    const options = { check: false };
+    const options = { configs: [], check: false };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === '--check')
             options.check = true;
         else if (arg === '--config' || arg === '-c') {
-            options.config = args[++i];
-            if (!options.config)
+            const config = args[++i];
+            if (!config)
                 throw new UsageError(`${arg} needs a path`);
+            options.configs.push(config);
         }
         else if (arg.startsWith('--config='))
-            options.config = arg.slice('--config='.length);
+            options.configs.push(arg.slice('--config='.length));
         else
             throw new UsageError(`unknown option "${arg}"`);
     }
     return options;
 }
+function configsToBuild(named, cwd) {
+    if (named.length > 0)
+        return named.map((config) => node_path_1.default.resolve(cwd, config));
+    const root = (0, config_1.findPackageRoot)(cwd);
+    const found = (0, config_1.findConfigFiles)(root);
+    if (found.length > 0)
+        return found;
+    if ((0, node_fs_1.existsSync)(node_path_1.default.join(root, build_1.TSCONFIG_FILE)))
+        return [undefined];
+    throw new errors_1.TicConfigError(`no *.bundle.{json,yaml,yml} or ${build_1.TSCONFIG_FILE} in ${root}; name a config with --config`);
+}
 function run(argv, io = { cwd: process.cwd(), stdout: console.log, stderr: console.error }) {
     const [command, ...rest] = argv;
     if (command === '--help' || command === '-h' || command === 'help') {
@@ -61,14 +75,25 @@ function run(argv, io = { cwd: process.cwd(), stdout: console.log, stderr: conso
             io.stderr(command ? `tic: unknown command "${command}"` : USAGE);
             return 1;
         }
-        const { config, check } = parseBuildArgs(rest);
-        const { outputs, warnings } = (0, build_1.build)({ config, check, cwd: io.cwd });
-        for (const warning of warnings)
-            io.stderr(`tic: warning: ${warning}`);
-        for (const { status, file, registrations } of outputs) {
-            io.stdout(`${VERB[status].padEnd(10)}${node_path_1.default.relative(io.cwd, file)} (${plural(registrations)})`);
+        const { configs, check } = parseBuildArgs(rest);
+        let stale = 0;
+        for (const config of configsToBuild(configs, io.cwd)) {
+            const name = config === undefined ? build_1.TSCONFIG_FILE : node_path_1.default.relative(io.cwd, config);
+            try {
+                const { output, warnings } = (0, build_1.build)({ config, check, cwd: io.cwd });
+                for (const warning of warnings)
+                    io.stderr(`tic: warning: ${name}: ${warning}`);
+                const { status, file, registrations } = output;
+                io.stdout(`${VERB[status].padEnd(10)}${node_path_1.default.relative(io.cwd, file)} (${plural(registrations)})`);
+                if (status === 'stale')
+                    stale++;
+            }
+            catch (e) {
+                if (e instanceof errors_1.TicError)
+                    e.message = `${name}: ${e.message}`;
+                throw e;
+            }
         }
-        const stale = outputs.filter((o) => o.status === 'stale').length;
         if (stale > 0) {
             io.stderr(`tic: ${stale} generated bundle${stale === 1 ? ' is' : 's are'} out of date — run \`tic build\``);
             return 1;

package/cjm/config.js

@@ -3,15 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_EXCLUDE = exports.DEFAULT_BUNDLE_NAME = exports.DEFAULT_CONFIG_FILE = void 0;
+exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_BUNDLE_NAME = exports.DEFAULT_EXTENDS = exports.CONFIG_FILE_SUFFIXES = void 0;
 exports.resolveConfig = resolveConfig;
+exports.toClassName = toClassName;
+exports.findPackageRoot = findPackageRoot;
+exports.findConfigFiles = findConfigFiles;
 exports.loadConfig = loadConfig;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = require("yaml");
 const errors_1 = require("./errors");
 const glob_1 = require("./glob");
-exports.DEFAULT_CONFIG_FILE = 'tic.config.json';
-exports.DEFAULT_BUNDLE_NAME = 'Bundle';
+exports.CONFIG_FILE_SUFFIXES = ['.bundle.json', '.bundle.yaml', '.bundle.yml'];
+const configSuffix = (file) => exports.CONFIG_FILE_SUFFIXES.find((suffix) => file.endsWith(suffix));
+exports.DEFAULT_EXTENDS = './tsconfig.json';
+exports.DEFAULT_BUNDLE_NAME = 'base';
+exports.DEFAULT_DECORATORS = ['register'];
 exports.DEFAULT_EXCLUDE = [
     '**/*.spec.ts',
     '**/*.test.ts',
@@ -23,11 +30,11 @@ exports.DEFAULT_EXCLUDE = [
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
 const isStringArray = (value) => Array.isArray(value) && value.every(isNonEmptyString);
-const isIdentifier = (value) => typeof value === 'string' && /^[A-Za-z_$][\w$]*$/.test(value);
+const isBundleName = (value) => typeof value === 'string' && /^[A-Za-z][\w-]*$/.test(value);
 const fail = (field, expected) => {
     throw new errors_1.TicConfigError(`${field}: expected ${expected}`);
 };
-function toNamespace(value, field) {
+function toPath(value, field) {
     if (isNonEmptyString(value))
         return { path: value, recursive: true };
     if (!isObject(value))
@@ -38,122 +45,155 @@ function toNamespace(value, field) {
         return fail(`${field}.recursive`, 'a boolean');
     return { path: value.path, recursive: value.recursive ?? true };
 }
-const SELECTOR_FIELDS = new Set([
-    'export',
-    'decorators',
-    'nameGlob',
-    'excludeClasses',
-    'excludeNameGlob',
-    'excludeAliases',
-]);
-function toSelector(value, field) {
+const FILE_SELECTOR_FIELDS = new Set(['paths', 'include', 'exclude']);
+function toFileSelector(value, field) {
     if (value === undefined)
-        return { export: 'any' };
+        return { exclude: exports.DEFAULT_EXCLUDE.map(glob_1.globToRegExp) };
     if (!isObject(value))
         return fail(field, 'an object');
-    const unknown = Object.keys(value).find((key) => !SELECTOR_FIELDS.has(key));
+    const unknown = Object.keys(value).find((key) => !FILE_SELECTOR_FIELDS.has(key));
     if (unknown)
         throw new errors_1.TicConfigError(`${field}.${unknown}: unknown field`);
-    const { export: kind, decorators, nameGlob, excludeClasses, excludeNameGlob, excludeAliases } = value;
-    if (kind !== undefined && kind !== 'any' && kind !== 'named' && kind !== 'default') {
-        return fail(`${field}.export`, '"any", "named" or "default"');
-    }
-    if (decorators !== undefined && !(isStringArray(decorators) && decorators.length > 0)) {
-        return fail(`${field}.decorators`, 'a non-empty array of strings');
-    }
-    if (nameGlob !== undefined && !isNonEmptyString(nameGlob))
-        return fail(`${field}.nameGlob`, 'a non-empty string');
-    if (excludeClasses !== undefined && !(isStringArray(excludeClasses) && excludeClasses.length > 0)) {
-        return fail(`${field}.excludeClasses`, 'a non-empty array of strings');
-    }
-    if (excludeNameGlob !== undefined && !isNonEmptyString(excludeNameGlob)) {
-        return fail(`${field}.excludeNameGlob`, 'a non-empty string');
+    const { paths, include, exclude } = value;
+    if (paths !== undefined && !(Array.isArray(paths) && paths.length > 0)) {
+        return fail(`${field}.paths`, 'a non-empty array');
     }
-    if (excludeAliases !== undefined && !(isStringArray(excludeAliases) && excludeAliases.length > 0)) {
-        return fail(`${field}.excludeAliases`, 'a non-empty array of strings');
+    if (include !== undefined && !(isStringArray(include) && include.length > 0)) {
+        return fail(`${field}.include`, 'a non-empty array of strings');
     }
+    if (exclude !== undefined && !isStringArray(exclude))
+        return fail(`${field}.exclude`, 'an array of strings');
     return {
-        export: kind ?? 'any',
-        decorators,
-        nameGlob: nameGlob === undefined ? undefined : (0, glob_1.globToRegExp)(nameGlob),
-        excludeClasses,
-        excludeNameGlob: excludeNameGlob === undefined ? undefined : (0, glob_1.globToRegExp)(excludeNameGlob),
-        excludeAliases,
+        paths: paths?.map((entry, i) => toPath(entry, `${field}.paths[${i}]`)),
+        include: include?.map(glob_1.globToRegExp),
+        exclude: (exclude ?? exports.DEFAULT_EXCLUDE).map(glob_1.globToRegExp),
     };
 }
-function toBundle(value, field, dir) {
+const CLASS_SELECTOR_FIELDS = new Set(['export', 'decorators', 'name', 'excludeClasses', 'excludeName']);
+function toClassSelector(value, field) {
+    if (value === undefined)
+        return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
     if (!isObject(value))
         return fail(field, 'an object');
-    const { output, name, namespaces, select, exclude, additionalExclude, include, filterExports } = value;
-    if (!isNonEmptyString(output))
-        return fail(`${field}.output`, 'a non-empty string');
-    if (name !== undefined && !isIdentifier(name))
-        return fail(`${field}.name`, 'a valid identifier');
-    if (!Array.isArray(namespaces) || namespaces.length === 0)
-        return fail(`${field}.namespaces`, 'a non-empty array');
-    if (exclude !== undefined && !isStringArray(exclude))
-        return fail(`${field}.exclude`, 'an array of strings');
-    if (additionalExclude !== undefined && !isStringArray(additionalExclude)) {
-        return fail(`${field}.additionalExclude`, 'an array of strings');
+    const unknown = Object.keys(value).find((key) => !CLASS_SELECTOR_FIELDS.has(key));
+    if (unknown)
+        throw new errors_1.TicConfigError(`${field}.${unknown}: unknown field`);
+    const { export: kind, decorators, name, excludeClasses, excludeName } = value;
+    if (kind !== undefined && kind !== 'any' && kind !== 'named' && kind !== 'default') {
+        return fail(`${field}.export`, '"any", "named" or "default"');
     }
-    if (include !== undefined && !isNonEmptyString(include))
-        return fail(`${field}.include`, 'a non-empty string');
-    if (filterExports !== undefined && !isNonEmptyString(filterExports)) {
-        return fail(`${field}.filterExports`, 'a non-empty string');
+    if (decorators !== undefined && !isStringArray(decorators))
+        return fail(`${field}.decorators`, 'an array of strings');
+    if (name !== undefined && !isNonEmptyString(name))
+        return fail(`${field}.name`, 'a non-empty string');
+    if (excludeClasses !== undefined && !(isStringArray(excludeClasses) && excludeClasses.length > 0)) {
+        return fail(`${field}.excludeClasses`, 'a non-empty array of strings');
+    }
+    if (excludeName !== undefined && !isNonEmptyString(excludeName)) {
+        return fail(`${field}.excludeName`, 'a non-empty string');
     }
     return {
-        output: node_path_1.default.resolve(dir, output),
-        name: name ?? exports.DEFAULT_BUNDLE_NAME,
-        namespaces: namespaces.map((ns, i) => toNamespace(ns, `${field}.namespaces[${i}]`)),
-        select: toSelector(select, `${field}.select`),
-        exclude: [...(exclude ?? exports.DEFAULT_EXCLUDE), ...(additionalExclude ?? [])],
-        include: include === undefined ? undefined : node_path_1.default.resolve(dir, include),
-        filterExports: filterExports === undefined ? undefined : node_path_1.default.resolve(dir, filterExports),
+        export: kind ?? 'any',
+        decorators: decorators === undefined ? exports.DEFAULT_DECORATORS : decorators.length > 0 ? decorators : undefined,
+        name: name === undefined ? undefined : (0, glob_1.globToRegExp)(name),
+        excludeClasses,
+        excludeName: excludeName === undefined ? undefined : (0, glob_1.globToRegExp)(excludeName),
     };
 }
-function excludeWarnings(value, field) {
-    if (!isObject(value))
+function excludeWarnings(files) {
+    if (!isObject(files))
         return [];
-    const exclude = value.exclude;
+    const exclude = files.exclude;
     if (!isStringArray(exclude) || exclude.length === 0)
         return [];
     const missing = exports.DEFAULT_EXCLUDE.filter((glob) => !exclude.includes(glob));
     if (missing.length === 0)
         return [];
     return [
-        `${field}.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
-            `add them back or use ${field}.additionalExclude`,
+        `files.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
+            `add them back`,
     ];
 }
+const CONFIG_FIELDS = new Set(['$schema', 'output', 'name', 'tags', 'extends', 'importExtension', 'files', 'classes']);
 function resolveConfig(content, file) {
     const dir = node_path_1.default.dirname(file);
     if (!isObject(content))
-        return fail('config', 'a JSON object');
-    const { tsconfig, importExtension, bundles } = content;
+        return fail('config', 'an object');
+    const unknown = Object.keys(content).find((key) => !CONFIG_FIELDS.has(key));
+    if (unknown)
+        throw new errors_1.TicConfigError(`${unknown}: unknown field`);
+    const { output, name, tags, extends: tsconfig, importExtension, files, classes } = content;
+    if (output !== undefined && !isNonEmptyString(output))
+        return fail('output', 'a non-empty string');
+    if (name !== undefined && !isBundleName(name)) {
+        return fail('name', 'letters, digits, "-" or "_", starting with a letter');
+    }
+    const bundleName = name ?? configStem(file) ?? exports.DEFAULT_BUNDLE_NAME;
+    if (tags !== undefined && !isStringArray(tags))
+        return fail('tags', 'an array of strings');
     if (tsconfig !== undefined && !isNonEmptyString(tsconfig))
-        return fail('tsconfig', 'a non-empty string');
+        return fail('extends', 'a non-empty string');
     if (importExtension !== undefined && typeof importExtension !== 'string')
         return fail('importExtension', 'a string');
-    if (!Array.isArray(bundles) || bundles.length === 0)
-        return fail('bundles', 'a non-empty array');
     return {
         file,
         dir,
-        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? 'tsconfig.json'), required: tsconfig !== undefined },
+        output: output === undefined ? undefined : node_path_1.default.resolve(dir, output),
+        name: bundleName,
+        className: toClassName(bundleName),
+        tags: tags ?? [],
+        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_EXTENDS), required: tsconfig !== undefined },
         importExtension,
-        bundles: bundles.map((m, i) => toBundle(m, `bundles[${i}]`, dir)),
-        warnings: bundles.flatMap((m, i) => excludeWarnings(m, `bundles[${i}]`)),
+        files: toFileSelector(files, 'files'),
+        classes: toClassSelector(classes, 'classes'),
+        warnings: excludeWarnings(files),
     };
 }
-function loadConfig(file) {
-    if (!(0, node_fs_1.existsSync)(file))
-        throw new errors_1.TicConfigError(`config file not found: ${file}`);
-    let content;
+function configStem(file) {
+    const base = node_path_1.default.basename(file);
+    const suffix = configSuffix(base);
+    const stem = suffix ? base.slice(0, -suffix.length) : '';
+    return isBundleName(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 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() && 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, -configSuffix(file).length);
+        const other = byStem.get(stem);
+        if (other)
+            throw new errors_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));
+}
+function parseConfig(file, text) {
+    const yaml = file.endsWith('.yaml') || file.endsWith('.yml');
     try {
-        content = JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8'));
+        return yaml ? ((0, yaml_1.parse)(text) ?? {}) : JSON.parse(text);
     }
     catch (e) {
-        throw new errors_1.TicConfigError(`${file} is not valid JSON: ${e.message}`);
+        throw new errors_1.TicConfigError(`${file} is not valid ${yaml ? 'YAML' : 'JSON'}: ${e.message}`);
     }
-    return resolveConfig(content, file);
+}
+function loadConfig(file) {
+    if (!(0, node_fs_1.existsSync)(file))
+        throw new errors_1.TicConfigError(`config file not found: ${file}`);
+    return resolveConfig(parseConfig(file, (0, node_fs_1.readFileSync)(file, 'utf8')), file);
 }

package/cjm/emit.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATED_HEADER = void 0;
 exports.emitBundle = emitBundle;
 const render_1 = require("./render");
+exports.GENERATED_HEADER = '// Generated by `tic build`';
 const RUNTIME_IMPORTS = ['IContainer', 'IContainerModule', 'IRegistration', 'Registration'];
-function emitBundle({ name, configPath, namespaces, classes }) {
+function emitBundle({ name, configPath, paths, tsconfigPath, classes }) {
     const taken = new Set([...RUNTIME_IMPORTS, 'registrations', name]);
     const uniqueName = (wanted) => {
         let candidate = wanted;
@@ -25,7 +27,8 @@ function emitBundle({ name, configPath, namespaces, classes }) {
     });
     return (0, render_1.renderProtocol)('Bundle.ts.hbs', {
         configPath,
-        namespaces,
+        paths,
+        tsconfigPath,
         name,
         imports: [...byFile.values()],
         registrations: bindings,