pkgbld 1.29.1 → 1.29.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Konstantin Shutkin
+Copyright (c) 2021-present Konstantin Shutkin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="@niceties/draftlog-appender" />
+
+declare module 'pkgbld' {
+	import type { Plugin, InternalModuleFormat, OutputOptions } from 'rollup';
+	import type { Logger } from '@niceties/logger';
+	export type Json = null | string | number | boolean | Json[] | {
+		[name: string]: Json;
+	};
+	export type ProvideFunction = (factory: () => Plugin, priority: number, 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: number;
+		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[], inputsExt: Map<string, string>): Promise<void>;
+		getExtraOutputSettings(format: InternalModuleFormat, inputs: string[]): Partial<OutputOptions>;
+		buildEnd(): Promise<void>;
+	}
+	export type PackageJson = {
+		private?: boolean;
+		version?: string;
+		name?: string;
+		license?: string;
+		readme?: string;
+		author?: string | {
+			name?: string;
+			email?: string;
+			url?: string;
+		};
+		description?: string;
+		scripts?: {
+			[key: string]: string;
+		};
+		repository?: {
+			type?: string;
+			url?: string;
+		};
+		files?: string[];
+		bugs?: string;
+		homepage?: string;
+		dependencies?: Record<string, string>;
+		devDependencies?: Record<string, string>;
+		peerDependencies?: Record<string, string>;
+		exports?: Record<string, string | Record<string, string>>;
+	};
+	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;
+		noExports: boolean;
+	} | {
+		readonly kind: "prune";
+		readonly profile: string;
+		readonly flatten: string | boolean;
+	};
+}
+
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1,26 @@
+{
+	"version": 3,
+	"file": "index.d.ts",
+	"names": [
+		"Json",
+		"ProvideFunction",
+		"Provider",
+		"PkgbldRollupPlugin",
+		"CliOptions",
+		"ParsedOptions",
+		"PkgbldPlugin",
+		"PackageJson",
+		"getCliOptions"
+	],
+	"sources": [
+		"src/types.d.ts",
+		"src/options-types.d.ts",
+		"src/get-cli-options.d.ts"
+	],
+	"sourcesContent": [
+		null,
+		null,
+		null
+	],
+	"mappings": ";;;;;aAIYA,IAAIA;;;aAGJC,eAAeA;;;;;aAKfC,QAAQA;;;;;;aAMRC,kBAAkBA;;;;;;;aAOlBC,UAAUA;;;aAGVC,aAAaA;kBACRC,YAAYA;;;;;;;;aC7BjBC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;UCECC,aAAaA"
+}

package/dist/index.mjs

@@ -292,10 +292,21 @@ async function getJson(fileName) {
     return [pkgPath, JSON.parse(buffer.toString())];
 }
 
+const Priority = {
+    preprocess: 1000,
+    cleanup: 1000,
+    externals: 2000,
+    resolve: 3000,
+    commonjs: 4000,
+    transpile: 6000,
+    compress: 10000,
+    finalize: 20000
+};
+
 async function clean (provider) {
     const pluginClean = await provider.import('@rollup-extras/plugin-clean');
     const pluginInstance = pluginClean();
-    provider.provide(pluginFactory, 1000 /* Priority.cleanup */, { outputPlugin: true });
+    provider.provide(pluginFactory, Priority.cleanup, { outputPlugin: true });
     let firstPluginInstance = true;
     function pluginFactory() {
         const result = firstPluginInstance ? pluginInstance : pluginInstance.api.addInstance();
@@ -306,7 +317,7 @@ async function clean (provider) {
 
 async function commonjs (provider) {
     const pluginCommonjs = await provider.import('@rollup/plugin-commonjs');
-    provider.provide(() => pluginCommonjs(), 4000 /* Priority.commonjs */);
+    provider.provide(() => pluginCommonjs(), Priority.commonjs);
 }
 
 async function externals (provider, config, inputs, inputsExt) {
@@ -319,7 +330,7 @@ async function externals (provider, config, inputs, inputsExt) {
         const format = (allowGenericUmd ? undefined : config.formats.filter(format => format !== 'umd'));
         provider.provide(() => pluginExternals(config.includeExternals === false
             ? {}
-            : (id, external, importer) => includeExternals(importer, external, id, config)), 2000 /* Priority.externals */, { format });
+            : (id, external, importer) => includeExternals(importer, external, id, config)), Priority.externals, { format });
         // for eject config
         provider.globalImport('path', 'path');
         provider.globalSetup(includeExternals);
@@ -328,7 +339,7 @@ async function externals (provider, config, inputs, inputsExt) {
         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, inputsExt, id, config))(currentInput);
-            provider.provide(() => pluginExternals(isExternal), 2000 /* Priority.externals */, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
+            provider.provide(() => pluginExternals(isExternal), Priority.externals, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
         }
         // for eject config
         if (config.formats.length === 0) {
@@ -372,15 +383,15 @@ function isExternalInput(currentInput, inputs, inputsExt, id, config) {
 
 async function preprocess (provider, config, inputs, inputsExt) {
     if (config.preprocess.length > 0) {
-        const pluginPreprocess = await provider.import('rollup-plugin-preprocess', 'default');
+        const pluginPreprocess = await provider.import('rollup-plugin-preprocess');
         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 });
+                provider.provide(() => pluginPreprocess.default({ include, context: { [format]: true } }), 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}.${inputsExt.get(currentInput)}`] });
+                    provider.provide(() => pluginPreprocess.default({ include, context: { umd: true } }), Priority.preprocess, { format, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
                 }
             }
         }
@@ -389,7 +400,7 @@ async function preprocess (provider, config, inputs, inputsExt) {
 
 async function resolve (provider) {
     const pluginResolve = await provider.import('@rollup/plugin-node-resolve');
-    provider.provide(() => pluginResolve(), 3000 /* Priority.resolve */);
+    provider.provide(() => pluginResolve(), Priority.resolve);
 }
 
 async function terser (provider, config, inputs, inputsExt) {
@@ -406,11 +417,11 @@ async function terser (provider, config, inputs, inputsExt) {
         if (filteredFormats.length > 0) {
             for (const format of filteredFormats) {
                 if (format !== 'umd') {
-                    provider.provide(() => pluginTerser(options), 10000 /* Priority.compress */, { format, outputPlugin: true });
+                    provider.provide(() => pluginTerser(options), Priority.compress, { format, outputPlugin: true });
                 }
                 else {
                     for (const currentInput of config.umdInputs) {
-                        provider.provide(() => pluginTerser(options), 10000 /* Priority.compress */, { format, outputPlugin: true, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
+                        provider.provide(() => pluginTerser(options), Priority.compress, { format, outputPlugin: true, inputs: [`./${config.sourceDir}/${currentInput}.${inputsExt.get(currentInput)}`] });
                     }
                 }
             }
@@ -422,7 +433,7 @@ 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 });
+        provider.provide(() => pluginTypescript(), Priority.transpile, typescriptInputs.length === inputs.length ? undefined : { inputs: typescriptInputs });
     }
 }
 
@@ -431,7 +442,7 @@ async function binify (provider, config) {
         const pluginBinify = await provider.import('@rollup-extras/plugin-binify');
         provider.provide(() => pluginBinify({
             filter: (item) => item.type === 'chunk' && item.isEntry && config.bin.some(input => input === `./${config.dir}/${item.fileName}`)
-        }), 20000 /* Priority.finalize */, { outputPlugin: true, format: 'cjs' });
+        }), Priority.finalize, { outputPlugin: true, format: 'cjs' });
     }
 }
 
@@ -694,7 +705,7 @@ async function getRollupConfigs([provider, plugins$1], inputs, inputsExt, config
 const mainLoggerText = (sourceDir, dir, configsCount, startingTime, finishedCount = 0) => (final = false) => `${sourceDir} → ${dir} ${final ? configsCount : finishedCount++} / ${configsCount}${final ? (' in ' + getTimeDiff(startingTime)) : ''}`;
 
 const emptySet = new Set;
-const sourceFileSuffixes = ['ts', 'tsx', 'js', 'jsx']; // svelte, vue, etc. are not supported yet
+const sourceFileSuffixes = ['ts', 'tsx', 'js', 'jsx', 'cjs', 'mjs']; // svelte, vue, etc. are not supported yet
 async function processPackage(pkg, config, plugins, tsConfig) {
     const typingsFilePattern = '[name].d.ts';
     const indexId = 'index';
@@ -901,12 +912,13 @@ async function writeJson(path, json) {
     await fs.writeFile(path, toFormattedJson(json));
 }
 
-var version = "1.29.1";
+var version = "1.29.3";
 var name = "pkgbld";
 var license = "MIT";
 var author = "Konstantin Shutkin";
 var bin = "./index.js";
 var main = "./dist/index.mjs";
+var types = "./dist/index.d.ts";
 var files = [
 	"dist"
 ];
@@ -928,7 +940,7 @@ var keywords = [
 	"rollup"
 ];
 var scripts = {
-	build: "rollup -c",
+	build: "xc6 rm src/options-types.ts && xc6 ln ../options/src/types.ts src/options-types.ts && rollup -c && dts-buddy dist/index.d.ts -m pkgbld:dist/src/index.d.ts && xc6 rm dist/src",
 	lint: "eslint ./src",
 	prepack: "node ./index.js prune"
 };
@@ -956,8 +968,11 @@ var dependencies = {
 };
 var devDependencies = {
 	"@types/lodash": "^4.14.202",
+	"rollup-plugin-dts": "^6.1.0",
 	"@total-typescript/ts-reset": "^0.5.1",
-	options: "workspace:*"
+	"dts-buddy": "^0.4.4",
+	options: "workspace:*",
+	xc6: "workspace:*"
 };
 var peerDependencies = {
 	typescript: "^5.3.3"
@@ -969,6 +984,7 @@ var pkgbldPkg = {
 	author: author,
 	bin: bin,
 	main: main,
+	types: types,
 	files: files,
 	engines: engines,
 	repository: repository,
@@ -1131,10 +1147,16 @@ async function checkTsConfig(options, mainLogger, plugins) {
     return config;
 }
 
-function loadPlugins(pkg) {
-    return Promise.all(Object.keys(pkg.devDependencies || {})
-        .filter(packageName => packageName.startsWith('pkgbld-plugin-'))
-        .map(packageName => import(packageName)));
+async function loadPlugins(pkg) {
+    try {
+        return await Promise.all([...new Set([...Object.keys(pkg.devDependencies || {}), ...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.peerDependencies || {})])]
+            .filter(packageName => packageName.startsWith('pkgbld-plugin-'))
+            .map(packageName => import(packageName)));
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
 }
 
 async function prunePkg(pkg, options, logger) {
@@ -1384,8 +1406,7 @@ async function execute() {
         }
     }
     catch (e) {
-        console.log(e);
-        mainLogger.finish(`${e}}`, 3 /* LogLevel.error */);
+        mainLogger.finish(JSON.stringify(e), 3 /* LogLevel.error */);
         process.exit(-1);
     }
     async function buildConfig(config, updater) {

package/package.json

@@ -1,10 +1,11 @@
 {
-  "version": "1.29.1",
+  "version": "1.29.3",
   "name": "pkgbld",
   "license": "MIT",
   "author": "Konstantin Shutkin",
   "bin": "./index.js",
   "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],