pkgbld 1.27.0 → 1.28.0

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.0";
+var version = "1.28.0";
 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,
@@ -1176,6 +1205,23 @@ async function flatten(pkg, flatten, logger) {
     });
     files.push(...newFiles);
     pkg.files = [...files];
+    // remove extra directories with package.json
+    const exports = pkg.exports ? Object.keys(pkg.exports) : [];
+    for (const key of exports) {
+        if (key === '.') {
+            continue;
+        }
+        const isDir = await isDirectory(key);
+        if (isDir) {
+            const pkgPath = path.join(key, 'package.json');
+            const pkgExists = await isExists(pkgPath);
+            // ensure nothing else is in the directory
+            const files = await fs.readdir(key);
+            if (files.length === 1 && pkgExists) {
+                await fs.rm(key, { recursive: true, force: true });
+            }
+        }
+    }
 }
 function cloneAndUpdate(pkg, updater) {
     if (typeof pkg === 'string') {
@@ -1193,17 +1239,12 @@ function cloneAndUpdate(pkg, updater) {
     }
     return pkg;
 }
-async function isExists(file) {
+async function isDirectory(file) {
     try {
-        await fs.access(file);
+        const fileStat = await fs.stat(file);
+        return fileStat.isDirectory();
     }
-    catch (e) {
-        if (typeof e === 'object' && e != null && 'code' in e && e.code === 'ENOENT') {
-            return false;
-        }
-        throw e;
-    }
-    return file;
+    catch (e) { /**/ }
 }
 async function walkDir(dir) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -1275,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/dist/src/builtin-plugins/externals.d.ts

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

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

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

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

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

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

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

package/dist/src/eject.d.ts

@@ -3,4 +3,4 @@ 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>;
+export declare function ejectConfig(config: RollupOptions[], pkgPath: string, options: CliOptions, inputs: string[], inputsExt: Map<string, string>, helpers: ReturnType<typeof getHelpers>, pkg: PackageJson): Promise<void>;

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

@@ -1,6 +1,6 @@
 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<{
+export declare function getRollupConfigs([provider, plugins]: [Provider, PkgbldRollupPlugin[]], inputs: string[], inputsExt: Map<string, string>, config: CliOptions, helpers: ReturnType<typeof getHelpers>, externalPlugins: Partial<PkgbldPlugin>[]): Promise<{
     input: string[];
     output: {
         amd?: import("rollup").AmdOptions | undefined;

package/dist/src/helpers.d.ts

@@ -10,3 +10,4 @@ export declare function formatOutput(output: OutputOptions | OutputOptions[] | u
 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;
+export declare function isExists(file: string): Promise<string | false>;

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

@@ -1,2 +1,4 @@
 import { CliOptions, Json, PkgbldPlugin } from './types';
-export declare function processPackage(pkg: Json, config: CliOptions, plugins: Partial<PkgbldPlugin>[]): string[];
+declare const sourceFileSuffixes: readonly ["ts", "tsx", "js", "jsx"];
+export declare function processPackage(pkg: Json, config: CliOptions, plugins: Partial<PkgbldPlugin>[]): Promise<[string[], Map<string, typeof sourceFileSuffixes[number]>]>;
+export {};

package/dist/src/types.d.ts

@@ -41,7 +41,7 @@ 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>;
+    providePlugins(provider: Provider, config: ParsedOptions, inputs: string[], inputsExt: Map<string, string>): Promise<void>;
     getExtraOutputSettings(format: InternalModuleFormat, inputs: string[]): Partial<OutputOptions>;
     buildEnd(): Promise<void>;
 }

package/package.json

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