@ts-ioc-container/bundler 2.0.0 → 3.0.0

package/typings/config.d.ts

@@ -1,162 +0,0 @@
-/**
- * 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';
-/**
- * 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). 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. */
-    name?: string;
-    /**
-     * Class names to drop after selection, e.g. one test double sitting next to the
-     * 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. */
-    excludeName?: string;
-}
-/** A {@link ClassSelector} with its defaults filled in and its globs compiled. */
-export interface ResolvedClassSelector {
-    export: ExportKind;
-    decorators?: string[];
-    name?: RegExp;
-    excludeClasses?: string[];
-    excludeName?: RegExp;
-}
-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 {
-    $schema?: string;
-    /**
-     * 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.
-     */
-    output?: string;
-    /**
-     * 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}).
-     */
-    name?: string;
-    /** Tags associated with the bundle. */
-    tags?: string[];
-    /**
-     * 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.
-     */
-    extends?: string;
-    /** Extension of generated imports. Inferred from the tsconfig's `moduleResolution` when omitted. */
-    importExtension?: string;
-    /** 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;
-}
-/**
- * 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 {@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;
-    files: ResolvedFileSelector;
-    classes: ResolvedClassSelector;
-    /** Non-fatal problems found while resolving, e.g. a `files.exclude` that drops a default test glob. */
-    warnings: string[];
-}
-/**
- * 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 `*.bundle.json`, `*.bundle.yaml` or `*.bundle.yml`.
- *
- * @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

@@ -1,23 +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;
-    /** 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, paths, tsconfigPath, 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 `.bundles.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/render.d.ts

@@ -1,8 +0,0 @@
-import '../tpl/index.cjs';
-/**
- * Renders a precompiled protocol, looked up by its file basename (`Bundle.ts.hbs`).
- *
- * @throws {Error} when no protocol is registered under `name`.
- */
-export declare function renderProtocol(name: string, data: unknown): string;
-//# sourceMappingURL=render.d.ts.map

package/typings/tsconfig.d.ts

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