pkgbld 1.29.4 → 1.30.0

package/README.md

@@ -186,13 +186,31 @@ Do not setup pack script in package.json
 pkgbld --no-pack
 ```
 
+### no-exports
+
+```
+pkgbld --no-exports
+```
+
+Do not add exports field in package.json.
+
 ### prune (command)
 
 ```
 pkgbld prune
 ```
 
-prune devDependencies and redundunt scripts from package.json
+prune devDependencies and redundant scripts from package.json
+
+### prune --profile=<profile>
+
+There are two profiles: `library` and `app`. `library` is default.
+
+Right now it only affects how `prune` command removes entries in the `scripts` field.
+
+For `library` profile it retains: 'preinstall', 'install', 'postinstall', 'prepublish', 'preprepare', 'prepare', 'postprepare'.
+
+For `app` profile it retains in addition: 'prestart', 'start', 'poststart', 'prerestart', 'restart', 'postrestart', 'prestop', 'stop', 'poststop', 'pretest', 'test',        'posttest'.
 
 ### flatten
 
@@ -206,13 +224,23 @@ If the directory is not specified it is guessed from package.json.
 
 If files cannot be copied because of name conflicts the command will fail.
 
-### no-exports
+### removeSourcemaps
 
 ```
-pkgbld --no-exports
+pkgbld prune --removeSourcemaps
 ```
 
-Do not add exports field in package.json.
+Removes all sourcemaps from the package. The logic is very simple and removes all files with `.map` extension and references in format `//# sourceMappingURL=<mapFile>`.
+
+### optimizeFiles (default)
+
+```
+pkgbld prune --optimizeFiles=false
+```
+
+Optimizes files by removing all files that are not required for pack at the given moment.
+
+You might want to disable this option in some edge cases.
 
 ## Plugin API
 

package/dist/index.d.ts

@@ -40,6 +40,8 @@ declare module 'pkgbld' {
 		private?: boolean;
 		version?: string;
 		name?: string;
+		bin?: string | Record<string, string>;
+		main?: string;
 		license?: string;
 		readme?: string;
 		author?: string | {
@@ -84,11 +86,14 @@ declare module 'pkgbld' {
 		formatPackageJson: boolean;
 		noPack: boolean;
 		noExports: boolean;
+		noClean: boolean;
+		noBundle: boolean;
 	} | {
 		readonly kind: "prune";
 		readonly profile: string;
 		readonly flatten: string | boolean;
+		readonly removeSourcemaps: boolean;
+		readonly optimizeFiles: boolean;
 	};
 }
 
-//# sourceMappingURL=index.d.ts.map

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import '@niceties/draftlog-appender';
 import { createLogger } from '@niceties/logger';
 import { rollup } from 'rollup';
-import fs, { access, rename, rm, readdir, stat } from 'fs/promises';
+import fs, { access, readFile, writeFile, rm, readdir, mkdir, rename, stat } from 'fs/promises';
 import path from 'path';
 import { cli, command } from 'cleye';
 import refiner from '@slimlib/refine-partition';
@@ -148,6 +148,16 @@ const cliFlags = {
         description: 'Do not add exports field in package.json',
         default: false
     },
+    noClean: {
+        type: Boolean,
+        description: 'Do not clean output directory',
+        default: false
+    },
+    noBundle: {
+        type: Boolean,
+        description: 'Do not bundle',
+        default: false
+    },
 };
 const packageJsonFieldsOrder = new Set([
     'private',
@@ -232,7 +242,7 @@ function getCliOptions(plugins, pkg) {
         commands: [
             command({
                 name: 'prune',
-                description: 'prune devDependencies and redundunt scripts from package.json',
+                description: 'prune devDependencies and redundant scripts from package.json',
                 flags: {
                     profile: {
                         type: String,
@@ -243,6 +253,16 @@ function getCliOptions(plugins, pkg) {
                         type: FlattenParam,
                         description: 'flatten package files',
                         default: false
+                    },
+                    removeSourcemaps: {
+                        type: Boolean,
+                        description: 'remove sourcemaps',
+                        default: false
+                    },
+                    optimizeFiles: {
+                        type: Boolean,
+                        description: 'optimize files array',
+                        default: true
                     }
                 }
             })
@@ -252,7 +272,9 @@ function getCliOptions(plugins, pkg) {
         return {
             kind: 'prune',
             profile: cliOptions.flags.profile,
-            flatten: cliOptions.flags.flatten
+            flatten: cliOptions.flags.flatten,
+            removeSourcemaps: cliOptions.flags.removeSourcemaps,
+            optimizeFiles: cliOptions.flags.optimizeFiles
         };
     }
     else {
@@ -277,7 +299,9 @@ function getCliOptions(plugins, pkg) {
             umdPattern: flags.umdPattern,
             formatPackageJson: flags.formatPackageJson,
             noPack: flags.noPack,
-            noExports: flags.noExports
+            noExports: flags.noExports,
+            noClean: flags.noClean,
+            noBundle: flags.noBundle
         };
         for (const plugin of plugins) {
             plugin.options?.(flags, options);
@@ -303,7 +327,10 @@ const Priority = {
     finalize: 20000
 };
 
-async function clean (provider) {
+async function clean (provider, config) {
+    if (config.noClean) {
+        return;
+    }
     const pluginClean = await provider.import('@rollup-extras/plugin-clean');
     const pluginInstance = pluginClean();
     provider.provide(pluginFactory, Priority.cleanup, { outputPlugin: true });
@@ -508,11 +535,8 @@ function formatOutput(output, field) {
     return (Array.isArray(output) ? output : [output ?? '']).map(item => kleur.cyan(item[field])).join(', ');
 }
 function getTimeDiff(starting) {
-    const now = Date.now();
-    if (now - starting > 1000) {
-        return `${((now - starting) / 1000).toFixed(1)}s`;
-    }
-    return `${now - starting}ms`;
+    const diff = Date.now() - starting;
+    return diff >= 1000 ? `${(diff / 1000).toFixed(1)}s` : `${diff}ms`;
 }
 const areSetsEqual = (a, b) => a.size === b.size ? [...a].every(value => b.has(value)) : false;
 function formatPackageJson(pkg) {
@@ -647,7 +671,7 @@ async function getRollupConfigs([provider, plugins$1], inputs, inputsExt, config
                     break;
                 }
                 if (inputs.length > 1) {
-                    throw new Error(`Cannot produce global name for mutliple umd inputs in one output: ${inputs}`);
+                    throw new Error(`Cannot produce global name for multiple umd inputs in one output: ${inputs}`);
                 }
                 result = {
                     name: helpers.getGlobalName(inputs.join('_')),
@@ -721,15 +745,15 @@ async function processPackage(pkg, config, plugins, tsConfig) {
     const allowEsm = (config.formatsOverridden && config.formats.includes('es') || !config.formatsOverridden);
     const allowCjs = (config.formatsOverridden && config.formats.includes('cjs') || !config.formatsOverridden);
     const allowUmd = (config.formatsOverridden && config.formats.includes('umd') || !config.formatsOverridden || config.umdInputs);
-    if (typeof pkg !== 'object' || Array.isArray(pkg)) {
+    if (typeof pkg !== 'object' || Array.isArray(pkg) || pkg == null) {
         logger.finish('expecting object on top level of package.json', 3 /* LogLevel.error */);
         process.exit(-1);
     }
-    if (typeof pkg?.name !== 'string') {
+    if (typeof pkg.name !== 'string' && config.umdInputs.length > 0) {
         logger.finish('expecting name to be a string in package.json', 3 /* LogLevel.error */);
         process.exit(-1);
     }
-    if (!Array.isArray(pkg?.files)) {
+    if (!Array.isArray(pkg.files)) {
         pkg.files = [];
     }
     if (!pkg.files.includes(config.dir)) {
@@ -912,11 +936,12 @@ async function writeJson(path, json) {
     await fs.writeFile(path, toFormattedJson(json));
 }
 
-var version = "1.29.4";
+var version = "1.30.0";
 var name = "pkgbld";
 var license = "MIT";
 var author = "Konstantin Shutkin";
 var bin = "./index.js";
+var type = "module";
 var main = "./dist/index.mjs";
 var types = "./dist/index.d.ts";
 var files = [
@@ -942,7 +967,8 @@ var keywords = [
 var scripts = {
 	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"
+	prepack: "node ./index.js prune --removeSourcemaps",
+	test: "c8 --src=. --all -r=html node --env-file=ci.env tests/test.js"
 };
 var dependencies = {
 	"@niceties/logger": "^1.1.12",
@@ -968,11 +994,12 @@ var dependencies = {
 };
 var devDependencies = {
 	"@types/lodash": "^4.14.202",
-	"rollup-plugin-dts": "^6.1.0",
 	"@total-typescript/ts-reset": "^0.5.1",
-	"dts-buddy": "^0.4.4",
+	"dts-buddy": "^0.4.5",
 	options: "workspace:*",
-	xc6: "workspace:*"
+	xc6: "workspace:*",
+	c8: "^9.1.0",
+	"cli-test-helper": "workspace:*"
 };
 var peerDependencies = {
 	typescript: ">=5.3.3"
@@ -983,6 +1010,7 @@ var pkgbldPkg = {
 	license: license,
 	author: author,
 	bin: bin,
+	type: type,
 	main: main,
 	types: types,
 	files: files,
@@ -1107,6 +1135,7 @@ const defaultTsConfig = {
         allowJs: true,
         skipLibCheck: true,
         strict: true,
+        sourceMap: true,
         noUncheckedIndexedAccess: true,
         declaration: true,
         moduleResolution: 'node'
@@ -1160,9 +1189,6 @@ async function loadPlugins(pkg) {
 }
 
 async function prunePkg(pkg, options, logger) {
-    if (options.kind !== 'prune') {
-        throw new Error('prunePkg should only be called in prune mode');
-    }
     const scriptsToKeep = getScriptsData();
     const keys = scriptsToKeep[options.profile];
     if (!keys) {
@@ -1170,22 +1196,122 @@ async function prunePkg(pkg, options, logger) {
     }
     delete pkg.devDependencies;
     delete pkg['packageManager'];
-    for (const key of Object.keys(pkg.scripts)) {
-        if (!keys.has(key)) {
-            delete pkg.scripts[key];
+    if (pkg.scripts) {
+        for (const key of Object.keys(pkg.scripts)) {
+            if (!keys.has(key)) {
+                delete pkg.scripts[key];
+            }
+        }
+        if (Object.keys(pkg.scripts).length === 0) {
+            delete pkg.scripts;
         }
-    }
-    if (Object.keys(pkg.scripts).length === 0) {
-        delete pkg.scripts;
     }
     if (options.flatten) {
         await flatten(pkg, options.flatten, logger);
     }
+    if (options.removeSourcemaps) {
+        const sourceMaps = await walkDir('.').then(files => files.filter(file => file.endsWith('.map')));
+        for (const sourceMap of sourceMaps) {
+            // find corresponding file
+            const sourceFile = sourceMap.slice(0, -4);
+            // load file
+            const sourceFileContent = await readFile(sourceFile, 'utf8');
+            // find sourceMappingURL
+            const sourceMappingUrl = `//# sourceMappingURL=${path.basename(sourceMap)}`;
+            // remove sourceMappingURL
+            const newContent = sourceFileContent.replace(sourceMappingUrl, '');
+            // write file
+            await writeFile(sourceFile, newContent, 'utf8');
+            // remove sourceMap
+            await rm(sourceMap);
+        }
+    }
+    if (pkg.files && Array.isArray(pkg.files) && options.optimizeFiles) {
+        const filterFiles = ['package.json'];
+        const specialFiles = ['README', 'LICENSE', 'LICENCE'];
+        if (pkg.main && typeof pkg.main === 'string') {
+            filterFiles.push(normalizePath(pkg.main));
+        }
+        if (pkg.bin) {
+            if (typeof pkg.bin === 'string') {
+                filterFiles.push(normalizePath(pkg.bin));
+            }
+            if (typeof pkg.bin === 'object' && pkg.bin !== null) {
+                filterFiles.push(...Object.values(pkg.bin).map(normalizePath));
+            }
+        }
+        const depthToFiles = new Map();
+        for (const file of pkg.files.concat(filterFiles)) {
+            const dirname = path.dirname(file);
+            const depth = dirname.split('/').length;
+            if (!depthToFiles.has(depth)) {
+                depthToFiles.set(depth, [file]);
+            }
+            else {
+                depthToFiles.get(depth)?.push(file);
+            }
+        }
+        // walk depth keys from the highest to the lowest
+        const maxDepth = Math.max(...depthToFiles.keys());
+        for (let depth = maxDepth; depth > 0; --depth) {
+            const files = depthToFiles.get(depth);
+            const mapDirToFiles = new Map();
+            for (const file of files) {
+                const dirname = path.dirname(file);
+                const basename = normalizePath(path.basename(file));
+                if (!mapDirToFiles.has(dirname)) {
+                    mapDirToFiles.set(dirname, [basename]);
+                }
+                else {
+                    mapDirToFiles.get(dirname)?.push(basename);
+                }
+            }
+            for (const [dirname, filesInDir] of mapDirToFiles) {
+                // find out real content of the directory
+                const realFiles = await readdir(dirname);
+                // check if all files in the directory are in the filesInDir
+                const allFilesInDir = realFiles.every(file => filesInDir.includes(file)) || realFiles.length === 0;
+                if (allFilesInDir && dirname !== '.') {
+                    if (!depthToFiles.has(depth - 1)) {
+                        depthToFiles.set(depth - 1, [dirname]);
+                    }
+                    else {
+                        depthToFiles.get(depth - 1).push(dirname);
+                    }
+                    const thisDepth = depthToFiles.get(depth);
+                    depthToFiles.set(depth, thisDepth.filter(file => filesInDir.every(fileInDir => path.join(dirname, fileInDir) !== file)));
+                }
+            }
+        }
+        pkg.files = [...new Set(Array.from(depthToFiles.values()).flat())];
+        pkg.files = pkg.files.filter(file => {
+            const fileNormalized = normalizePath(file);
+            const dirname = path.dirname(fileNormalized);
+            const basenameWithoutExtension = path.basename(fileNormalized, path.extname(fileNormalized)).toUpperCase();
+            return !filterFiles.includes(fileNormalized) && (dirname !== '' && dirname !== '.' || !specialFiles.includes(basenameWithoutExtension));
+        });
+        const ignoreDirs = [];
+        for (const fileOrDir of pkg.files) {
+            if (await isDirectory(fileOrDir)) {
+                const allFiles = await walkDir(fileOrDir);
+                if (allFiles.every(file => {
+                    const fileNormalized = normalizePath(file);
+                    return filterFiles.includes(fileNormalized);
+                })) {
+                    ignoreDirs.push(fileOrDir);
+                }
+            }
+        }
+        pkg.files = pkg.files.filter(dir => !ignoreDirs.includes(dir));
+        if (pkg.files.length === 0) {
+            delete pkg.files;
+        }
+    }
 }
 async function flatten(pkg, flatten, logger) {
     const { default: jsonata } = await import('jsonata');
     // find out where is the dist folder
-    const expression = jsonata('[bin, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*]');
+    const expression = jsonata('[bin, bin.*, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*, directories.bin]');
     const allReferences = (await expression.evaluate(pkg));
     let distDir;
     if (flatten === true) {
@@ -1231,6 +1357,14 @@ async function flatten(pkg, flatten, logger) {
     if (filesAlreadyExist.length) {
         throw new Error(`dist folder cannot be flattened because files already exist: ${filesAlreadyExist.join(', ')}`);
     }
+    // create new directory structure
+    const mkdirPromises = [];
+    for (const file of filesInDist) {
+        // check file is not in root dir
+        const relativePath = path.relative(relativeDistDir, file);
+        mkdirPromises.push(mkdir(path.dirname(relativePath), { recursive: true }));
+    }
+    await Promise.all(mkdirPromises);
     // move files to root dir (rename)
     const renamePromises = [];
     const newFiles = [];
@@ -1241,30 +1375,31 @@ async function flatten(pkg, flatten, logger) {
         renamePromises.push(rename(file, relativePath));
     }
     await Promise.all(renamePromises);
-    // remove dist folder
-    try {
-        await rm(relativeDistDir, { recursive: true, force: true });
-    }
-    catch (e) {
-        // ignore
+    let cleanedDir = relativeDistDir;
+    while (isEmptyDir(cleanedDir)) {
+        await rm(cleanedDir, { recursive: true, force: true });
+        const parentDir = path.dirname(cleanedDir);
+        if (parentDir === '.') {
+            break;
+        }
+        cleanedDir = parentDir;
     }
+    const normalizedCleanDir = normalizePath(cleanedDir);
     const allReferencesSet = new Set(allReferences);
     // update package.json
-    const stringToReplace = distDir + '/';
+    const stringToReplace = distDir + '/'; // we append / to remove in from the middle of the string
     const pkgClone = cloneAndUpdate(pkg, value => allReferencesSet.has(value) ? value.replace(stringToReplace, '') : value);
     Object.assign(pkg, pkgClone);
     // update files
-    let files = pkg.files ?? [];
-    files = files.filter(file => {
-        let fileNormilized = path.normalize(file);
-        if (fileNormilized.endsWith('/')) {
-            // remove trailing slash
-            fileNormilized = fileNormilized.slice(0, -1);
-        }
-        return fileNormilized !== distDir;
-    });
-    files.push(...newFiles);
-    pkg.files = [...files];
+    let files = pkg.files;
+    if (files) {
+        files = files.filter(file => {
+            const fileNormalized = normalizePath(file);
+            return !isSubDirectory(cleanedDir, fileNormalized) && fileNormalized !== normalizedCleanDir;
+        });
+        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) {
@@ -1283,6 +1418,14 @@ async function flatten(pkg, flatten, logger) {
         }
     }
 }
+function normalizePath(file) {
+    let fileNormalized = path.normalize(file);
+    if (fileNormalized.endsWith('/') || fileNormalized.endsWith('\\')) {
+        // remove trailing slash
+        fileNormalized = fileNormalized.slice(0, -1);
+    }
+    return fileNormalized;
+}
 function cloneAndUpdate(pkg, updater) {
     if (typeof pkg === 'string') {
         return updater(pkg);
@@ -1299,12 +1442,16 @@ function cloneAndUpdate(pkg, updater) {
     }
     return pkg;
 }
+function isSubDirectory(parent, child) {
+    return path.relative(child, parent).startsWith('..');
+}
+async function isEmptyDir(dir) {
+    const entries = await readdir(dir);
+    return entries.length === 0;
+}
 async function isDirectory(file) {
-    try {
-        const fileStat = await stat(file);
-        return fileStat.isDirectory();
-    }
-    catch (e) { /**/ }
+    const fileStat = await stat(file);
+    return fileStat.isDirectory();
 }
 async function walkDir(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
@@ -1384,6 +1531,9 @@ async function execute() {
         const preimportMap = preimport();
         const provider = options.eject ? await createEjectProvider(preimportMap) : createProvider(preimportMap);
         const rollupConfigs = await getRollupConfigs(provider, inputs, inputsExt, options, helpers, plugins);
+        if (options.noBundle) {
+            rollupConfigs.length = 0;
+        }
         if (options.eject) {
             await ejectConfig(rollupConfigs, pkgPath, options, inputs, inputsExt, helpers, pkg);
             mainLogger.finish(`ejected config in ${getTimeDiff(time)}`);
@@ -1406,7 +1556,7 @@ async function execute() {
         }
     }
     catch (e) {
-        mainLogger.finish(JSON.stringify(e), 3 /* LogLevel.error */);
+        mainLogger.finish(String(e), 3 /* LogLevel.error */);
         process.exit(-1);
     }
     async function buildConfig(config, updater) {
@@ -1424,3 +1574,4 @@ function preimport() {
         ['@rollup-extras/plugin-externals', import('@rollup-extras/plugin-externals')]
     ]) : new Map);
 }
+

package/package.json

@@ -1,9 +1,10 @@
 {
-  "version": "1.29.4",
+  "version": "1.30.0",
   "name": "pkgbld",
   "license": "MIT",
   "author": "Konstantin Shutkin",
   "bin": "./index.js",
+  "type": "module",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [

package/dist/index.d.ts.map

@@ -1,26 +0,0 @@
-{
-	"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"
-}