@tochii/build 2.5.0 → 2.6.0

package/dist/index.d.mts

@@ -1,12 +1,203 @@
+// ---- index.d.mts ----
 import * as tsup from 'tsup';
-import { B as BuildUtils$1 } from './utils-dsfZeRyj.mjs';
+import { build as build$1 } from 'tsup';
+export { Format, NormalizedOptions, Options } from 'tsup';
+
+declare module '@npmcli/arborist' {
+    export interface Node {
+        name: string;
+        path: string;
+        realpath: string;
+        package: Record<string, any>;
+        isLink?: boolean;
+        isRoot?: boolean;
+        children?: Map<string, Node>;
+    }
+
+    export default class Arborist {
+        constructor(options: { path: string });
+        loadActual(): Promise<Node>;
+    }
+}
+
+declare module 'npm-packlist' {
+    export default function packlist(tree: {
+        name: string;
+        path: string;
+        realpath: string;
+        package: Record<string, any>;
+        isLink?: boolean;
+        isRoot?: boolean;
+        children?: Map<string, any>;
+    }): Promise<string[]>;
+}
+
+/**
+ * Creates a tarball from a package
+ *
+ * @param options - options to customize the tarball
+ * @returns an object containing the tarball path and included files
+ */
+declare function createTarball({ packageDir, packageJsonData, outputTarballPath }: PublishCreateOptions): Promise<PublishCreateResult>;
+
+/**
+ * Merges the contents of all files from the `files` array into `outFile`
+ * @param files array of file paths or glob patterns (glob supported)
+ * @param outFile destination file to write merged content (relative/absolute)
+ * @param onResolvedFiles optional callback that is called after files are resolved and validated
+ */
+declare function mergeFiles(files: string[], outFile: string, onResolvedFiles?: (resolvedFiles: string[]) => void): Promise<void>;
+
+declare class BuildUtils$1 {
+    /**
+     * The default build options
+     */
+    static readonly defaultConfigOptions: BuildOptions;
+    /**
+     * Array of commonly ignored entries
+     */
+    static readonly ignoredEntries: string[];
+    /**
+     * Aray of commonly used entries
+     */
+    static readonly entriesCommon: string[];
+    /**
+     * Array of index entries
+     */
+    static readonly entriesIndex: string[];
+    /**
+     * Array of default entries including index files and commonly ignored entries
+     */
+    static readonly defaultEntriesIndex: string[];
+    /**
+     * Array of default entries including any .ts files and commonly ignored entries
+     */
+    static readonly defaultEntriesCommon: string[];
+    /**
+     * Default options
+     *
+     * See all available options here: https://www.jsdocs.io/package/tsup#Options
+     *
+     * @default '{ tsconfig: "tsconfig.json", dts: true, format: ["esm"], minify: true }'
+     * @param options configuration with entry, clean and splitting as required properties to avoid unintended behaviour
+     * @param config (optional) configure tochibuild behaviour
+     * @param throwErr (optional) whether or not to throw an error if something goes wrong
+     * @param isCli (optional) whether or not this is being called from the CLI
+     */
+    static readonly handleOptions: (options: BuildOptionsParams<"entry" | "clean" | "splitting">, config?: TochibuildConfig, throwErr?: boolean, isCli?: boolean) => any;
+    /**
+     * Default options for index files as entry
+     *
+     * See all available options here: https://www.jsdocs.io/package/tsup#Options
+     *
+     * @default '{ entry: BuildUtils.defaultEntriesIndex, tsconfig: "tsconfig.json", dts: true, format: ["esm"], minify: true }'
+     * @param options configuration with clean and splitting as required properties to avoid unintended behaviour
+     * @param config (optional) configure tochibuild behaviour
+     * @param throwErr (optional) whether or not to throw an error if something goes wrong
+     * @param isCli (optional) whether or not this is being called from the CLI
+     */
+    static readonly handleOptionsWithIndexEntries: (options: BuildOptionsParams<"clean" | "splitting">, config?: TochibuildConfig, throwErr?: boolean, isCli?: boolean) => any;
+    /**
+     * Default options for common files as entry
+     *
+     * See all available options here: https://www.jsdocs.io/package/tsup#Options
+     *
+     * @default '{ entry: BuildUtils.defaultEntriesCommon, tsconfig: "tsconfig.json", dts: true, format: ["esm"], minify: true }'
+     * @param options configuration with clean and splitting as required properties to avoid unintended behaviour
+     * @param config (optional) configure tochibuild behaviour
+     * @param throwErr (optional) whether or not to throw an error if something goes wrong
+     * @param isCli (optional) whether or not this is being called from the CLI
+     */
+    static readonly handleOptionsWithCommonEntries: (options: BuildOptionsParams<"clean" | "splitting">, config?: TochibuildConfig, throwErr?: boolean, isCli?: boolean) => any;
+    static readonly generateConfig: typeof generateConfig;
+    static readonly ensureEntries: typeof ensureEntries;
+    static readonly createTarball: typeof createTarball;
+    static readonly mergeFiles: typeof mergeFiles;
+    /**
+     * Merge build options
+     *
+     * @param options the primary build options
+     * @param config configure the overriding options and how to merge them
+     * @param throwErr (optional) whether or not to throw an error if something goes wrong
+     * @param isCli (optional) whether or not this is being called from the CLI
+     */
+    static readonly mergeBuildOptions: <TRequiredKeys extends keyof (BuildOptions | BuildOptionsWithConfig) = any, TOpts extends BuildOptionsResult<TRequiredKeys> | BuildOptionsParams<TRequiredKeys> = BuildOptionsParams<TRequiredKeys>>(options: TOpts, config: MergeBuildOptionsConfig, throwErr?: boolean, isCli?: boolean) => any;
+    /**
+     * Merge build options asynchronously
+     *
+     * @param options the primary build options
+     * @param config configure the overriding options and how to merge them
+     * @param throwErr (optional) whether or not to throw an error if something goes wrong
+     * @param isCli (optional) whether or not this is being called from the CLI
+     */
+    static readonly mergeBuildOptionsAsync: <TOpts extends BuildOptionsResult | BuildOptionsParams, TConfig extends MergeBuildOptionsConfigAsync>(options: TOpts, config: TConfig, throwErr?: boolean, isCli?: boolean) => Promise<any>;
+    /**
+     * Get the file path and json data from a package.json
+     *
+     * If no rootDir is passed or if it's undefined, then the current working directory will be used
+     *
+     * @param rootDir the directory the package.json is in
+     * @param throwErr whether or not to throw an error if something goes wrong
+     */
+    static readonly getPackageJson: <TPackageJson extends Record<string, any> = Record<string, any>>(rootDir?: string, throwErr?: boolean) => {
+        filePath: string | undefined;
+        data: TPackageJson | undefined;
+    };
+    /**
+     * Get dependencies from a package.json file using config
+     *
+     * @param config configuration from {@link TochibuildConfig}
+     * @param packageJsonPath the package.json file path
+     */
+    static readonly getPackageJsonDepsEntriesFromConfig: (config: TochibuildConfig | undefined, packageJsonPath?: string) => string[];
+    /**
+     * Get dependencies from a package.json file as entries
+     *
+     * @param packageJsonPath the package.json file path
+     * @param filter the types of dependencies to include
+     */
+    static readonly getPackageJsonDepsEntries: (packageJsonPath: string | undefined, filter?: ("dependencies" | "devDependencies" | "peerDependencies")[]) => string[];
+    /**
+     * Get dependencies from a package.json file
+     *
+     * @param packageJsonPath the package.json file path
+     * @param filter the types of dependencies to include
+     */
+    static readonly getPackageJsonDeps: (packageJsonPath: string | undefined) => {
+        toArray: (filter?: ("dependencies" | "devDependencies" | "peerDependencies")[]) => string[];
+        dependencies: any;
+        devDependencies: any;
+        peerDependencies: any;
+    };
+}
+
+/**
+ * Ensures that the passed entries includes the certain ones
+ *
+ * NOTE: only works for string arrays (otherwise will return the same entry) and will not overwrite or duplicate the entries
+ *
+ * @param entry the entries to check
+ * @param type the type of entries to ensure
+ */
+declare function ensureEntries(entry: BuildOptions['entry'], type: ('ignoredEntries' | 'entriesIndex' | 'entriesCommon' | 'defaultEntriesIndex' | 'defaultEntriesCommon')[]): BuildOptions['entry'];
+/**
+ * Generate a config file
+ *
+ * @param cliModule which module to use
+ * @param options (optional) configure how to generate the config
+ * @param throwErr (optional) whether or not to throw an error if something goes wrong
+ * @param isCli (optional) whether or not this is being called from the CLI
+ */
+declare function generateConfig(cliModule: CLIModule, options?: GenerateConfigOptionsCLI, throwErr?: boolean, isCli?: boolean): void;
 
 type DefineConfigOptions = BuildOptionsParams<'entry' | 'clean' | 'splitting'>;
 type DefineConfigOptionsIndexEntries = BuildOptionsParams<'clean' | 'splitting'>;
 type DefineConfigOptionsCommonEntries = BuildOptionsParams<'clean' | 'splitting'>;
 declare const BuildUtils: typeof BuildUtils$1;
+declare const build: typeof build$1;
 declare const _default: {
     utils: typeof BuildUtils$1;
+    build: typeof build$1;
     defineConfig: typeof defineConfig;
     defineConfigWithIndexEntries: typeof defineConfigWithIndexEntries;
     defineConfigWithCommonEntries: typeof defineConfigWithCommonEntries;
@@ -19,8 +210,9 @@ declare const _default: {
  *
  * @default '{ tsconfig: "tsconfig.json", dts: true, format: ["esm"], minify: true }'
  * @param options configuration with entry, clean and splitting as required properties to avoid unintended behaviour
+ * @param config (optional) configure tochibuild behaviour
  */
-declare function defineConfig(options: DefineConfigOptions): tsup.Options | tsup.Options[] | ((overrideOptions: tsup.Options) => tsup.Options | tsup.Options[] | Promise<tsup.Options | tsup.Options[]>);
+declare function defineConfig(options: DefineConfigOptions, config?: TochibuildConfig): Promise<tsup.Options | tsup.Options[] | ((overrideOptions: tsup.Options) => tsup.Options | tsup.Options[] | Promise<tsup.Options | tsup.Options[]>)>;
 /**
  * Define tochibuild configuration with index files as entry
  *
@@ -28,8 +220,9 @@ declare function defineConfig(options: DefineConfigOptions): tsup.Options | tsup
  *
  * @default '{ entry: BuildUtils.defaultEntriesIndex, tsconfig: "tsconfig.json", dts: true, format: ["esm"], minify: true }'
  * @param options configuration with clean and splitting as required properties to avoid unintended behaviour
+ * @param config (optional) configure tochibuild behaviour
  */
-declare function defineConfigWithIndexEntries(options: DefineConfigOptionsIndexEntries): tsup.Options | tsup.Options[] | ((overrideOptions: tsup.Options) => tsup.Options | tsup.Options[] | Promise<tsup.Options | tsup.Options[]>);
+declare function defineConfigWithIndexEntries(options: DefineConfigOptionsIndexEntries, config?: TochibuildConfig): Promise<tsup.Options | tsup.Options[] | ((overrideOptions: tsup.Options) => tsup.Options | tsup.Options[] | Promise<tsup.Options | tsup.Options[]>)>;
 /**
  * Define tochibuild configuration with common files as entry
  *
@@ -37,7 +230,1127 @@ declare function defineConfigWithIndexEntries(options: DefineConfigOptionsIndexE
  *
  * @default '{ entry: BuildUtils.defaultEntriesCommon, tsconfig: "tsconfig.json", dts: true, format: ["esm"], minify: true }'
  * @param options configuration with clean and splitting as required properties to avoid unintended behaviour
+ * @param config (optional) configure tochibuild behaviour
  */
-declare function defineConfigWithCommonEntries(options: DefineConfigOptionsCommonEntries): tsup.Options | tsup.Options[] | ((overrideOptions: tsup.Options) => tsup.Options | tsup.Options[] | Promise<tsup.Options | tsup.Options[]>);
+declare function defineConfigWithCommonEntries(options: DefineConfigOptionsCommonEntries, config?: TochibuildConfig): Promise<tsup.Options | tsup.Options[] | ((overrideOptions: tsup.Options) => tsup.Options | tsup.Options[] | Promise<tsup.Options | tsup.Options[]>)>;
+
+export { BuildUtils, type DefineConfigOptions, type DefineConfigOptionsCommonEntries, type DefineConfigOptionsIndexEntries, build, _default as default, defineConfig, defineConfigWithCommonEntries, defineConfigWithIndexEntries };
+
+
+// ---- cli.d.ts ----
+/// <reference types="commander" />
+
+type CLICommand = import('commander').Command;
+type CLIModule = '@tochii/build' | 'tochibuild';
+
+type CommandHandler = (cliModule: CLIModule, program: CLICommand) => MaybePromise<void>;
+
+type BuildOptionsCliFlag = keyof BuildOptionsCliFlagMap | '--no-config' | (string & {});
+
+/**
+ * Maps CLI flags (both long and short versions) to their corresponding {@link BuildOptions} property keys.
+ */
+interface BuildOptionsCliFlagMap extends Record<string, keyof BuildOptions> {
+    // output directory
+    '-d': 'outDir';
+    '--out-dir': 'outDir';
+
+    // format
+    '--format': 'format';
+
+    // minification
+    '--minify': 'minify';
+    '--minify-whitespace': 'minifyWhitespace';
+    '--minify-identifiers': 'minifyIdentifiers';
+    '--minify-syntax': 'minifySyntax';
+
+    // misc flags
+    '--keep-names': 'keepNames';
+    '--target': 'target';
+    '--legacy-output': 'legacyOutput';
+    '--sourcemap': 'sourcemap';
+
+    // watch and dev
+    '--watch': 'watch';
+    '--onSuccess': 'onSuccess';
+
+    // inject and externals
+    '--inject': 'inject';
+    '--external': 'external';
+
+    // output options
+    '--global-name': 'globalName';
+    '--jsxFactory': 'jsxFactory';
+    '--jsxFragment': 'jsxFragment';
+    '--replaceNodeEnv': 'replaceNodeEnv';
+    '--no-splitting': 'splitting';
+    '--clean': 'clean';
+    '--silent': 'silent';
+    '--pure': 'pure';
+    '--metafile': 'metafile';
+
+    // platform and env
+    '--platform': 'platform';
+    '--loader': 'loader';
+    '--tsconfig': 'tsconfig';
+    '--config': 'config';
+    '--shims': 'shims';
+    '--inject-style': 'injectStyle';
+
+    // tree shaking and public assets
+    '--treeshake': 'treeshake';
+    '--publicDir': 'publicDir';
+
+    // process control
+    '--killSignal': 'killSignal';
+    '--cjsInterop': 'cjsInterop';
+}
+
+/**
+ * Provides default values for supported CLI flags (where applicable).
+ */
+interface BuildOptionsCliDefaults extends Partial<Record<keyof BuildOptionsCliFlagMap, unknown>> {
+    '--format': 'esm';
+    '--minify': false;
+    '--sourcemap': false;
+    '--watch': false;
+    '--clean': false;
+    '--silent': false;
+    '--shims': true;
+    '--splitting': true;
+    '--treeshake': true;
+    '--cjsInterop': true;
+    '--platform': 'node';
+    '--target': 'esnext';
+}
+
+type BuildOptionsCliAllowedTypes = string | string[] | boolean;
+type BuildOptionsCliReplaceIfNotAllowed<T> = T extends BuildOptionsCliAllowedTypes ? T : string;
+type BuildOptionsCliFlags = {
+    [K in BuildOptionsCliKeys]: BuildOptionsCliReplaceIfNotAllowed<BuildOptions[K]>;
+};
+type BuildOptionsCliKeys =
+    | 'outDir'
+    | 'format'
+    | 'minify'
+    | 'minifyWhitespace'
+    | 'minifyIdentifiers'
+    | 'minifySyntax'
+    | 'keepNames'
+    | 'target'
+    | 'legacyOutput'
+    | 'sourcemap'
+    | 'watch'
+    | 'onSuccess'
+    | 'inject'
+    | 'external'
+    | 'globalName'
+    | 'jsxFactory'
+    | 'jsxFragment'
+    | 'replaceNodeEnv'
+    | 'splitting'
+    | 'clean'
+    | 'silent'
+    | 'pure'
+    | 'metafile'
+    | 'platform'
+    | 'loader'
+    | 'tsconfig'
+    | 'config'
+    | 'shims'
+    | 'injectStyle'
+    | 'treeshake'
+    | 'publicDir'
+    | 'killSignal'
+    | 'cjsInterop';
+
+
+// ---- commands.d.ts ----
+type GenerateConfigOptionsCLI = {
+    /**
+     * The file extension to use
+     * @default '.ts'
+     */
+    ext?: '.ts' | '.js' | '.cjs' | '.json';
+
+    /**
+     * The name of the file to generate
+     * @default 'tochibuild.config'
+     */
+    filename?: 'tochibuild.config' | (string & {});
+
+    /**
+     * If the file already exists, overwrite it
+     * @default false
+     */
+    overwrite?: boolean;
+
+    /**
+     * The output directories
+     * @default the current working directory
+     */
+    outDir?: string[];
+};
+
+type CreateTarballOptionsCLI = {
+    /**
+     * Path to the original package directory (relative/absolute)
+     * @default the current working directory
+     */
+    dir?: string;
+
+    /**
+     * The custom path to the package.json file (relative/absolute)
+     * @default 'package.json'
+     */
+    pkg?: string;
+
+    /**
+     * The output tarball path (relative/absolute)
+     * @default tochibuild.package.tgz
+     */
+    out?: string[];
+};
+
+
+// ---- lifecycle.d.ts ----
+type BuildLifecyclePackageJsonHandler =
+    | PackageJsonOptions
+    | ((override: PackageJsonOptions) => PackageJsonOptions);
+type BuildLifecyclePackageJsonValue =
+    | string
+    | BuildLifecyclePackageJsonHandler
+    | {
+          /**
+           * The path to the package.json file (relative to the current working directory)
+           *
+           * Use the `data` property instead if you already have the package.json data
+           */
+          path?: string;
+
+          /**
+           * The package.json data
+           *
+           * Use the `path` property instead if you don't have the package.json data
+           */
+          data?: BuildLifecyclePackageJsonHandler;
+      };
+
+type BuildLifecycleRegistryUri =
+    | 'https://registry.npmjs.org/'
+    | 'https://registry.yarnpkg.com/'
+    | 'https://npm.pkg.github.com/';
+
+interface BuildLifecycleRegistry extends Record<string, BuildLifecycleRegistryUri> {
+    npm: 'https://registry.npmjs.org/';
+    yarn: 'https://registry.yarnpkg.com/';
+    pnpm: 'https://registry.npmjs.org/';
+    bun: 'https://registry.npmjs.org/';
+    github: 'https://npm.pkg.github.com/';
+}
+
+type BuildLifecycleHookOptions<
+    TDefaultHooks extends Record<string, any> = BuildLifecycleDefaultHooks<any>,
+> = (BuildLifecycleHookOptionsCli | BuildLifecycleHookOptionsAction) & {
+    /**
+     * The description of what the hook does
+     * @example 'generate pokemons'
+     */
+    description?: string;
+
+    /**
+     * The lifecycle position of the hook
+     */
+    position:
+        | 'before.build'
+        | `before.${keyof TDefaultHooks}`
+        | 'after.build'
+        | `after.${keyof TDefaultHooks}`;
+};
+
+type BuildLifecycleHookOptionsCli = {
+    /**
+     * The name of the hook
+     * @example 'my special hook'
+     */
+    name?: string;
+
+    /**
+     * The cli to use for this hook
+     */
+    cli: {
+        /**
+         * The name of the cli to use for this hook
+         *
+         * If `undefined` or `null` is provided, then the one from {@link BuildLifecycleOptions} will be used
+         *
+         * @example 'node', 'nodemon' or 'tsx'
+         */
+        name:
+            | keyof Omit<BuildLifecycleRegistry, 'github'>
+            | 'node'
+            | (string & {})
+            | undefined
+            | null;
+
+        /**
+         * The command and arguments to use for this hook (eg. `run`, `script.js`)
+         *
+         * The provided cli name will be prefixed to the command
+         */
+        args: string[];
+    };
+};
+
+type TBuildUtils = typeof import('../utils/index').BuildUtils;
+type BuildLifecycleHookOptionsAction = {
+    /**
+     * The name of the hook
+     * @example 'my special hook'
+     */
+    name: string;
+
+    /**
+     * The action to perform for this hook
+     *
+     * @param utils build utilities
+     * @param config the settings from the configuration file
+     * @param packageJson data from package.json
+     */
+    action: (
+        utils: TBuildUtils,
+        config: TochibuildConfig | undefined,
+        packageJson: PackageJsonOptions | undefined
+    ) => MaybePromise<void>;
+};
+
+type BuildLifecycleDefaultHookOptionsKnown<
+    TPackageManager extends keyof BuildLifecycleRegistry,
+    TBuildLifecycleHookName extends BuildLifecycleDefaultHookName,
+> = BuildLifecyclePackageManagerOptions<
+    TPackageManager,
+    TBuildLifecycleHookName
+>[TPackageManager][TBuildLifecycleHookName];
+
+type BuildLifecycleDefaultHookOptionsUnknown = Record<string, any>;
+
+type BuildLifecycleDefaultHookOptions<
+    TPackageManager extends keyof BuildLifecycleRegistry | (string & {}),
+    TBuildLifecycleHookName extends BuildLifecycleDefaultHookName,
+> = (TPackageManager extends keyof BuildLifecycleRegistry
+    ? BuildLifecycleDefaultHookOptionsKnown<TPackageManager, TBuildLifecycleHookName>
+    : BuildLifecycleDefaultHookOptionsUnknown) & {
+    /**
+     * The package manager to use
+     *
+     * If none is provided, then the one from {@link BuildLifecycleOptions} will be used
+     */
+    packageManager?:
+        | ConditionalType<
+              TBuildLifecycleHookName,
+              'deprecate',
+              'npm',
+              keyof Omit<BuildLifecycleRegistry, 'github'>
+          >
+        | (string & {});
+
+    /**
+     * The command to use
+     */
+    command?: TBuildLifecycleHookName | (string & {});
+
+    /**
+     * The arguments for the command if any (eg. `--no-private`)
+     *
+     * NOTE: the tarball will be created automatically (recommended) if not provided
+     */
+    args?: string[];
+};
+
+type BuildLifecycleDefaultHookName = 'publish' | 'deprecate';
+type BuildLifecycleDefaultHooks<
+    TPackageManager extends keyof BuildLifecycleRegistry | (string & {}),
+> = {
+    /**
+     * The default publish command for the selected package manager
+     *
+     * More info:
+     * - [npm](https://docs.npmjs.com/cli/commands/npm-publish)
+     * - [yarn](https://yarnpkg.com/cli/npm/publish)
+     * - [pnpm](https://pnpm.io/cli/publish)
+     * - [bun](https://bun.sh/docs/cli/publish)
+     */
+    publish?: BuildLifecycleDefaultHookOptions<TPackageManager, 'publish'>;
+
+    /**
+     * The default deprecate command for the selected package manager
+     *
+     * NOTE: this hook is unaware of workspaces
+     *
+     * More info:
+     * - [npm](https://docs.npmjs.com/cli/commands/npm-deprecate)
+     * - only npm supports deprecating packages
+     */
+    deprecate?: BuildLifecycleDefaultHookOptions<TPackageManager, 'deprecate'>;
+};
+
+type BuildLifecycleOptions<TPackageManager extends keyof BuildLifecycleRegistry | (string & {})> = {
+    /**
+     * The package manager to use
+     */
+    packageManager: TPackageManager;
+
+    /**
+     * The access level of the package
+     * @default 'restricted'
+     */
+    access?: 'public' | 'restricted' | (string & {});
+
+    /**
+     * The registry to publish to
+     * @default 'https://registry.npmjs.org/'
+     */
+    registry?: BuildLifecycleRegistryUri | (string & {});
+
+    /**
+     * The hooks to use for the build lifecycle
+     *
+     * These hooks are not running or overriding any pre/post scripts in your package.json
+     */
+    hooks?: BuildLifecycleDefaultHooks<TPackageManager> & {
+        /**
+         * Add your own hook(s)
+         */
+        custom?: MaybeArray<BuildLifecycleHookOptions>;
+    };
+
+    /**
+     * The package.json to use for the published package
+     *
+     * If a string is provided (relative to the current working directory), it will be used as the path to the package.json
+     *
+     * Configure the options using {@link BuildLifecyclePackageJsonValue}
+     *
+     * @default 'package.json'
+     */
+    packageJson?: BuildLifecyclePackageJsonValue;
+};
+
+type MaybeNpmOnlyOptions<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+    TBuildLifecyclePackageManagerOptions extends Record<
+        TPackageManagerCommandName,
+        Record<string, any>
+    >,
+> = ConditionalType<
+    TPackageManagerCommandName,
+    'deprecate',
+    TBuildLifecyclePackageManagerOptions,
+    TPackageManager
+>;
+
+interface BuildLifecyclePackageManagerOptions<
+    TPackageManager extends keyof BuildLifecycleRegistry,
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManager, Record<TPackageManagerCommandName, Record<string, any>>> {
+    npm: MaybeNpmOnlyOptions<
+        TPackageManagerCommandName,
+        BuildLifecyclePackageManagerOptionsNpm<TPackageManagerCommandName>
+    >;
+    yarn: MaybeNpmOnlyOptions<
+        TPackageManagerCommandName,
+        BuildLifecyclePackageManagerOptionsYarn<TPackageManagerCommandName>
+    >;
+    pnpm: MaybeNpmOnlyOptions<
+        TPackageManagerCommandName,
+        BuildLifecyclePackageManagerOptionsPnpm<TPackageManagerCommandName>
+    >;
+    bun: MaybeNpmOnlyOptions<
+        TPackageManagerCommandName,
+        BuildLifecyclePackageManagerOptionsBun<TPackageManagerCommandName>
+    >;
+    github: MaybeNpmOnlyOptions<
+        TPackageManagerCommandName,
+        BuildLifecyclePackageManagerOptionsGithub<TPackageManagerCommandName>
+    >;
+}
+
+interface BuildLifecyclePackageManagerOptionsNpm<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManagerCommandName, Record<string, any>> {
+    /**
+     * The publish command for `npm@11`
+     * @see https://docs.npmjs.com/cli/v11/commands/npm-publish
+     */
+    publish?: NpmPublishOptions;
+
+    /**
+     * The deprecate command for `npm@11`
+     * @see https://docs.npmjs.com/cli/v11/commands/npm-deprecate
+     */
+    deprecate?: NpmDeprecateOptions;
+}
+
+interface BuildLifecyclePackageManagerOptionsYarn<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManagerCommandName, Record<string, any>> {
+    /**
+     * The publish command for `yarn`
+     * @see https://yarnpkg.com/cli/publish
+     */
+    publish?: YarnPublishOptions;
+}
+
+interface BuildLifecyclePackageManagerOptionsYarn<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManagerCommandName, Record<string, any>> {
+    /**
+     * The publish command for `yarn`
+     * @see https://yarnpkg.com/cli/publish
+     */
+    publish?: YarnPublishOptions;
+}
+
+interface BuildLifecyclePackageManagerOptionsPnpm<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManagerCommandName, Record<string, any>> {
+    /**
+     * The publish command for `pnpm`
+     * @see https://pnpm.io/cli/publish
+     */
+    publish?: PnpmPublishOptions;
+}
+
+interface BuildLifecyclePackageManagerOptionsBun<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManagerCommandName, Record<string, any>> {
+    /**
+     * The publish command for `bun`
+     * @see https://bun.sh/docs/cli/publish
+     */
+    publish?: BunPublishOptions;
+}
+
+interface BuildLifecyclePackageManagerOptionsGithub<
+    TPackageManagerCommandName extends BuildLifecycleDefaultHookName,
+> extends Record<TPackageManagerCommandName, Record<string, any>> {
+    /**
+     * The publish command for GitHub's npm registry
+     */
+    publish?: GithubPublishOptions;
+}
+
+
+// ---- npm.d.ts ----
+interface NpmPublishOptions {
+    /**
+     * The tag that will be added to the package in the registry.
+     * @default 'latest'
+     */
+    tag?: string;
+
+    /**
+     * Control access level for scoped packages.
+     * @default 'public' for new packages; no change for existing
+     */
+    access?: 'public' | 'restricted' | null;
+
+    /**
+     * Indicates a dry run without actual publishing.
+     * @default false
+     */
+    'dry-run'?: boolean;
+
+    /**
+     * One-time password for 2FA-enabled accounts.
+     * @default null
+     */
+    otp?: string | null;
+
+    /**
+     * Run the command in the context of a specific workspace.
+     * Can be passed multiple times.
+     */
+    workspace?: string | string[];
+
+    /**
+     * Run the command in the context of all configured workspaces.
+     * @default null
+     */
+    workspaces?: boolean | null;
+
+    /**
+     * Include the workspace root when workspaces are enabled.
+     * @default false
+     */
+    'include-workspace-root'?: boolean;
+
+    /**
+     * Link the package to its CI/CD provenance on supported systems.
+     * Cannot be used with `provenance-file`.
+     * @default false
+     */
+    provenance?: boolean;
+
+    /**
+     * Path to a provenance bundle to use during publish.
+     * Cannot be used with `provenance`.
+     * @default null
+     */
+    'provenance-file'?: string | null;
+
+    /**
+     * Skip publishing if package.json has "private": true.
+     * @default false
+     */
+    'no-private'?: boolean;
+}
+
+interface NpmDeprecateOptions {
+    /**
+     * The version or semver range to deprecate.
+     */
+    version: string;
+
+    /**
+     * The deprecation message to be shown.
+     * Use an empty string to remove the deprecation.
+     */
+    message: string;
+
+    /**
+     * Indicates a dry run without actual changes.
+     * @default false
+     */
+    'dry-run'?: boolean;
+
+    /**
+     * One-time password for 2FA-enabled accounts.
+     * @default null
+     */
+    otp?: string | null;
+}
+
+interface YarnPublishOptions
+    extends Omit<NpmPublishOptions, 'access' | 'otp' | 'provenance' | 'provenance-file'> {
+    'no-git-tag-version'?: boolean;
+}
+
+interface PnpmPublishOptions extends Omit<NpmPublishOptions, 'provenance' | 'provenance-file'> {
+    tag?: string;
+}
+
+interface BunPublishOptions
+    extends Omit<
+        NpmPublishOptions,
+        | 'otp'
+        | 'provenance'
+        | 'provenance-file'
+        | 'workspace'
+        | 'workspaces'
+        | 'include-workspace-root'
+    > {}
+
+interface GithubPublishOptions
+    extends Omit<NpmPublishOptions, 'access' | 'provenance' | 'provenance-file'> {
+    token?: string;
+    'dry-run'?: boolean;
+}
+
+
+// ---- pkg.json.d.ts ----
+/**
+ * Represents the structure of a package.json file.
+ * All properties are optional to allow for partial definitions.
+ */
+interface PackageJsonOptions {
+    [key: string]: Record<string, any> | string | number | boolean | null;
+
+    /**
+     * The name of your package.
+     * Must be lowercase and may include hyphens and underscores.
+     * @example "my-awesome-package"
+     */
+    name?: string;
+
+    /**
+     * The version of your package.
+     * Must follow semantic versioning.
+     * @example "1.0.0"
+     */
+    version?: string;
+
+    /**
+     * A brief description of your package.
+     * @example "A package that does awesome things."
+     */
+    description?: string;
+
+    /**
+     * The entry point to your package.
+     * @example "index.js"
+     */
+    main?: string;
+
+    /**
+     * The module entry point for ES6 module systems.
+     * @example "dist/index.mjs"
+     */
+    module?: string;
+
+    /**
+     * The types entry point for TypeScript definitions.
+     * @example "dist/index.d.ts"
+     */
+    types?: string;
+
+    /**
+     * An array of keywords that describes your package.
+     * Helps people discover your package as it's listed in npm search.
+     * @example ["awesome", "package", "nodejs"]
+     */
+    keywords?: string[];
+
+    /**
+     * The license for your package.
+     * @example "MIT"
+     */
+    license?: string;
+
+    /**
+     * The author of the package.
+     * Can be a string or an object with name, email, and url.
+     * @example "Jane Doe <jane@example.com> (https://example.com)"
+     */
+    author?:
+        | string
+        | {
+              name: string;
+              email?: string;
+              url?: string;
+          };
+
+    /**
+     * A list of contributors to the package.
+     * Each contributor can be a string or an object with name, email, and url.
+     */
+    contributors?: Array<
+        | string
+        | {
+              name: string;
+              email?: string;
+              url?: string;
+          }
+    >;
+
+    /**
+     * The URL to the homepage of your package.
+     * @example "https://example.com"
+     */
+    homepage?: string;
+
+    /**
+     * Information about the bugs for your package.
+     * Can be a URL or an object with url and email.
+     */
+    bugs?:
+        | string
+        | {
+              url?: string;
+              email?: string;
+          };
+
+    /**
+     * The repository where your package's source code lives.
+     * Can be a string or an object with type and url.
+     */
+    repository?:
+        | string
+        | {
+              type: string;
+              url: string;
+              directory?: string;
+          };
+
+    /**
+     * Script commands that are run at various times in the lifecycle of your package.
+     * @example { "start": "node index.js", "test": "jest" }
+     */
+    scripts?: Record<string, string>;
+
+    /**
+     * Dependencies that are required to run your package.
+     * @example { "express": "^4.17.1" }
+     */
+    dependencies?: Record<string, string>;
+
+    /**
+     * Dependencies that are only needed for development and testing.
+     * @example { "jest": "^26.6.3" }
+     */
+    devDependencies?: Record<string, string>;
+
+    /**
+     * Optional dependencies that are not required for your package to work.
+     * @example { "fsevents": "^2.3.2" }
+     */
+    optionalDependencies?: Record<string, string>;
+
+    /**
+     * Dependencies that are bundled when publishing the package.
+     * @example { "lodash": "^4.17.21" }
+     */
+    bundledDependencies?: string[];
+
+    /**
+     * Engines that your package is compatible with.
+     * @example { "node": ">=12.0.0" }
+     */
+    engines?: Record<string, string>;
+
+    /**
+     * Operating systems your package is compatible with.
+     * @example ["darwin", "linux"]
+     */
+    os?: string[];
+
+    /**
+     * CPU architectures your package is compatible with.
+     * @example ["x64", "arm64"]
+     */
+    cpu?: string[];
+
+    /**
+     * Files to include when publishing your package.
+     * @example ["dist/", "README.md"]
+     */
+    files?: string[];
+
+    /**
+     * The directory that contains the executable files.
+     * @example "bin"
+     */
+    bin?: string | Record<string, string>;
+
+    /**
+     * Configuration options for your package.
+     * These can be used by your package's code.
+     */
+    config?: Record<string, any>;
+
+    /**
+     * A map of package names to versions that your package depends on.
+     * These dependencies are bundled when publishing the package.
+     */
+    bundleDependencies?: Record<string, string>;
+
+    /**
+     * A map of package names to versions that your package depends on.
+     * These dependencies are peer dependencies.
+     */
+    peerDependencies?: Record<string, string>;
+
+    /**
+     * A map of package names to versions that your package depends on.
+     * These dependencies are optional peer dependencies.
+     */
+    peerDependenciesMeta?: Record<
+        string,
+        {
+            optional?: boolean;
+        }
+    >;
+
+    /**
+     * A map of package names to versions that your package depends on.
+     * These dependencies are used for overrides.
+     */
+    overrides?: Record<string, string | Record<string, string>>;
+
+    /**
+     * A map of package names to versions that your package depends on.
+     * These dependencies are used for resolutions.
+     */
+    resolutions?: Record<string, string>;
+
+    /**
+     * A map of package names to versions that your package depends on.
+     * These dependencies are used for workspaces.
+     */
+    workspaces?:
+        | string[]
+        | {
+              packages?: string[];
+              nohoist?: string[];
+          };
+
+    /**
+     * The package's publish configuration.
+     */
+    publishConfig?: {
+        access?: 'public' | 'restricted';
+        registry?: string;
+        tag?: string;
+    };
+
+    /**
+     * The package's funding information.
+     * Can be a string or an object with type and url.
+     */
+    funding?:
+        | string
+        | {
+              type?: string;
+              url: string;
+          };
+
+    /**
+     * The package's exports field.
+     * Specifies which module should be used when the package is imported.
+     */
+    exports?: string | Record<string, string | Record<string, string>>;
+
+    /**
+     * The package's imports field.
+     * Specifies internal package imports.
+     */
+    imports?: Record<string, string | Record<string, string>>;
+
+    /**
+     * The package's type.
+     * Can be "commonjs" or "module".
+     */
+    type?: 'commonjs' | 'module';
+
+    /**
+     * The package's side effects.
+     * Can be a boolean or an array of strings.
+     */
+    sideEffects?: boolean | string[];
+
+    /**
+     * The package's private flag.
+     * If true, prevents the package from being published.
+     */
+    private?: boolean;
+
+    /**
+     * The options available in `tochibuild.config.ts` Not all of them are available from CLI flags
+     */
+    tochibuild?: BuildOptions;
+
+    /**
+     * The options available in `tsup.config.ts` Not all of them are available from CLI flags
+     */
+    tsup?: BuildOptions;
+}
+
+
+// ---- shims.d.ts ----
+declare module '@npmcli/arborist' {
+    export interface Node {
+        name: string;
+        path: string;
+        realpath: string;
+        package: Record<string, any>;
+        isLink?: boolean;
+        isRoot?: boolean;
+        children?: Map<string, Node>;
+    }
+
+    export default class Arborist {
+        constructor(options: { path: string });
+        loadActual(): Promise<Node>;
+    }
+}
+
+declare module 'npm-packlist' {
+    export default function packlist(tree: {
+        name: string;
+        path: string;
+        realpath: string;
+        package: Record<string, any>;
+        isLink?: boolean;
+        isRoot?: boolean;
+        children?: Map<string, any>;
+    }): Promise<string[]>;
+}
+
+
+// ---- tarball.d.ts ----
+/**
+ * Options for creating a publishable tarball from a package.
+ */
+interface PublishCreateOptions {
+    /**
+     * Path to the original package directory (relative/absolute).
+     */
+    packageDir: string;
+
+    /**
+     * Custom `package.json` content to include in the tarball.
+     * 
+     * If undefined then the original `package.json` will be used.
+     */
+    packageJsonData: PackageJsonOptions | undefined;
+
+    /**
+     * Output path for the generated `.tgz` tarball (relative/absolute).
+     * 
+     * @default 'tochibuild.package.tgz'
+     */
+    outputTarballPath?: string;
+}
+
+/**
+ * Result returned after successfully creating the tarball.
+ */
+interface PublishCreateResult {
+    /**
+     * The name of the package (from the custom `package.json`).
+     */
+    name: string;
+
+    /**
+     * Relative path (from `process.cwd()`) to the generated tarball.
+     */
+    tarballRelativePath: string;
+
+    /**
+     * Absolute path to the generated tarball.
+     */
+    tarballPath: string;
+
+    /**
+     * List of files included in the tarball (based on npm-packlist).
+     */
+    fileList: string[];
+}
+
 
-export { BuildUtils, type DefineConfigOptions, type DefineConfigOptionsCommonEntries, type DefineConfigOptionsIndexEntries, _default as default, defineConfig, defineConfigWithCommonEntries, defineConfigWithIndexEntries };
+// ---- types.d.ts ----
+/// <reference types="tsup" />
+
+type TsupOptions = import('tsup').Options;
+
+/**
+ * The options available in tochibuild.config.ts
+ *
+ * Not all of them are available from CLI flags
+ */
+interface BuildOptions extends TsupOptions {}
+
+/**
+ * The options available in tochibuild.config.ts including { `tochibuildConfig`: {@link TochibuildConfig} }
+ *
+ * Not all of them are available from CLI flags
+ */
+type BuildOptionsWithConfig<
+    TPackageManager extends
+        | keyof BuildLifecycleRegistry
+        | (string & {}) = keyof BuildLifecycleRegistry,
+> = BuildOptions & {
+    tochibuildConfig?: TochibuildConfig<TPackageManager>;
+};
+
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+
+type ConditionalType<IfType, ExtendsThisType, ThenA, ElseB> = IfType extends ExtendsThisType
+    ? ThenA
+    : ElseB;
+
+type BuildOptionsParam<RequiredKeys extends keyof BuildOptions = any> = MaybeArray<
+    WithRequired<BuildOptions, RequiredKeys>
+>;
+
+/**
+ * Override the config file options with the options derived from CLI flags
+ * @param cliOptions the options derived from CLI flags
+ */
+type BuildOptionsOverrideParam<RequiredKeys extends keyof BuildOptions = any> = (
+    cliOptions: BuildOptions
+) => MaybePromise<BuildOptionsParam<RequiredKeys>>;
+
+type BuildOptionsParams<RequiredKeys extends keyof BuildOptions = any> =
+    | BuildOptionsParam<RequiredKeys>
+    | BuildOptionsOverrideParam<RequiredKeys>;
+
+type BuildOptionsResultValue<RequiredKeys extends keyof BuildOptionsWithConfig = any> = MaybeArray<
+    WithRequired<BuildOptionsWithConfig, RequiredKeys>
+>;
+
+/**
+ * Override the config file options with the options derived from CLI flags
+ * @param cliOptions the options derived from CLI flags
+ */
+type BuildOptionsResultOverrideValue<RequiredKeys extends keyof BuildOptionsWithConfig = any> = (
+    cliOptions: BuildOptionsWithConfig
+) => MaybePromise<BuildOptionsResultValue<RequiredKeys>>;
+
+type BuildOptionsResult<RequiredKeys extends keyof BuildOptionsWithConfig = any> =
+    | BuildOptionsResultValue<RequiredKeys>
+    | BuildOptionsResultOverrideValue<RequiredKeys>;
+
+type TochibuildConfig<
+    TPackageManager extends
+        | keyof BuildLifecycleRegistry
+        | (string & {}) = keyof BuildLifecycleRegistry,
+> = {
+    /**
+     * @default false
+     */
+    includePackageJsonDeps?: boolean;
+
+    /**
+     * @default false
+     */
+    includePackageJsonDevDeps?: boolean;
+
+    /**
+     * @default false
+     */
+    includePackageJsonPeerDeps?: boolean;
+    defaultBuildOptions?: BuildOptions;
+
+    /**
+     * @default false
+     */
+    excludeIgnoredEntries?: boolean;
+
+    /**
+     * Customize what happens before and after the build process using {@link BuildLifecycleOptions} (eg. publishing, deprecating, custom hooks, etc.)
+     */
+    lifecycle?: BuildLifecycleOptions<TPackageManager>;
+};
+
+type MergeConfigOverride = {
+    /**
+     * The parameter (`opts:` {@link BuildOptionsResult}) from {@link mergeOptions} may be a function and therefore you should:
+     *
+     * - set `execute` to `true` if `opts` was dynamically imported from a module (config file) and should be resolved to get the final options.
+     * - set `execute` to `false` if `opts` is not supposed to be resolved yet.
+     */
+    execute: true;
+
+    /**
+     * Override the config file options with these options
+     */
+    overrideOptions: BuildOptionsWithConfig;
+};
+
+type MergeConfigModify = {
+    /**
+     * Override the config file options with the options derived from CLI flags
+     * @param cliOptions the options derived from CLI flags
+     */
+    overrideOptions: (cliOptions: BuildOptionsWithConfig) => BuildOptionsWithConfig;
+
+    /**
+     * Override the result of `overrideOptions` with these options
+     */
+    overrideOptionsCustom?: BuildOptionsWithConfig;
+};
+
+type MergeBuildOptionsConfig = MergeConfigModify;
+type MergeBuildOptionsConfigAsync = MergeConfigOverride | (MergeConfigModify & { execute?: false });