@ts-ioc-container/bundler 0.0.0

package/cjm/cli.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const build_1 = require("./build");
+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',
+    '',
+    'Options:',
+    '  -c, --config <path>   config file (default: tic.config.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');
+const VERB = { written: 'wrote', unchanged: 'unchanged', stale: 'stale' };
+const plural = (n) => `${n} registration${n === 1 ? '' : 's'}`;
+function version() {
+    return JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '..', 'package.json'), 'utf8')).version;
+}
+class UsageError extends errors_1.TicError {
+}
+function parseBuildArgs(args) {
+    const options = { 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)
+                throw new UsageError(`${arg} needs a path`);
+        }
+        else if (arg.startsWith('--config='))
+            options.config = arg.slice('--config='.length);
+        else
+            throw new UsageError(`unknown option "${arg}"`);
+    }
+    return options;
+}
+function run(argv, io = { cwd: process.cwd(), stdout: console.log, stderr: console.error }) {
+    const [command, ...rest] = argv;
+    if (command === '--help' || command === '-h' || command === 'help') {
+        io.stdout(USAGE);
+        return 0;
+    }
+    if (command === '--version' || command === '-v') {
+        io.stdout(version());
+        return 0;
+    }
+    try {
+        if (command !== 'build') {
+            io.stderr(command ? `tic: unknown command "${command}"` : USAGE);
+            return 1;
+        }
+        const { config, check } = parseBuildArgs(rest);
+        const { outputs } = (0, build_1.build)({ config, check, cwd: io.cwd });
+        for (const { status, file, registrations } of outputs) {
+            io.stdout(`${VERB[status].padEnd(10)}${node_path_1.default.relative(io.cwd, file)} (${plural(registrations)})`);
+        }
+        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;
+        }
+        return 0;
+    }
+    catch (e) {
+        if (!(e instanceof errors_1.TicError))
+            throw e;
+        io.stderr(`tic: ${e.message}`);
+        return 1;
+    }
+}

package/cjm/config.js

@@ -0,0 +1,118 @@
+"use strict";
+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.resolveConfig = resolveConfig;
+exports.loadConfig = loadConfig;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const glob_1 = require("./glob");
+exports.DEFAULT_CONFIG_FILE = 'tic.config.json';
+exports.DEFAULT_BUNDLE_NAME = 'Bundle';
+exports.DEFAULT_EXCLUDE = [
+    '**/*.spec.ts',
+    '**/*.test.ts',
+    '**/*.spec.tsx',
+    '**/*.test.tsx',
+    '**/__tests__/**',
+    '**/node_modules/**',
+];
+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 fail = (field, expected) => {
+    throw new errors_1.TicConfigError(`${field}: expected ${expected}`);
+};
+function toNamespace(value, field) {
+    if (isNonEmptyString(value))
+        return { path: value, recursive: true };
+    if (!isObject(value))
+        return fail(field, 'a string or an object with "path"');
+    if (!isNonEmptyString(value.path))
+        return fail(`${field}.path`, 'a non-empty string');
+    if (value.recursive !== undefined && typeof value.recursive !== 'boolean')
+        return fail(`${field}.recursive`, 'a boolean');
+    return { path: value.path, recursive: value.recursive ?? true };
+}
+const SELECTOR_FIELDS = new Set(['export', 'decorators', 'nameGlob']);
+function toSelector(value, field) {
+    if (value === undefined)
+        return { export: 'any' };
+    if (!isObject(value))
+        return fail(field, 'an object');
+    const unknown = Object.keys(value).find((key) => !SELECTOR_FIELDS.has(key));
+    if (unknown)
+        throw new errors_1.TicConfigError(`${field}.${unknown}: unknown field`);
+    const { export: kind, decorators, nameGlob } = 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');
+    return { export: kind ?? 'any', decorators, nameGlob: nameGlob === undefined ? undefined : (0, glob_1.globToRegExp)(nameGlob) };
+}
+function toBundle(value, field, dir) {
+    if (!isObject(value))
+        return fail(field, 'an object');
+    const { output, name, namespaces, select, exclude, 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 (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');
+    }
+    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,
+        include: include === undefined ? undefined : node_path_1.default.resolve(dir, include),
+        filterExports: filterExports === undefined ? undefined : node_path_1.default.resolve(dir, filterExports),
+    };
+}
+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;
+    if (tsconfig !== undefined && !isNonEmptyString(tsconfig))
+        return fail('tsconfig', '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 },
+        importExtension,
+        bundles: bundles.map((m, i) => toBundle(m, `bundles[${i}]`, dir)),
+    };
+}
+function loadConfig(file) {
+    if (!(0, node_fs_1.existsSync)(file))
+        throw new errors_1.TicConfigError(`config file not found: ${file}`);
+    let content;
+    try {
+        content = JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8'));
+    }
+    catch (e) {
+        throw new errors_1.TicConfigError(`${file} is not valid JSON: ${e.message}`);
+    }
+    return resolveConfig(content, file);
+}

package/cjm/emit.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitBundle = emitBundle;
+const render_1 = require("./render");
+const RUNTIME_IMPORTS = ['IContainer', 'IContainerModule', 'IRegistration', 'Registration'];
+function emitBundle({ name, configPath, namespaces, classes }) {
+    const taken = new Set([...RUNTIME_IMPORTS, 'registrations', name]);
+    const uniqueName = (wanted) => {
+        let candidate = wanted;
+        for (let n = 2; taken.has(candidate); n++)
+            candidate = `${wanted}_${n}`;
+        taken.add(candidate);
+        return candidate;
+    };
+    const byFile = new Map();
+    const bindings = classes.map((cls) => {
+        const binding = uniqueName(cls.localName);
+        const entry = byFile.get(cls.file) ?? { specifier: cls.specifier, named: [] };
+        byFile.set(cls.file, entry);
+        if (cls.exportName === 'default')
+            entry.defaultName = binding;
+        else
+            entry.named.push(binding === cls.exportName ? binding : `${cls.exportName} as ${binding}`);
+        return binding;
+    });
+    return (0, render_1.renderProtocol)('Bundle.ts.hbs', {
+        configPath,
+        namespaces,
+        name,
+        imports: [...byFile.values()],
+        registrations: bindings,
+    });
+}

package/cjm/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceNotFoundError = exports.TicConfigError = exports.TicError = void 0;
+class TicError extends Error {
+    name = 'TicError';
+}
+exports.TicError = TicError;
+class TicConfigError extends TicError {
+    name = 'TicConfigError';
+}
+exports.TicConfigError = TicConfigError;
+class NamespaceNotFoundError extends TicError {
+    name = 'NamespaceNotFoundError';
+}
+exports.NamespaceNotFoundError = NamespaceNotFoundError;

package/cjm/exportPredicate.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPORTS_CONVENTION = void 0;
+exports.findConventionalExportPredicate = findConventionalExportPredicate;
+exports.loadExportPredicate = loadExportPredicate;
+const predicateFile_1 = require("./predicateFile");
+exports.EXPORTS_CONVENTION = (0, predicateFile_1.conventionalNames)('tic.exports');
+function findConventionalExportPredicate(dir) {
+    return (0, predicateFile_1.findConventionalFile)(dir, 'tic.exports');
+}
+function loadExportPredicate(file) {
+    return (0, predicateFile_1.loadPredicateFile)(file, 'ExportPredicate');
+}

package/cjm/glob.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPosix = void 0;
+exports.globToRegExp = globToRegExp;
+function globToRegExp(glob) {
+    let source = '';
+    for (let i = 0; i < glob.length; i++) {
+        const char = glob[i];
+        if (char === '*' && glob[i + 1] === '*') {
+            const slash = glob[i + 2] === '/';
+            source += slash ? '(?:.*/)?' : '.*';
+            i += slash ? 2 : 1;
+        }
+        else if (char === '*') {
+            source += '[^/]*';
+        }
+        else if (char === '?') {
+            source += '[^/]';
+        }
+        else {
+            source += char.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+const toPosix = (file) => file.split('\\').join('/');
+exports.toPosix = toPosix;

package/cjm/inclusion.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INCLUSION_CONVENTION = void 0;
+exports.fileTags = fileTags;
+exports.byTags = byTags;
+exports.findConventionalPredicate = findConventionalPredicate;
+exports.loadInclusionPredicate = loadInclusionPredicate;
+const predicateFile_1 = require("./predicateFile");
+function fileTags(filename) {
+    return filename
+        .slice(filename.lastIndexOf('/') + 1)
+        .split('.')
+        .slice(1, -1);
+}
+function byTags(predicate) {
+    return (context) => predicate(fileTags(context.filename), context);
+}
+exports.INCLUSION_CONVENTION = (0, predicateFile_1.conventionalNames)('tic.include');
+function findConventionalPredicate(dir) {
+    return (0, predicateFile_1.findConventionalFile)(dir, 'tic.include');
+}
+function loadInclusionPredicate(file) {
+    return (0, predicateFile_1.loadPredicateFile)(file, 'InclusionPredicate');
+}

package/cjm/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceNotFoundError = exports.TicConfigError = exports.TicError = exports.globToRegExp = exports.emitBundle = exports.listSourceFiles = exports.findClasses = exports.loadInclusionPredicate = exports.findConventionalPredicate = exports.INCLUSION_CONVENTION = exports.fileTags = exports.byTags = exports.loadExportPredicate = exports.findConventionalExportPredicate = exports.EXPORTS_CONVENTION = exports.ImportPaths = exports.DEFAULT_BUNDLE_NAME = exports.DEFAULT_EXCLUDE = exports.DEFAULT_CONFIG_FILE = exports.resolveConfig = exports.loadConfig = exports.run = exports.build = void 0;
+var build_1 = require("./build");
+Object.defineProperty(exports, "build", { enumerable: true, get: function () { return build_1.build; } });
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return cli_1.run; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return config_1.resolveConfig; } });
+Object.defineProperty(exports, "DEFAULT_CONFIG_FILE", { enumerable: true, get: function () { return config_1.DEFAULT_CONFIG_FILE; } });
+Object.defineProperty(exports, "DEFAULT_EXCLUDE", { enumerable: true, get: function () { return config_1.DEFAULT_EXCLUDE; } });
+Object.defineProperty(exports, "DEFAULT_BUNDLE_NAME", { enumerable: true, get: function () { return config_1.DEFAULT_BUNDLE_NAME; } });
+var ImportPaths_1 = require("./ImportPaths");
+Object.defineProperty(exports, "ImportPaths", { enumerable: true, get: function () { return ImportPaths_1.ImportPaths; } });
+var exportPredicate_1 = require("./exportPredicate");
+Object.defineProperty(exports, "EXPORTS_CONVENTION", { enumerable: true, get: function () { return exportPredicate_1.EXPORTS_CONVENTION; } });
+Object.defineProperty(exports, "findConventionalExportPredicate", { enumerable: true, get: function () { return exportPredicate_1.findConventionalExportPredicate; } });
+Object.defineProperty(exports, "loadExportPredicate", { enumerable: true, get: function () { return exportPredicate_1.loadExportPredicate; } });
+var inclusion_1 = require("./inclusion");
+Object.defineProperty(exports, "byTags", { enumerable: true, get: function () { return inclusion_1.byTags; } });
+Object.defineProperty(exports, "fileTags", { enumerable: true, get: function () { return inclusion_1.fileTags; } });
+Object.defineProperty(exports, "INCLUSION_CONVENTION", { enumerable: true, get: function () { return inclusion_1.INCLUSION_CONVENTION; } });
+Object.defineProperty(exports, "findConventionalPredicate", { enumerable: true, get: function () { return inclusion_1.findConventionalPredicate; } });
+Object.defineProperty(exports, "loadInclusionPredicate", { enumerable: true, get: function () { return inclusion_1.loadInclusionPredicate; } });
+var scan_1 = require("./scan");
+Object.defineProperty(exports, "findClasses", { enumerable: true, get: function () { return scan_1.findClasses; } });
+Object.defineProperty(exports, "listSourceFiles", { enumerable: true, get: function () { return scan_1.listSourceFiles; } });
+var emit_1 = require("./emit");
+Object.defineProperty(exports, "emitBundle", { enumerable: true, get: function () { return emit_1.emitBundle; } });
+var glob_1 = require("./glob");
+Object.defineProperty(exports, "globToRegExp", { enumerable: true, get: function () { return glob_1.globToRegExp; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "TicError", { enumerable: true, get: function () { return errors_1.TicError; } });
+Object.defineProperty(exports, "TicConfigError", { enumerable: true, get: function () { return errors_1.TicConfigError; } });
+Object.defineProperty(exports, "NamespaceNotFoundError", { enumerable: true, get: function () { return errors_1.NamespaceNotFoundError; } });

package/cjm/predicateFile.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conventionalNames = void 0;
+exports.findConventionalFile = findConventionalFile;
+exports.loadPredicateFile = loadPredicateFile;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const EXTENSIONS = ['cjs', 'js', 'mjs', 'ts', 'cts', 'mts'];
+const conventionalNames = (base) => EXTENSIONS.map((ext) => `${base}.${ext}`);
+exports.conventionalNames = conventionalNames;
+function findConventionalFile(dir, base) {
+    return (0, exports.conventionalNames)(base)
+        .map((name) => node_path_1.default.join(dir, name))
+        .find((file) => (0, node_fs_1.existsSync)(file));
+}
+function loadPredicateFile(file, typeName) {
+    if (!(0, node_fs_1.existsSync)(file))
+        throw new errors_1.TicConfigError(`predicate file not found: ${file}`);
+    const loaded = (0, node_module_1.createRequire)(file)(file);
+    const predicate = typeof loaded === 'function' ? loaded : loaded?.default;
+    if (typeof predicate !== 'function') {
+        throw new errors_1.TicConfigError(`${file} must export an ${typeName} function (default export or module.exports)`);
+    }
+    return predicate;
+}

package/cjm/render.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderProtocol = renderProtocol;
+require("../tpl/index.cjs");
+const handlebars_1 = __importDefault(require("handlebars"));
+handlebars_1.default.registerHelper('join', (items, separator) => items.join(separator));
+function renderProtocol(name, data) {
+    const protocol = handlebars_1.default.templates?.[name];
+    if (!protocol)
+        throw new Error(`Protocol not found: ${name}`);
+    return protocol(data);
+}

package/cjm/scan.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSourceFiles = listSourceFiles;
+exports.findClasses = findClasses;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const ts = __importStar(require("typescript"));
+const SOURCE_FILE = /\.(tsx?|mts|cts)$/;
+const DECLARATION_FILE = /\.d\.[mc]?tsx?$/;
+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 (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(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;
+    if (ts.isIdentifier(callee))
+        return imports.get(callee.text) ?? callee.text;
+    if (ts.isPropertyAccessExpression(callee))
+        return callee.name.text;
+    return undefined;
+}
+function nameFromFile(file) {
+    const words = node_path_1.default
+        .basename(file)
+        .split('.')[0]
+        .split(/[^A-Za-z0-9_$]+/)
+        .filter(Boolean);
+    const name = words.map((w) => w[0].toUpperCase() + w.slice(1)).join('');
+    return /^[A-Za-z_$]/.test(name) ? name : `_${name}`;
+}
+function findClasses(file, selector, text = (0, node_fs_1.readFileSync)(file, 'utf8')) {
+    const kind = file.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, false, kind);
+    const imports = new Map();
+    const classes = new Map();
+    const exported = [];
+    for (const statement of source.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            const bindings = statement.importClause?.namedBindings;
+            if (bindings && ts.isNamedImports(bindings)) {
+                for (const el of bindings.elements)
+                    imports.set(el.name.text, (el.propertyName ?? el.name).text);
+            }
+        }
+        else if (ts.isClassDeclaration(statement)) {
+            if (statement.name)
+                classes.set(statement.name.text, statement);
+            if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+                const isDefault = hasModifier(statement, ts.SyntaxKind.DefaultKeyword);
+                exported.push({ node: statement, exportName: isDefault ? 'default' : statement.name.text });
+            }
+        }
+        else if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && !statement.isTypeOnly) {
+            const clause = statement.exportClause;
+            if (clause && ts.isNamedExports(clause)) {
+                for (const el of clause.elements) {
+                    if (!el.isTypeOnly)
+                        exported.push({ node: undefined, local: (el.propertyName ?? el.name).text, exportName: el.name.text });
+                }
+            }
+        }
+        else if (ts.isExportAssignment(statement) && !statement.isExportEquals && ts.isIdentifier(statement.expression)) {
+            exported.push({ node: undefined, local: statement.expression.text, exportName: 'default' });
+        }
+    }
+    const decoratorsOf = (node) => (ts.getDecorators(node) ?? []).map((d) => decoratorName(d, imports)).filter((n) => !!n);
+    return exported
+        .map(({ node, local, exportName }) => ({ node: node ?? (local ? classes.get(local) : undefined), exportName }))
+        .filter((e) => !!e.node)
+        .map(({ node, exportName }) => ({
+        node,
+        exportName,
+        className: node.name?.text ?? nameFromFile(file),
+        decorators: decoratorsOf(node),
+    }))
+        .filter(({ node, exportName, className, decorators }) => {
+        if (hasModifier(node, ts.SyntaxKind.AbstractKeyword))
+            return false;
+        if (selector.export !== 'any' && (exportName === 'default') !== (selector.export === 'default'))
+            return false;
+        if (selector.decorators && !selector.decorators.some((name) => decorators.includes(name)))
+            return false;
+        return !selector.nameGlob || selector.nameGlob.test(className);
+    })
+        .sort((a, b) => a.node.pos - b.node.pos)
+        .map(({ exportName, className, decorators }) => ({
+        file,
+        exportName,
+        localName: exportName === 'default' ? className : exportName,
+        className,
+        isDefault: exportName === 'default',
+        decorators,
+    }));
+}

package/cjm/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });