pkgbld 1.27.1 → 1.28.1

package/dist/index.js

@@ -17,7 +17,7 @@ var isEqual = require('lodash/isEqual');
 
 async function createSubpackages(inputs, config) {
     for (const input of inputs) {
-        const basename = path.basename(input, '.ts');
+        const basename = path.basename(input, path.extname(input));
         if (basename !== 'index') {
             const pkg = {
                 type: 'module',
@@ -307,7 +307,7 @@ async function commonjs (provider) {
     provider.provide(() => pluginCommonjs(), 4000 /* Priority.commonjs */);
 }
 
-async function externals (provider, config, inputs) {
+async function externals (provider, config, inputs, inputsExt) {
     if (config.includeExternals === true) {
         return;
     }
@@ -325,8 +325,8 @@ async function externals (provider, config, inputs) {
     if (!allowGenericUmd && config.umdInputs.length > 0) {
         const curry = (await provider.import('lodash/curry.js'));
         for (const currentInput of config.umdInputs) {
-            const isExternal = curry((currentInput, id, external, importer) => includeExternals(importer, external, id, config) || isExternalInput(currentInput, inputs, id, config))(currentInput);
-            provider.provide(() => pluginExternals(isExternal), 2000 /* Priority.externals */, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+            const isExternal = curry((currentInput, id, external, importer) => includeExternals(importer, external, id, config) || isExternalInput(currentInput, inputs, inputsExt, id, config))(currentInput);
+            provider.provide(() => pluginExternals(isExternal), 2000 /* Priority.externals */, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
         }
         // for eject config
         if (config.formats.length === 0) {
@@ -354,13 +354,13 @@ function includeExternals(importer, external, id, config) {
     }
     return true;
 }
-function isExternalInput(currentInput, inputs, id, config) {
+function isExternalInput(currentInput, inputs, inputsExt, id, config) {
     let normalizedPath;
     if (path.isAbsolute(currentInput)) {
-        normalizedPath = './' + path.relative(process.cwd(), currentInput);
+        normalizedPath = './' + path.relative(process.cwd(), `${currentInput}.${inputsExt.get(currentInput)}`);
     }
     else {
-        normalizedPath = './' + path.join(config.sourceDir, currentInput + '.ts');
+        normalizedPath = './' + path.join(config.sourceDir, `${currentInput}.${inputsExt.get(currentInput)}`);
     }
     if (path.isAbsolute(id)) {
         id = './' + path.relative(process.cwd(), id);
@@ -368,17 +368,17 @@ function isExternalInput(currentInput, inputs, id, config) {
     return normalizedPath !== id && inputs.includes(normalizedPath);
 }
 
-async function preprocess (provider, config) {
+async function preprocess (provider, config, inputs, inputsExt) {
     if (config.preprocess.length > 0) {
         const pluginPreprocess = await provider.import('rollup-plugin-preprocess');
-        const include = config.preprocess.map(name => `${config.sourceDir}/${name}.ts`);
+        const include = config.preprocess.map(name => `${config.sourceDir}/${name}.${inputsExt.get(name)}`);
         for (const format of config.formats) {
             if (format !== 'umd') {
                 provider.provide(() => pluginPreprocess({ include, context: { [format]: true } }), 1000 /* Priority.preprocess */, { format });
             }
             else {
                 for (const currentInput of config.umdInputs) {
-                    provider.provide(() => pluginPreprocess({ include, context: { umd: true } }), 1000 /* Priority.preprocess */, { format, inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+                    provider.provide(() => pluginPreprocess({ include, context: { umd: true } }), 1000 /* Priority.preprocess */, { format, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
                 }
             }
         }
@@ -390,7 +390,7 @@ async function resolve (provider) {
     provider.provide(() => pluginResolve(), 3000 /* Priority.resolve */);
 }
 
-async function terser (provider, config) {
+async function terser (provider, config, inputs, inputsExt) {
     const filteredFormats = config.compressFormats.filter(format => config.formats.includes(format));
     if (filteredFormats.length > 0) {
         const pluginTerser = await provider.import('@rollup/plugin-terser');
@@ -408,7 +408,7 @@ async function terser (provider, config) {
                 }
                 else {
                     for (const currentInput of config.umdInputs) {
-                        provider.provide(() => pluginTerser(options), 10000 /* Priority.compress */, { format, outputPlugin: true, inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+                        provider.provide(() => pluginTerser(options), 10000 /* Priority.compress */, { format, outputPlugin: true, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
                     }
                 }
             }
@@ -416,9 +416,12 @@ async function terser (provider, config) {
     }
 }
 
-async function typescript (provider) {
-    const pluginTypescript = await provider.import('rollup-plugin-typescript2');
-    provider.provide(() => pluginTypescript(), 6000 /* Priority.transpile */);
+async function typescript (provider, config, inputs) {
+    const typescriptInputs = inputs.filter(input => input.endsWith('.ts') || input.endsWith('.tsx'));
+    if (typescriptInputs.length > 0) {
+        const pluginTypescript = await provider.import('rollup-plugin-typescript2');
+        provider.provide(() => pluginTypescript(), 6000 /* Priority.transpile */, typescriptInputs.length === inputs.length ? undefined : { inputs: typescriptInputs });
+    }
 }
 
 async function binify (provider, config) {
@@ -462,7 +465,7 @@ function createProvider(preimportMap) {
 
 function getHelpers(pkgName) {
     function getGlobalName(anInput) {
-        return camelCase(path.join(pkgName, path.basename(anInput, '.ts') !== 'index' ? path.basename(anInput, '.ts') : ''));
+        return camelCase(path.join(pkgName, path.basename(anInput, path.extname(anInput)) !== 'index' ? path.basename(anInput, path.extname(anInput)) : ''));
     }
     function getExternalGlobalName(id) {
         if (path.isAbsolute(id)) {
@@ -485,7 +488,7 @@ function toArray(object) {
     return [object];
 }
 function formatInput(input) {
-    return (Array.isArray(input) ? input : [input ?? '']).map(item => kleur.magenta(path.basename(item, '.ts'))).join(', ');
+    return (Array.isArray(input) ? input : [input ?? '']).map(item => kleur.magenta(path.basename(item, path.extname(item)))).join(', ');
 }
 function formatOutput(output, field) {
     //? can we avoid it
@@ -505,8 +508,20 @@ const areSetsEqual = (a, b) => a.size === b.size ? [...a].every(value => b.has(v
 function formatPackageJson(pkg) {
     return processPackageJson(pkg, key => key in pkg, key => pkg[key]);
 }
+async function isExists(file) {
+    try {
+        await fs.access(file);
+    }
+    catch (e) {
+        if (typeof e === 'object' && e != null && 'code' in e && e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+    return file;
+}
 
-async function getRollupConfigs([provider, plugins$1], inputs, config, helpers, externalPlugins) {
+async function getRollupConfigs([provider, plugins$1], inputs, inputsExt, config, helpers, externalPlugins) {
     const factoryInProgress = [];
     const fileNamePatterns = {
         'es': config.esPattern,
@@ -514,10 +529,10 @@ async function getRollupConfigs([provider, plugins$1], inputs, config, helpers,
         'umd': config.umdPattern
     };
     for (const factory of plugins) {
-        factoryInProgress.push(factory(provider, config, inputs));
+        factoryInProgress.push(factory(provider, config, inputs, inputsExt));
     }
     for (const ePlugin of externalPlugins) {
-        ePlugin.providePlugins && factoryInProgress.push(ePlugin.providePlugins(provider, config, inputs));
+        ePlugin.providePlugins && factoryInProgress.push(ePlugin.providePlugins(provider, config, inputs, inputsExt));
     }
     await Promise.all(factoryInProgress);
     const expandInputs = new Set;
@@ -665,7 +680,7 @@ async function getRollupConfigs([provider, plugins$1], inputs, config, helpers,
                 }
                 else {
                     for (const input of config.umdInputs) {
-                        expanded.push(`${format}../${config.sourceDir}/${input}.ts`);
+                        expanded.push(`${format}../${config.sourceDir}/${input}.${inputsExt.get(input)}`);
                     }
                 }
             }
@@ -680,7 +695,8 @@ async function getRollupConfigs([provider, plugins$1], inputs, config, helpers,
 const mainLoggerText = (sourceDir, dir, configsCount, startingTime, finishedCount = 0) => (final = false) => `${sourceDir} → ${dir} ${final ? configsCount : finishedCount++} / ${configsCount}${final ? (' in ' + getTimeDiff(startingTime)) : ''}`;
 
 const emptySet = new Set;
-function processPackage(pkg, config, plugins) {
+const sourceFileSuffixes = ['ts', 'tsx', 'js', 'jsx']; // svelte, vue, etc. are not supported yet
+async function processPackage(pkg, config, plugins) {
     const exportsFields = new Set([
         'types',
         'import',
@@ -692,6 +708,7 @@ function processPackage(pkg, config, plugins) {
     const indexId = 'index';
     const typesVersionsLastFields = new Set(['*']);
     const inputs = [];
+    const inputsExt = new Map;
     const logger$1 = logger.createLogger();
     const allowEsm = (config.formatsOverridden && config.formats.includes('es') || !config.formatsOverridden);
     const allowCjs = (config.formatsOverridden && config.formats.includes('cjs') || !config.formatsOverridden);
@@ -730,7 +747,7 @@ function processPackage(pkg, config, plugins) {
     if (typeof pkg.typings === 'string') {
         delete pkg.typings;
     }
-    pkg.types = `./${config.dir}/index.d.ts`;
+    pkg.types = `./${config.dir}/${patternToName(typingsFilePattern, 'index')}`;
     if (allowUmd && typeof pkg.umd === 'string') {
         pkg.umd = `./${config.dir}/${patternToName(config.umdPattern, indexId)}`;
         if (!config.umdInputs.includes(indexId)) {
@@ -802,7 +819,16 @@ function processPackage(pkg, config, plugins) {
                 pkg.files.push(basename);
             }
         }
-        inputs.push(`./${config.sourceDir}/${basename}.ts`);
+        // check if source file exists
+        const sourceFileWithoutSuffix = `./${config.sourceDir}/${basename}.`;
+        for (const suffix of sourceFileSuffixes) {
+            const file = sourceFileWithoutSuffix + suffix;
+            if (await isExists(file)) {
+                inputs.push(file);
+                inputsExt.set(file, suffix);
+                break;
+            }
+        }
     }
     pkg.typesVersions['*']['*'] = [
         `${config.dir}/${patternToName(typingsFilePattern, indexId)}`,
@@ -815,7 +841,7 @@ function processPackage(pkg, config, plugins) {
     for (const plugin of plugins) {
         plugin.processPackageJson?.(pkg, inputs, logger$1);
     }
-    return inputs;
+    return [inputs, inputsExt];
 }
 function patternToName(pattern, input) {
     return pattern.replace('[name]', input);
@@ -844,7 +870,7 @@ async function writeJson(path, json) {
     await fs.writeFile(path, toFormattedJson(json));
 }
 
-var version = "1.27.1";
+var version = "1.28.1";
 var name = "pkgbld";
 var license = "MIT";
 var author = "Konstantin Shutkin";
@@ -960,7 +986,7 @@ async function createEjectProvider(preimportMap) {
             }
         }, plugins];
 }
-async function ejectConfig(config, pkgPath, options, inputs, helpers, pkg) {
+async function ejectConfig(config, pkgPath, options, inputs, inputsExt, helpers, pkg) {
     const pkgName = pkg.name;
     // generate from config
     const text = generate(config);
@@ -968,6 +994,7 @@ async function ejectConfig(config, pkgPath, options, inputs, helpers, pkg) {
     // generate globals for config functions
     setup.add(`const config = ${generate(options)}`);
     setup.add(`const inputs = ${generate(inputs)}`);
+    setup.add(`const inputsExt = new Map(${generate(Array.from(inputsExt))})`);
     // generate helpers code
     if (options.formats.includes('umd')) {
         imports.set('path', 'path');
@@ -1032,6 +1059,8 @@ const defaultTsConfig = {
         target: 'esnext',
         module: 'esnext',
         esModuleInterop: true,
+        allowJs: true,
+        skipLibCheck: true,
         strict: true,
         noUncheckedIndexedAccess: true,
         declaration: true,
@@ -1217,18 +1246,6 @@ async function isDirectory(file) {
     }
     catch (e) { /**/ }
 }
-async function isExists(file) {
-    try {
-        await fs.access(file);
-    }
-    catch (e) {
-        if (typeof e === 'object' && e != null && 'code' in e && e.code === 'ENOENT') {
-            return false;
-        }
-        throw e;
-    }
-    return file;
-}
 async function walkDir(dir) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     const files = [];
@@ -1299,16 +1316,16 @@ async function execute() {
         process.stdout.moveCursor?.(0, 1);
         mainLogger.update('preparing...');
         checkTsConfig(options, mainLogger, plugins);
-        const inputs = processPackage(pkg, options, plugins);
+        const [inputs, inputsExt] = await processPackage(pkg, options, plugins);
         if (options.formatPackageJson) {
             pkg = formatPackageJson(pkg);
         }
         const helpers = getHelpers(pkg.name);
         const preimportMap = preimport();
         const provider = options.eject ? await createEjectProvider(preimportMap) : createProvider(preimportMap);
-        const rollupConfigs = await getRollupConfigs(provider, inputs, options, helpers, plugins);
+        const rollupConfigs = await getRollupConfigs(provider, inputs, inputsExt, options, helpers, plugins);
         if (options.eject) {
-            await ejectConfig(rollupConfigs, pkgPath, options, inputs, helpers, pkg);
+            await ejectConfig(rollupConfigs, pkgPath, options, inputs, inputsExt, helpers, pkg);
             mainLogger.finish(`ejected config in ${getTimeDiff(time)}`);
             if (!options.noUpdatePackageJson) {
                 await writeJson(pkgPath, pkg);

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.27.1",
+  "version": "1.28.1",
   "name": "pkgbld",
   "license": "MIT",
   "author": "Konstantin Shutkin",

package/dist/src/builtin-plugins/binify.d.ts

@@ -1,2 +0,0 @@
-import { CliOptions, Provider } from '../types';
-export default function (provider: Provider, config: CliOptions): Promise<void>;

package/dist/src/builtin-plugins/clean.d.ts

@@ -1,2 +0,0 @@
-import { Provider } from '../types';
-export default function (provider: Provider): Promise<void>;

package/dist/src/builtin-plugins/commonjs.d.ts

@@ -1,2 +0,0 @@
-import { Provider } from '../types';
-export default function (provider: Provider): Promise<void>;

package/dist/src/builtin-plugins/externals.d.ts

@@ -1,2 +0,0 @@
-import { CliOptions, Provider } from '../types';
-export default function (provider: Provider, config: CliOptions, inputs: string[]): Promise<void>;

package/dist/src/builtin-plugins/preprocess.d.ts

@@ -1,2 +0,0 @@
-import { CliOptions, Provider } from '../types';
-export default function (provider: Provider, config: CliOptions): Promise<void>;

package/dist/src/builtin-plugins/resolve.d.ts

@@ -1,2 +0,0 @@
-import { Provider } from '../types';
-export default function (provider: Provider): Promise<void>;

package/dist/src/builtin-plugins/terser.d.ts

@@ -1,2 +0,0 @@
-import { CliOptions, Provider } from '../types';
-export default function (provider: Provider, config: CliOptions): Promise<void>;

package/dist/src/builtin-plugins/typescript.d.ts

@@ -1,2 +0,0 @@
-import { Provider } from '../types';
-export default function (provider: Provider): Promise<void>;

package/dist/src/create-subpackages.d.ts

@@ -1,2 +0,0 @@
-import { CliOptions } from './types';
-export declare function createSubpackages(inputs: string[], config: CliOptions): Promise<void>;

package/dist/src/eject.d.ts

@@ -1,6 +0,0 @@
-import type { CliOptions, PkgbldRollupPlugin, Provider } from './types';
-import type { PackageJson } from 'options';
-import type { RollupOptions } from 'rollup';
-import { getHelpers } from './helpers';
-export declare function createEjectProvider(preimportMap: Map<string, Promise<never>>): Promise<[Provider, PkgbldRollupPlugin[]]>;
-export declare function ejectConfig(config: RollupOptions[], pkgPath: string, options: CliOptions, inputs: string[], helpers: ReturnType<typeof getHelpers>, pkg: PackageJson): Promise<void>;

package/dist/src/get-cli-options.d.ts

@@ -1,27 +0,0 @@
-import { PkgbldPlugin } from './types';
-import { PackageJson } from 'options';
-export declare function getCliOptions(plugins: Partial<PkgbldPlugin>[], pkg: PackageJson): {
-    kind: 'build';
-    umdInputs: string[];
-    compressFormats: string[];
-    sourcemapFormats: string[];
-    formats: string[];
-    formatsOverridden: boolean;
-    preprocess: string[];
-    dir: string;
-    sourceDir: string;
-    bin?: string[] | undefined;
-    includeExternals: boolean | string[];
-    eject: boolean;
-    noTsConfig: boolean;
-    noUpdatePackageJson: boolean;
-    commonjsPattern: string;
-    esPattern: string;
-    umdPattern: string;
-    formatPackageJson: boolean;
-    noPack: boolean;
-} | {
-    readonly kind: "prune";
-    readonly profile: string;
-    readonly flatten: string | boolean;
-};

package/dist/src/get-json.d.ts

@@ -1,2 +0,0 @@
-import { Json } from './types';
-export declare function getJson(fileName: string): Promise<[string, Json]>;

package/dist/src/get-plugins.d.ts

@@ -1,4 +0,0 @@
-import type { PkgbldRollupPlugin, Provider } from './types';
-import externals from './builtin-plugins/externals';
-export declare const plugins: (typeof externals)[];
-export declare function createProvider(preimportMap: Map<string, Promise<never>>): [Provider, PkgbldRollupPlugin[]];

package/dist/src/get-rollup-configs.d.ts

@@ -1,54 +0,0 @@
-import type { getHelpers } from './helpers';
-import type { CliOptions, PkgbldPlugin, PkgbldRollupPlugin, Provider } from './types';
-export declare function getRollupConfigs([provider, plugins]: [Provider, PkgbldRollupPlugin[]], inputs: string[], config: CliOptions, helpers: ReturnType<typeof getHelpers>, externalPlugins: Partial<PkgbldPlugin>[]): Promise<{
-    input: string[];
-    output: {
-        amd?: import("rollup").AmdOptions | undefined;
-        assetFileNames?: string | ((chunkInfo: import("rollup").PreRenderedAsset) => string) | undefined;
-        banner?: string | import("rollup").AddonFunction | undefined;
-        chunkFileNames?: string | ((chunkInfo: import("rollup").PreRenderedChunk) => string) | undefined;
-        compact?: boolean | undefined;
-        dir: string;
-        dynamicImportInCjs?: boolean | undefined;
-        entryFileNames: string | ((chunkInfo: import("rollup").PreRenderedChunk) => string);
-        esModule?: boolean | "if-default-prop" | undefined;
-        experimentalMinChunkSize?: number | undefined;
-        exports?: "default" | "named" | "none" | "auto" | undefined;
-        extend?: boolean | undefined;
-        externalImportAssertions?: boolean | undefined;
-        externalImportAttributes?: boolean | undefined;
-        externalLiveBindings?: boolean | undefined;
-        file?: string | undefined;
-        footer?: string | import("rollup").AddonFunction | undefined;
-        format: "umd" | "amd" | "cjs" | "es" | "iife" | "system" | "commonjs" | "esm" | "module" | "systemjs";
-        freeze?: boolean | undefined;
-        generatedCode?: import("rollup").GeneratedCodePreset | import("rollup").GeneratedCodeOptions | undefined;
-        globals?: import("rollup").GlobalsOption | undefined;
-        hoistTransitiveImports?: boolean | undefined;
-        indent?: string | boolean | undefined;
-        inlineDynamicImports?: boolean | undefined;
-        interop?: import("rollup").InteropType | import("rollup").GetInterop | undefined;
-        intro?: string | import("rollup").AddonFunction | undefined;
-        manualChunks?: import("rollup").ManualChunksOption | undefined;
-        minifyInternalExports?: boolean | undefined;
-        name?: string | undefined;
-        noConflict?: boolean | undefined;
-        outro?: string | import("rollup").AddonFunction | undefined;
-        paths?: import("rollup").OptionsPaths | undefined;
-        plugins: false | import("rollup").OutputPlugin | import("rollup").OutputPluginOption[] | Promise<false | import("rollup").OutputPlugin | import("rollup").NullValue | import("rollup").OutputPluginOption[]> | null;
-        preserveModules?: boolean | undefined;
-        preserveModulesRoot?: string | undefined;
-        sanitizeFileName?: boolean | ((fileName: string) => string) | undefined;
-        sourcemap: boolean | "inline" | "hidden";
-        sourcemapBaseUrl?: string | undefined;
-        sourcemapExcludeSources?: boolean | undefined;
-        sourcemapFile?: string | undefined;
-        sourcemapFileNames?: string | ((chunkInfo: import("rollup").PreRenderedChunk) => string) | undefined;
-        sourcemapIgnoreList?: boolean | import("rollup").SourcemapIgnoreListOption | undefined;
-        sourcemapPathTransform?: import("rollup").SourcemapPathTransformOption | undefined;
-        strict?: boolean | undefined;
-        systemNullSetters?: boolean | undefined;
-        validate?: boolean | undefined;
-    }[];
-    plugins: import("rollup").Plugin<any>[];
-}[]>;

package/dist/src/helpers.d.ts

@@ -1,12 +0,0 @@
-import { OutputOptions } from 'rollup';
-import { PackageJson } from 'options';
-export declare function getHelpers(pkgName: string): {
-    getGlobalName: (anInput: string) => string;
-    getExternalGlobalName: (id: string) => string;
-};
-export declare function toArray<T>(object: T | T[] | undefined): T[];
-export declare function formatInput(input: string[] | string): string;
-export declare function formatOutput(output: OutputOptions | OutputOptions[] | undefined, field: 'dir' | 'format'): string;
-export declare function getTimeDiff(starting: number): string;
-export declare const areSetsEqual: <T>(a: Set<T>, b: Set<T>) => boolean;
-export declare function formatPackageJson(pkg: PackageJson): PackageJson;

package/dist/src/index.d.ts

@@ -1 +0,0 @@
-import '@niceties/draftlog-appender';

package/dist/src/load-plugins.d.ts

@@ -1,3 +0,0 @@
-import { PackageJson } from 'options';
-import { PkgbldPlugin } from './types';
-export declare function loadPlugins(pkg: PackageJson): Promise<Partial<PkgbldPlugin>[]>;

package/dist/src/messages.d.ts

@@ -1 +0,0 @@
-export declare const mainLoggerText: (sourceDir: string, dir: string, configsCount: number, startingTime: number, finishedCount?: number) => (final?: boolean) => string;

package/dist/src/process-pkg.d.ts

@@ -1,2 +0,0 @@
-import { CliOptions, Json, PkgbldPlugin } from './types';
-export declare function processPackage(pkg: Json, config: CliOptions, plugins: Partial<PkgbldPlugin>[]): string[];

package/dist/src/process-ts-config.d.ts

@@ -1,3 +0,0 @@
-import { Logger } from '@niceties/logger';
-import { CliOptions, PkgbldPlugin } from './types';
-export declare function checkTsConfig(options: CliOptions, mainLogger: Logger, plugins: Partial<PkgbldPlugin>[]): Promise<void>;

package/dist/src/prune.d.ts

@@ -1,7 +0,0 @@
-import { Logger } from '@niceties/logger';
-import { PackageJson } from 'options';
-export declare function prunePkg(pkg: PackageJson, options: {
-    kind: 'prune';
-    profile: string;
-    flatten: string | boolean;
-}, logger: Logger): Promise<void>;

package/dist/src/types.d.ts

@@ -1,47 +0,0 @@
-import type { Plugin, InternalModuleFormat, OutputOptions } from 'rollup';
-import type { getCliOptions } from './get-cli-options';
-import { Logger } from '@niceties/logger';
-import { PackageJson } from 'options';
-export type Json = null | string | number | boolean | Json[] | {
-    [name: string]: Json;
-};
-export declare const enum Priority {
-    preprocess = 1000,
-    cleanup = 1000,
-    externals = 2000,
-    resolve = 3000,
-    commonjs = 4000,
-    transpile = 6000,
-    compress = 10000,
-    finalize = 20000
-}
-export type ProvideFunction = (factory: () => Plugin, priority: Priority, options?: {
-    format?: InternalModuleFormat | InternalModuleFormat[];
-    inputs?: string[];
-    outputPlugin?: true;
-}) => void;
-export type Provider = {
-    provide: ProvideFunction;
-    import: (module: string, exportName?: string) => Promise<((...args: unknown[]) => Plugin)>;
-    globalImport: (module: string, exportName?: string | string[]) => void;
-    globalSetup: (code: Function | string) => void;
-};
-export type PkgbldRollupPlugin = {
-    plugin: () => Plugin;
-    priority: Priority;
-    format?: InternalModuleFormat | InternalModuleFormat[];
-    inputs?: string[];
-    outputPlugin?: true;
-};
-export type CliOptions = NonNullable<Extract<ReturnType<typeof getCliOptions>, {
-    kind: 'build';
-}>>;
-export type ParsedOptions = Record<string, string | number | string[] | number[] | boolean | undefined>;
-export interface PkgbldPlugin {
-    options(parsedArgs: ParsedOptions, options: CliOptions): void;
-    processPackageJson(packageJson: PackageJson, inputs: string[], logger: Logger): void;
-    processTsConfig(config: Json): void;
-    providePlugins(provider: Provider, config: ParsedOptions, inputs: string[]): Promise<void>;
-    getExtraOutputSettings(format: InternalModuleFormat, inputs: string[]): Partial<OutputOptions>;
-    buildEnd(): Promise<void>;
-}

package/dist/src/write-json.d.ts

@@ -1,2 +0,0 @@
-import { Json } from './types';
-export declare function writeJson(path: string, json: Json): Promise<void>;