@ts-ioc-container/bundler 1.5.0 → 2.1.0

package/cjm/cli.js

@@ -1,84 +0,0 @@
-"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, 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 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

@@ -1,162 +0,0 @@
-"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',
-    'excludeClasses',
-    'excludeNameGlob',
-    'excludeAliases',
-]);
-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, 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');
-    }
-    if (excludeAliases !== undefined && !(isStringArray(excludeAliases) && excludeAliases.length > 0)) {
-        return fail(`${field}.excludeAliases`, 'a non-empty 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,
-    };
-}
-function toBundle(value, field, dir) {
-    if (!isObject(value))
-        return fail(field, 'an object');
-    const { output, name, tags, 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 (tags !== undefined && !isStringArray(tags))
-        return fail(`${field}.tags`, 'an array of strings');
-    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');
-    }
-    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,
-        tags: tags ?? [],
-        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),
-    };
-}
-function excludeWarnings(value, field) {
-    if (!isObject(value))
-        return [];
-    const exclude = value.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`,
-    ];
-}
-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)),
-        warnings: bundles.flatMap((m, i) => excludeWarnings(m, `bundles[${i}]`)),
-    };
-}
-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/errors.js

@@ -1,15 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-"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/inclusion.js

@@ -1,24 +0,0 @@
-"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/predicateFile.js

@@ -1,30 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-"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/utils.js

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

package/typings/build.d.ts

@@ -1,45 +0,0 @@
-import { type ExportPredicate } from './exportPredicate.js';
-import { type InclusionPredicate } from './inclusion.js';
-export interface BuildOptions {
-    /** Path of `tic.config.json`, relative to `cwd`. Default `tic.config.json`. */
-    config?: string;
-    /** Default `process.cwd()`. */
-    cwd?: string;
-    /** Compare instead of writing: outputs that would change are reported `stale`. */
-    check?: boolean;
-    /** Decides which scanned files take part; overrides every inclusion predicate file. */
-    include?: InclusionPredicate;
-    /** Decides which parsed classes become registrations; overrides every export predicate file. */
-    filterExports?: ExportPredicate;
-}
-/** `written` / `unchanged` after a build; `stale` / `unchanged` after a check. */
-export type OutputStatus = 'written' | 'unchanged' | 'stale';
-export interface OutputResult {
-    /** Absolute path of the generated file. */
-    file: string;
-    /** Name of the generated class. */
-    bundle: string;
-    status: OutputStatus;
-    registrations: number;
-    content: string;
-}
-export interface BuildResult {
-    /** Absolute path of the config that was built. */
-    config: string;
-    outputs: OutputResult[];
-    /**
-     * Non-fatal problems found while building, e.g. an `exclude` that drops a default
-     * test glob or two selected classes passing the same decorator token. Each warning
-     * names the bundle field it belongs to.
-     */
-    warnings: string[];
-}
-/**
- * Generates one bundle per config entry. Every bundle is generated before any
- * file is written, so a failing namespace leaves the previous outputs intact.
- *
- * @throws {TicConfigError} when the config, the tsconfig or a predicate file it names is missing or invalid.
- * @throws {NamespaceNotFoundError} when a namespace is neither a folder nor a tsconfig paths alias of one.
- */
-export declare function build({ config, cwd, check, include, filterExports, }?: BuildOptions): BuildResult;
-//# sourceMappingURL=build.d.ts.map

package/typings/cli.d.ts

@@ -1,8 +0,0 @@
-export interface CliIo {
-    cwd: string;
-    stdout: (line: string) => void;
-    stderr: (line: string) => void;
-}
-/** Runs the `tic` CLI and returns its exit code; output goes through `io`. */
-export declare function run(argv: string[], io?: CliIo): number;
-//# sourceMappingURL=cli.d.ts.map

package/typings/config.d.ts

@@ -1,123 +0,0 @@
-/** Which exports of a file count: both kinds, only named exports, or only the default export. */
-export type ExportKind = 'any' | 'named' | 'default';
-/**
- * How the bundler picks target classes out of a file. A class is selected when
- * it is exported, not abstract, and meets every criterion set here; an empty
- * rule selects every exported class.
- */
-export interface ClassSelector {
-    /** Default `any`. */
-    export?: ExportKind;
-    /** The class must carry one of these decorators, recognised by name (`register`, or a composed one). */
-    decorators?: string[];
-    /** A glob the class name must match, e.g. `*Service`. An anonymous default export is named after its file. */
-    nameGlob?: string;
-    /**
-     * Class names to drop after selection, e.g. one test double sitting next to the
-     * real registration in the same file. Unlike `filterExports` this needs no file.
-     */
-    excludeClasses?: string[];
-    /** A glob the class name must NOT match, e.g. `*Mock`. An anonymous default export is named after its file. */
-    excludeNameGlob?: string;
-    /**
-     * tsconfig `paths` aliases to drop after selection: a class whose file resolves
-     * through one of these aliases is dropped, e.g. `["services"]` for a `services/*`
-     * (or `@services/*`) alias. Names may omit a leading `@` and a trailing `/*`.
-     */
-    excludeAliases?: string[];
-}
-/** A {@link ClassSelector} with its defaults filled in and its globs compiled. */
-export interface ResolvedSelector {
-    export: ExportKind;
-    decorators?: string[];
-    nameGlob?: RegExp;
-    excludeClasses?: string[];
-    excludeNameGlob?: RegExp;
-    excludeAliases?: string[];
-}
-export interface NamespaceConfig {
-    /** A folder relative to the config file (`./src/services`) or a tsconfig `paths` alias (`@app/services`). */
-    path: string;
-    /** Scan sub-folders too. Default `true`. */
-    recursive?: boolean;
-}
-export interface BundleConfig {
-    /** The generated file, relative to the config file. */
-    output: string;
-    /** Name of the generated class, an `IContainerModule`. Default `Bundle`. */
-    name?: string;
-    /** Tags associated with the bundle. */
-    tags?: string[];
-    namespaces: (string | NamespaceConfig)[];
-    /** Which classes of a scanned file are registered. Default: every exported class. */
-    select?: ClassSelector;
-    /** Globs, relative to the config file, of files never scanned. Replaces {@link DEFAULT_EXCLUDE} when given. */
-    exclude?: string[];
-    /**
-     * Globs, relative to the config file, of files never scanned, added on top of
-     * `exclude` (or {@link DEFAULT_EXCLUDE} when `exclude` is omitted). Use this to
-     * add one exclusion without restating the defaults.
-     */
-    additionalExclude?: string[];
-    /**
-     * A file exporting an `InclusionPredicate`, relative to the config file. Overrides the
-     * conventional `tic.include.*` next to the config.
-     */
-    include?: string;
-    /**
-     * A file exporting an `ExportPredicate`, relative to the config file. Overrides the
-     * conventional `tic.exports.*` next to the config.
-     */
-    filterExports?: string;
-}
-/** The shape of `tic.config.json`. */
-export interface TicConfig {
-    $schema?: string;
-    /** Relative to the config file. Default `tsconfig.json`, which may be absent. */
-    tsconfig?: string;
-    /** Extension of generated imports. Inferred from the tsconfig's `moduleResolution` when omitted. */
-    importExtension?: string;
-    bundles: BundleConfig[];
-}
-export declare const DEFAULT_CONFIG_FILE = "tic.config.json";
-export declare const DEFAULT_BUNDLE_NAME = "Bundle";
-export declare const DEFAULT_EXCLUDE: string[];
-/** A config whose defaults are filled in and whose paths are absolute. */
-export interface ResolvedConfig {
-    file: string;
-    dir: string;
-    tsconfig: {
-        file: string;
-        required: boolean;
-    };
-    importExtension?: string;
-    bundles: ResolvedBundle[];
-    /** Non-fatal problems found while resolving, e.g. an `exclude` that drops a default test glob. */
-    warnings: string[];
-}
-export interface ResolvedBundle {
-    output: string;
-    name: string;
-    tags: string[];
-    namespaces: Required<NamespaceConfig>[];
-    select: ResolvedSelector;
-    /** The effective list: the configured `exclude` (or the defaults) followed by `additionalExclude`. */
-    exclude: string[];
-    /** Absolute path of the bundle's own predicate file, when it names one. */
-    include?: string;
-    /** Absolute path of the bundle's own export predicate file, when it names one. */
-    filterExports?: string;
-}
-/**
- * Validates parsed `tic.config.json` content and resolves its paths against `file`'s directory.
- *
- * @throws {TicConfigError} when the content does not match the config shape; the message names the field.
- */
-export declare function resolveConfig(content: unknown, file: string): ResolvedConfig;
-/**
- * Reads and validates a `tic.config.json`.
- *
- * @throws {TicConfigError} when the file is missing, is not valid JSON, or does not match the config shape.
- */
-export declare function loadConfig(file: string): ResolvedConfig;
-//# sourceMappingURL=config.d.ts.map

package/typings/emit.d.ts

@@ -1,18 +0,0 @@
-import type { DiscoveredClass } from './scan.js';
-export interface EmitInput {
-    /** Name of the generated class. */
-    name: string;
-    /** Shown in the header: where the output came from. */
-    configPath: string;
-    namespaces: string[];
-    classes: (DiscoveredClass & {
-        specifier: string;
-    })[];
-}
-/**
- * Renders the generated bundle — static imports, `registrations`, and the bundle applying them —
- * from its protocol, `protocols/Bundle.ts.hbs`. This function only prepares the data: unique local
- * names, and one import per file in file order.
- */
-export declare function emitBundle({ name, configPath, namespaces, classes }: EmitInput): string;
-//# sourceMappingURL=emit.d.ts.map

package/typings/errors.d.ts

@@ -1,13 +0,0 @@
-/** Base class of every error the bundler raises on purpose; the CLI prints its message without a stack. */
-export declare class TicError extends Error {
-    name: string;
-}
-/** The config file is missing, is not JSON, or does not match the `tic.config.json` shape. */
-export declare class TicConfigError extends TicError {
-    name: string;
-}
-/** A namespace is neither an existing folder nor a `tsconfig.json` `paths` alias of one. */
-export declare class NamespaceNotFoundError extends TicError {
-    name: string;
-}
-//# sourceMappingURL=errors.d.ts.map

package/typings/exportPredicate.d.ts

@@ -1,36 +0,0 @@
-import type { FilterPredicate } from './utils.js';
-/** What an {@link ExportPredicate} decides on: one exported class of a parsed file. */
-export interface ExportContext {
-    /** The file's path relative to the config file, `/`-separated: `src/services/Logger.ts`. */
-    filename: string;
-    /** The name the class is exported under; `'default'` for a default export. */
-    exportName: string;
-    /** The declared class name; an anonymous default export is named after its file. */
-    className: string;
-    isDefault: boolean;
-    /** Names of the class's decorators, renamed imports resolved (`register as reg` -> `'register'`). */
-    decorators: string[];
-    /** The file-name tags `byTags` reads: `Report.production.eu.ts` -> `['production', 'eu']`. */
-    tags: string[];
-}
-/**
- * Decides, right after a file is parsed, whether one of its exported classes becomes a
- * registration. It runs on every exported, non-abstract class that passes `select`.
- *
- * @example
- * // tic.exports.ts, next to tic.config.json - picked up by convention
- * const filterExports: ExportPredicate = ({ exportName }) => !/(Stub|Mock|Fake)$/.test(exportName);
- * export default filterExports;
- */
-export type ExportPredicate = FilterPredicate<ExportContext>;
-/** Export predicate files looked up next to the config, in this order, when no bundle names one. */
-export declare const EXPORTS_CONVENTION: string[];
-/** The conventional export predicate file in `dir`, if there is one. */
-export declare function findConventionalExportPredicate(dir: string): string | undefined;
-/**
- * Loads an {@link ExportPredicate} file (see `loadPredicateFile` for formats and caching).
- *
- * @throws {TicConfigError} when the file is missing or does not export a function.
- */
-export declare function loadExportPredicate(file: string): ExportPredicate;
-//# sourceMappingURL=exportPredicate.d.ts.map

package/typings/inclusion.d.ts

@@ -1,42 +0,0 @@
-import type { FilterPredicate } from './utils.js';
-/** What an {@link InclusionPredicate} decides on. */
-export interface InclusionContext {
-    /** The file's path relative to the config file, `/`-separated: `src/services/Logger.ts`. */
-    filename: string;
-}
-/**
- * Decides whether a scanned file takes part in code generation. A file takes
- * part only when it matches no `exclude` glob and the predicate returns `true`.
- *
- * @example
- * // tic.include.ts, next to tic.config.json - picked up by convention
- * const include: InclusionPredicate = ({ filename }) => !filename.includes('/legacy/');
- * export default include;
- */
-export type InclusionPredicate = FilterPredicate<InclusionContext>;
-/**
- * An {@link InclusionPredicate} over a file's tags, the dot-separated parts of its name between
- * the base name and the extension. Wrap it with {@link byTags} to use it anywhere an
- * `InclusionPredicate` goes.
- *
- * @example
- * // StripeGateway.production.ts joins production only; Shared.ts joins every environment
- * const ENVS = ['development', 'production', 'test'];
- * export default byTags((tags) => tags.filter((t) => ENVS.includes(t)).every((t) => t === process.env.TIC_ENV));
- */
-export type TagInclusionPredicate = (tags: string[], context: InclusionContext) => boolean;
-/** `src/Report.production.eu.ts` -> `['production', 'eu']`; `src/Shared.ts` -> `[]`. */
-export declare function fileTags(filename: string): string[];
-/** Wraps a {@link TagInclusionPredicate} into the {@link InclusionPredicate} the bundler calls. */
-export declare function byTags(predicate: TagInclusionPredicate): InclusionPredicate;
-/** Predicate files looked up next to the config, in this order, when no bundle names one. */
-export declare const INCLUSION_CONVENTION: string[];
-/** The conventional inclusion predicate file in `dir`, if there is one. */
-export declare function findConventionalPredicate(dir: string): string | undefined;
-/**
- * Loads an {@link InclusionPredicate} file (see `loadPredicateFile` for formats and caching).
- *
- * @throws {TicConfigError} when the file is missing or does not export a function.
- */
-export declare function loadInclusionPredicate(file: string): InclusionPredicate;
-//# sourceMappingURL=inclusion.d.ts.map

package/typings/predicateFile.d.ts

@@ -1,16 +0,0 @@
-import type { FilterPredicate } from './utils.js';
-/** `tic.include` -> `tic.include.cjs`, `tic.include.js`, ... in lookup order. */
-export declare const conventionalNames: (base: string) => string[];
-/** The first conventional file for `base` that exists in `dir`, if any. */
-export declare function findConventionalFile(dir: string, base: string): string | undefined;
-/**
- * Loads a predicate file synchronously with `require` - `.cjs` / `.js`, ES modules
- * (Node 22.12+) and `.ts` (Node with type stripping). Its default export, or
- * `module.exports` itself, is the predicate. Like any `require`d module it is loaded
- * once per process, so a predicate that depends on the environment should read it
- * when called, not when loaded.
- *
- * @throws {TicConfigError} when the file is missing or does not export a function.
- */
-export declare function loadPredicateFile<T extends FilterPredicate<never>>(file: string, typeName: string): T;
-//# sourceMappingURL=predicateFile.d.ts.map