@ts-ioc-container/bundler 1.4.0 → 2.0.0

package/typings/ImportPaths.d.ts

@@ -1,3 +1,4 @@
+import * as ts from 'typescript';
 interface Alias {
     pattern: string;
     /** Absolute, `/`-separated. */
@@ -11,15 +12,10 @@ export declare class ImportPaths {
     private readonly aliases;
     readonly extension: string;
     /**
-     * Reads `paths` (following `extends`) and the extension imports need under the
-     * tsconfig's `moduleResolution`; `importExtension` overrides the latter.
-     *
-     * @throws {TicConfigError} when a required tsconfig is missing or cannot be parsed.
+     * From a parsed tsconfig's options: its `paths` aliases, and the extension imports need
+     * under its `moduleResolution`; `importExtension` overrides the latter.
      */
-    static load(tsconfig: {
-        file: string;
-        required: boolean;
-    }, importExtension?: string): ImportPaths;
+    static fromOptions(options: ts.CompilerOptions, tsconfigFile: string, importExtension?: string): ImportPaths;
     constructor(aliases: Alias[], extension: string);
     /**
      * The folder a namespace names: a path relative to `baseDir`, or a `paths` alias.
@@ -29,18 +25,10 @@ export declare class ImportPaths {
     resolveNamespace(namespace: string, baseDir: string): string;
     /** The specifier `fromFile` imports `toFile` by: its most specific alias, else a relative path. */
     specifier(fromFile: string, toFile: string): string;
-    /**
-     * The tsconfig `paths` alias `file` is covered by, normalized to its name
-     * (`@app/services/*` -> `app/services`), or `undefined` when no alias covers it.
-     * Used to drop classes by alias (`select.excludeAliases`).
-     */
-    aliasName(file: string): string | undefined;
     private bestAlias;
     private aliasTargets;
     /** A longer matched target prefix is a more specific alias; an exact file alias beats every wildcard. */
     private matchAlias;
 }
-/** The name of a `paths` alias: `@app/services/*` and `@app/services` both become `app/services`. */
-export declare function normalizeAliasName(pattern: string): string;
 export {};
 //# sourceMappingURL=ImportPaths.d.ts.map

package/typings/build.d.ts

@@ -1,16 +1,15 @@
-import { type ExportPredicate } from './exportPredicate.js';
-import { type InclusionPredicate } from './inclusion.js';
+/** The tsconfig a build without a config file extends. */
+export declare const TSCONFIG_FILE = "tsconfig.json";
 export interface BuildOptions {
-    /** Path of `tic.config.json`, relative to `cwd`. Default `tic.config.json`. */
+    /**
+     * Path of the `*.bundle.json` to build, relative to `cwd`. Omitted: build from the
+     * `tsconfig.json` of the package `cwd` is in (see `findPackageRoot`), every setting at its default.
+     */
     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';
@@ -26,20 +25,18 @@ export interface OutputResult {
 export interface BuildResult {
     /** Absolute path of the config that was built. */
     config: string;
-    outputs: OutputResult[];
+    output: 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.
+     * Non-fatal problems found while building, e.g. a `files.exclude` that drops a default
+     * test glob or two selected classes passing the same decorator token.
      */
     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.
+ * Generates the bundle a config describes. Nothing is written unless generation succeeds.
  *
- * @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.
+ * @throws {TicConfigError} when the config or its tsconfig is missing or invalid, or the config has neither `files.paths` nor a tsconfig.
+ * @throws {NamespaceNotFoundError} when a path is neither a folder nor a tsconfig paths alias of one.
  */
-export declare function build({ config, cwd, check, include, filterExports, }?: BuildOptions): BuildResult;
+export declare function build({ config, cwd, check }?: BuildOptions): BuildResult;
 //# sourceMappingURL=build.d.ts.map

package/typings/config.d.ts

@@ -1,120 +1,162 @@
+/**
+ * Which files a bundle reads and parses: the first, cheap stage of selection,
+ * decided by path alone. The candidates are what the extended tsconfig compiles,
+ * or the folders in `paths` when given — they override the tsconfig's file set,
+ * as a child tsconfig's `include` overrides its parent's. A candidate is parsed
+ * when it matches one of `include` and none of `exclude`. Globs are relative to
+ * the config file and `/`-separated. With a file naming convention
+ * (`*.service.ts`), `include` keeps the bundler from reading anything else.
+ */
+export interface FileSelector {
+    /**
+     * Folders to scan instead of the tsconfig's file set: relative to the config file,
+     * or tsconfig `paths` aliases. Required when there is no tsconfig to extend.
+     */
+    paths?: (string | PathConfig)[];
+    /** Globs a file must match one of, e.g. `**\/*.service.ts`. Default: every source file. */
+    include?: string[];
+    /** Globs of files never read. Replaces {@link DEFAULT_EXCLUDE} when given. */
+    exclude?: string[];
+}
+/** A {@link FileSelector} with its defaults filled in and its globs compiled. */
+export interface ResolvedFileSelector {
+    /** `undefined`: the extended tsconfig's file set. */
+    paths?: Required<PathConfig>[];
+    include?: RegExp[];
+    exclude: RegExp[];
+}
 /** 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
+ * Which classes of a parsed file are registered: the second stage of selection,
+ * run on the files {@link FileSelector} let through. 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). */
+    /**
+     * The class must carry one of these decorators, recognised by name (`register`, or a
+     * composed one). Default {@link DEFAULT_DECORATORS}; `[]` requires none.
+     */
     decorators?: string[];
     /** A glob the class name must match, e.g. `*Service`. An anonymous default export is named after its file. */
-    nameGlob?: string;
+    name?: 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.
+     * real registration in the same 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[];
+    excludeName?: string;
 }
 /** A {@link ClassSelector} with its defaults filled in and its globs compiled. */
-export interface ResolvedSelector {
+export interface ResolvedClassSelector {
     export: ExportKind;
     decorators?: string[];
-    nameGlob?: RegExp;
+    name?: RegExp;
     excludeClasses?: string[];
-    excludeNameGlob?: RegExp;
-    excludeAliases?: string[];
+    excludeName?: RegExp;
 }
-export interface NamespaceConfig {
+export interface PathConfig {
     /** 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;
 }
+/**
+ * The shape of `*.bundle.json`: one bundle, built on one tsconfig. A project that
+ * needs several bundles keeps one config file per bundle.
+ */
 export interface BundleConfig {
-    /** The generated file, relative to the config file. */
-    output: string;
-    /** Name of the generated class, an `IContainerModule`. Default `Bundle`. */
-    name?: 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[];
+    $schema?: 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.
+     * The generated file, relative to the config file. Default `<root>/<name>.bundle.ts`:
+     * `<root>` is the tsconfig's `rootDir`, else the common folder of the files it compiles.
+     * Required when there is no tsconfig to extend.
      */
-    additionalExclude?: string[];
+    output?: string;
     /**
-     * A file exporting an `InclusionPredicate`, relative to the config file. Overrides the
-     * conventional `tic.include.*` next to the config.
+     * The bundle's name: letters, digits, `-` and `_`, starting with a letter. Default: the
+     * config file's stem (`production.bundle.json` -> `production`), else {@link DEFAULT_BUNDLE_NAME}.
+     * It names the default output (`production.bundle.ts`) and the generated class,
+     * an `IContainerModule` (`ProductionBundle`, see {@link toClassName}).
      */
-    include?: string;
+    name?: string;
+    /** Tags associated with the bundle. */
+    tags?: string[];
     /**
-     * A file exporting an `ExportPredicate`, relative to the config file. Overrides the
-     * conventional `tic.exports.*` next to the config.
+     * The tsconfig the bundle builds on, like a tsconfig's own `extends`: the source of
+     * its file set, `paths` aliases and import extension. Relative to the config file.
+     * Default `./tsconfig.json`, which may be absent; a tsconfig named here must exist.
      */
-    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;
+    extends?: string;
     /** Extension of generated imports. Inferred from the tsconfig's `moduleResolution` when omitted. */
     importExtension?: string;
-    bundles: BundleConfig[];
+    /** Which files are parsed. Default: what the tsconfig compiles, minus {@link DEFAULT_EXCLUDE}. */
+    files?: FileSelector;
+    /** Which classes of a parsed file are registered. Default: every exported class. */
+    classes?: ClassSelector;
 }
-export declare const DEFAULT_CONFIG_FILE = "tic.config.json";
-export declare const DEFAULT_BUNDLE_NAME = "Bundle";
+/**
+ * A config file is named `<name>.bundle.json`, `<name>.bundle.yaml` or `<name>.bundle.yml`,
+ * e.g. `app.bundle.json`, `production.bundle.yaml`. Every format has the same shape.
+ */
+export declare const CONFIG_FILE_SUFFIXES: string[];
+export declare const DEFAULT_EXTENDS = "./tsconfig.json";
+/** The bundle name when the config file gives none, e.g. building from `tsconfig.json` alone. */
+export declare const DEFAULT_BUNDLE_NAME = "base";
+/** What `classes.decorators` requires when omitted: the library's own `@register`. */
+export declare const DEFAULT_DECORATORS: string[];
 export declare const DEFAULT_EXCLUDE: string[];
-/** A config whose defaults are filled in and whose paths are absolute. */
+/** A {@link BundleConfig} whose defaults are filled in and whose paths are absolute. */
 export interface ResolvedConfig {
+    /** The config file itself. */
     file: string;
     dir: string;
+    /** `undefined`: derived from the tsconfig at build time (see {@link BundleConfig.output}). */
+    output?: string;
+    /** The bundle name: `production` for `production.bundle.json`. */
+    name: string;
+    /** The generated class: `ProductionBundle`. */
+    className: string;
+    tags: string[];
+    /** The extended tsconfig; `required` when the config names it, so it must exist. */
     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. */
+    files: ResolvedFileSelector;
+    classes: ResolvedClassSelector;
+    /** Non-fatal problems found while resolving, e.g. a `files.exclude` that drops a default test glob. */
     warnings: string[];
 }
-export interface ResolvedBundle {
-    output: string;
-    name: 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.
+ * Validates parsed `*.bundle.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;
+/** The generated class for a bundle name: `production` -> `ProductionBundle`, `my-app_v2` -> `MyAppV2Bundle`. */
+export declare function toClassName(name: string): string;
+/**
+ * The root of the package `dir` belongs to: the nearest folder, `dir` or above, with a
+ * `package.json` — the project root in a single-package project, the package in a
+ * monorepo. `dir` itself when no folder above has one.
+ */
+export declare function findPackageRoot(dir: string): string;
+/**
+ * The `*.bundle.{json,yaml,yml}` configs in `dir` (not its sub-folders), sorted by name.
+ *
+ * @throws {TicConfigError} when one bundle is described in two formats, e.g. `app.bundle.json` and `app.bundle.yaml`.
+ */
+export declare function findConfigFiles(dir: string): string[];
 /**
- * Reads and validates a `tic.config.json`.
+ * Reads and validates a `*.bundle.json`, `*.bundle.yaml` or `*.bundle.yml`.
  *
- * @throws {TicConfigError} when the file is missing, is not valid JSON, or does not match the config shape.
+ * @throws {TicConfigError} when the file is missing, cannot be parsed, or does not match the config shape.
  */
 export declare function loadConfig(file: string): ResolvedConfig;
 //# sourceMappingURL=config.d.ts.map

package/typings/emit.d.ts

@@ -4,15 +4,20 @@ export interface EmitInput {
     name: string;
     /** Shown in the header: where the output came from. */
     configPath: string;
-    namespaces: string[];
+    /** The folders scanned; `undefined` when the files came from the extended tsconfig. */
+    paths?: string[];
+    /** Shown in the header when `paths` is `undefined`: the tsconfig the files came from. */
+    tsconfigPath: string;
     classes: (DiscoveredClass & {
         specifier: string;
     })[];
 }
+/** The first line of every generated bundle; marks it as output, never input. */
+export declare const GENERATED_HEADER = "// Generated by `tic build`";
 /**
  * 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;
+export declare function emitBundle({ name, configPath, paths, tsconfigPath, classes }: EmitInput): string;
 //# sourceMappingURL=emit.d.ts.map

package/typings/errors.d.ts

@@ -2,7 +2,7 @@
 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. */
+/** The config file is missing, is not JSON, or does not match the `.bundles.json` shape. */
 export declare class TicConfigError extends TicError {
     name: string;
 }

package/typings/index.d.ts

@@ -1,12 +1,10 @@
-export { build, type BuildOptions, type BuildResult, type OutputResult, type OutputStatus } from './build.js';
+export { build, TSCONFIG_FILE, type BuildOptions, type BuildResult, type OutputResult, type OutputStatus, } from './build.js';
 export { run, type CliIo } from './cli.js';
-export { loadConfig, resolveConfig, DEFAULT_CONFIG_FILE, DEFAULT_EXCLUDE, DEFAULT_BUNDLE_NAME, type TicConfig, type BundleConfig, type NamespaceConfig, type ClassSelector, type ExportKind, type ResolvedSelector, type ResolvedConfig, type ResolvedBundle, } from './config.js';
+export { loadConfig, resolveConfig, CONFIG_FILE_SUFFIXES, findConfigFiles, findPackageRoot, DEFAULT_EXTENDS, DEFAULT_EXCLUDE, DEFAULT_BUNDLE_NAME, DEFAULT_DECORATORS, toClassName, type BundleConfig, type PathConfig, type ClassSelector, type ExportKind, type ResolvedClassSelector, type FileSelector, type ResolvedFileSelector, type ResolvedConfig, } from './config.js';
 export { ImportPaths } from './ImportPaths.js';
-export { type FilterPredicate } from './utils.js';
-export { type ExportPredicate, type ExportContext, EXPORTS_CONVENTION, findConventionalExportPredicate, loadExportPredicate, } from './exportPredicate.js';
-export { type InclusionPredicate, type InclusionContext, type TagInclusionPredicate, byTags, fileTags, INCLUSION_CONVENTION, findConventionalPredicate, loadInclusionPredicate, } from './inclusion.js';
-export { findClasses, listSourceFiles, type DiscoveredClass } from './scan.js';
-export { emitBundle, type EmitInput } from './emit.js';
+export { loadTsconfig, type ExtendedTsconfig } from './tsconfig.js';
+export { findClasses, isSourceFile, listSourceFiles, type DiscoveredClass } from './scan.js';
+export { emitBundle, GENERATED_HEADER, type EmitInput } from './emit.js';
 export { globToRegExp } from './glob.js';
 export { TicError, TicConfigError, NamespaceNotFoundError } from './errors.js';
 //# sourceMappingURL=index.d.ts.map

package/typings/scan.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedSelector } from './config.js';
+import type { ResolvedClassSelector } from './config.js';
 /** An exported class the generated bundle registers. */
 export interface DiscoveredClass {
     file: string;
@@ -27,11 +27,13 @@ export interface DiscoveredClass {
         args: string[];
     }[];
 }
+/** A TypeScript source file the bundler may parse: not a declaration file. */
+export declare const isSourceFile: (file: string) => boolean;
 /** Source files of `dir`, sorted by path so the generated output is stable across machines. */
 export declare function listSourceFiles(dir: string, recursive: boolean, isExcluded: (file: string) => boolean): string[];
 /**
  * The exported, non-abstract classes of one file that `selector` selects, in
  * declaration order. Syntax only: decorators are recognised by name, not by type.
  */
-export declare function findClasses(file: string, selector: ResolvedSelector, text?: string): DiscoveredClass[];
+export declare function findClasses(file: string, selector: ResolvedClassSelector, text?: string): DiscoveredClass[];
 //# sourceMappingURL=scan.d.ts.map

package/typings/tsconfig.d.ts

@@ -0,0 +1,25 @@
+import { ImportPaths } from './ImportPaths.js';
+/** What a bundle takes from the tsconfig it extends. */
+export interface ExtendedTsconfig {
+    importPaths: ImportPaths;
+    /** Absolute paths of the files the tsconfig compiles; `undefined` when there is no tsconfig. */
+    fileNames?: string[];
+    /**
+     * Where the sources live, as tsc sees it: `rootDir`, else the longest common folder of
+     * the non-declaration files it compiles, else the tsconfig's folder. `undefined` when
+     * there is no tsconfig.
+     */
+    rootDir?: string;
+}
+/**
+ * Reads the tsconfig a bundle extends, following its own `extends`: its `paths` aliases,
+ * import extension and file set (`files` / `include` / `exclude`). An absent tsconfig that
+ * was not named explicitly yields no aliases and no file set.
+ *
+ * @throws {TicConfigError} when a required tsconfig is missing or cannot be parsed.
+ */
+export declare function loadTsconfig(tsconfig: {
+    file: string;
+    required: boolean;
+}, importExtension?: string): ExtendedTsconfig;
+//# sourceMappingURL=tsconfig.d.ts.map

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/utils.js

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

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

package/typings/utils.d.ts

@@ -1,3 +0,0 @@
-/** Decides whether a value is kept. The base of every predicate the bundler takes. */
-export type FilterPredicate<Target> = (value: Target) => boolean;
-//# sourceMappingURL=utils.d.ts.map