pkgprn 0.5.0 → 0.5.2

package/{src/prune.js → prune.js}

@@ -4,75 +4,28 @@ import path from 'node:path';
 import { extractReferences } from './extract-references.js';
 import { adjustSourcemapLineMappings, isStrippableFile, parseCommentTypes, stripCommentsWithLineMap } from './strip-comments.js';
 
-/**
- * Files always included by npm regardless of the `files` array.
- * README & LICENSE/LICENCE are matched case-insensitively by basename (without extension).
- */
 const alwaysIncludedExact = ['package.json'];
 const alwaysIncludedBasenames = ['README', 'LICENSE', 'LICENCE'];
 
-/**
- * Files/directories always ignored by npm by default.
- */
 const alwaysIgnored = ['.DS_Store', '.hg', '.lock-wscript', '.svn', 'CVS', 'config.gypi', 'npm-debug.log'];
 
-/**
- * Glob-like patterns for always-ignored files.
- * Each entry has a `test` function that checks whether a basename matches.
- */
 const alwaysIgnoredPatterns = [
-    /** `*.orig` */
-    { test: (/** @type {string} */ basename) => basename.endsWith('.orig') },
-    /** `.*.swp` */
-    { test: (/** @type {string} */ basename) => basename.startsWith('.') && basename.endsWith('.swp') },
-    /** `._*` */
-    { test: (/** @type {string} */ basename) => basename.startsWith('._') },
-    /** `.wafpickle-N` */
-    { test: (/** @type {string} */ basename) => /^\.wafpickle-\d+$/.test(basename) },
+
+    { test: ( basename) => basename.endsWith('.orig') },
+
+    { test: ( basename) => basename.startsWith('.') && basename.endsWith('.swp') },
+
+    { test: ( basename) => basename.startsWith('._') },
+
+    { test: ( basename) => /^\.wafpickle-\d+$/.test(basename) },
 ];
 
-/**
- * Subset of always-ignored that can never be included, even if listed in `files`.
- */
 const hardIgnored = new Set(['.git', '.npmrc', 'node_modules', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb']);
 
-/**
- * @typedef {import('@niceties/logger').Logger} Logger
- */
-
-/**
- * @typedef {Object} PackageJson
- * @property {Object.<string, string>} [scripts]
- * @property {Object.<string, string>} [devDependencies]
- * @property {string} [packageManager]
- * @property {string} [main]
- * @property {string|Object.<string, string>} [bin]
- * @property {Array<string>} [files]
- * @property {Record<string, unknown>} [directories]
- * @property {Record<string, unknown>} [exports]
- * @property {Record<string, unknown>} [typesVersions]
- */
-
-/**
- * @typedef {Object} PruneOptions
- * @property {string} profile
- * @property {string|boolean} flatten
- * @property {boolean} removeSourcemaps
- * @property {string|boolean} stripComments
- * @property {boolean} optimizeFiles
- * @property {boolean} cleanupFiles
- */
-
-/**
- * Prunes a package.json object according to the given options.
- * @param {PackageJson} pkg
- * @param {PruneOptions} options
- * @param {Logger} logger
- */
 export async function prunePkg(pkg, options, logger) {
     const scriptsToKeep = getScriptsData();
 
-    const keys = scriptsToKeep[/** @type {'library'|'app'} */ (options.profile)];
+    const keys = scriptsToKeep[ (options.profile)];
 
     if (!keys) {
         throw new Error(`unknown profile ${options.profile}`);
@@ -106,30 +59,28 @@ export async function prunePkg(pkg, options, logger) {
     if (options.removeSourcemaps) {
         const sourceMaps = await walkDir('.', ['node_modules']).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 = `\n//# sourceMappingURL=${path.basename(sourceMap)}`;
-            // remove sourceMappingURL
+
             const newContent = sourceFileContent.replace(sourceMappingUrl, '');
-            // write file
+
             await writeFile(sourceFile, newContent, 'utf8');
-            // remove sourceMap
+
             await rm(sourceMap);
         }
     }
 
     if (options.stripComments) {
-        const typesToStrip = parseCommentTypes(/** @type {string | true} */ (options.stripComments));
+        const typesToStrip = parseCommentTypes( (options.stripComments));
         logger.update('stripping comments...');
         const allFiles = await walkDir('.', ['node_modules']);
         const jsFiles = allFiles.filter(isStrippableFile);
         const dtsMapFiles = allFiles.filter(f => f.endsWith('.d.ts.map'));
 
-        // Strip comments from JS files and collect line maps keyed by file path.
-        /** @type {Map<string, Int32Array>} */
         const lineMaps = new Map();
         for (const file of jsFiles) {
             const content = await readFile(file, 'utf8');
@@ -140,7 +91,6 @@ export async function prunePkg(pkg, options, logger) {
             }
         }
 
-        // Adjust .d.ts.map files that reference any of the stripped JS files.
         if (lineMaps.size > 0 && dtsMapFiles.length > 0) {
             for (const mapFile of dtsMapFiles) {
                 const mapContent = await readFile(mapFile, 'utf8');
@@ -184,7 +134,6 @@ export async function prunePkg(pkg, options, logger) {
             }
         }
 
-        // 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);
@@ -199,9 +148,9 @@ export async function prunePkg(pkg, options, logger) {
                 }
             }
             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)) {
@@ -212,8 +161,8 @@ export async function prunePkg(pkg, options, logger) {
                     const thisDepth = depthToFiles.get(depth);
                     depthToFiles.set(
                         depth,
-                        thisDepth.filter((/** @type {string} */ file) =>
-                            filesInDir.every((/** @type {string} */ fileInDir) => path.join(dirname, fileInDir) !== file)
+                        thisDepth.filter(( file) =>
+                            filesInDir.every(( fileInDir) => path.join(dirname, fileInDir) !== file)
                         )
                     );
                 }
@@ -222,7 +171,7 @@ export async function prunePkg(pkg, options, logger) {
 
         pkg.files = [...new Set(Array.from(depthToFiles.values()).flat())];
 
-        pkg.files = pkg.files.filter((/** @type {string} */ file) => {
+        pkg.files = pkg.files.filter(( file) => {
             const fileNormalized = normalizePath(file);
             const dirname = path.dirname(fileNormalized);
             const basenameWithoutExtension = path.basename(fileNormalized, path.extname(fileNormalized)).toUpperCase();
@@ -232,16 +181,13 @@ export async function prunePkg(pkg, options, logger) {
             );
         });
 
-        /**
-         * @type {string[]}
-         */
         const ignoreDirs = [];
 
         for (const fileOrDir of pkg.files) {
             if (await isDirectory(fileOrDir)) {
                 const allFiles = await walkDir(fileOrDir);
                 if (
-                    allFiles.every((/** @type {string} */ file) => {
+                    allFiles.every(( file) => {
                         const fileNormalized = normalizePath(file);
                         return filterFiles.includes(fileNormalized);
                     })
@@ -263,26 +209,12 @@ export async function prunePkg(pkg, options, logger) {
     }
 }
 
-/**
- * Flattens the dist directory and updates package.json references.
- * Supports multiple directories (comma-separated when passed as a string).
- * @param {PackageJson} pkg
- * @param {string|true} flatten
- * @param {Logger} logger
- */
 async function flatten(pkg, flatten, logger) {
-    // find out where is the dist folder
 
     const allReferences = extractReferences(pkg);
 
-    /** @type {string[]} */
     let distDirs;
 
-    // at this point we requested directories.bin, but it is the only one that is directory and not a file
-    // later when we get dirname we can't flatten directories.bin completely
-    // it is easy to fix by checking element is a directory but it is kind of good
-    // to have it as a separate directory, but user still can flatten it by specifying the directory
-
     if (flatten === true) {
         let commonSegments;
 
@@ -311,7 +243,7 @@ async function flatten(pkg, flatten, logger) {
         }
         distDirs = [distDir];
     } else {
-        // split on comma to support multiple directories
+
         distDirs = flatten
             .split(',')
             .map(d => normalizePath(d.trim()))
@@ -320,9 +252,6 @@ async function flatten(pkg, flatten, logger) {
 
     logger.update(`flattening ${distDirs.join(', ')}...`);
 
-    // collect files from all dist directories
-
-    /** @type {Map<string, { distDir: string, relativeDistDir: string, files: string[] }>} */
     const distDirInfo = new Map();
 
     for (const distDir of distDirs) {
@@ -331,26 +260,21 @@ async function flatten(pkg, flatten, logger) {
         distDirInfo.set(distDir, { distDir, relativeDistDir, files });
     }
 
-    // check for conflicts: files already existing in root AND cross-directory collisions
-
-    /** @type {Map<string, string>} */
     const destinationToSource = new Map();
     const existsPromises = [];
-    /** @type {string[]} */
+
     const existsKeys = [];
 
     for (const [distDir, info] of distDirInfo) {
         for (const file of info.files) {
             const relativePath = path.relative(info.relativeDistDir, file);
 
-            // check for cross-directory conflicts
             if (destinationToSource.has(relativePath)) {
                 const otherDir = destinationToSource.get(relativePath);
                 throw new Error(`cannot flatten because '${relativePath}' exists in both '${otherDir}' and '${distDir}'`);
             }
             destinationToSource.set(relativePath, distDir);
 
-            // check if file already exists in root
             existsKeys.push(relativePath);
             existsPromises.push(isExists(relativePath));
         }
@@ -364,7 +288,6 @@ async function flatten(pkg, flatten, logger) {
         throw new Error(`dist folder cannot be flattened because files already exist: ${filesAlreadyExist.join(', ')}`);
     }
 
-    // handle directories.bin special case for each dist dir
     for (const distDir of distDirs) {
         if (
             'directories' in pkg &&
@@ -390,7 +313,6 @@ async function flatten(pkg, flatten, logger) {
         }
     }
 
-    // create new directory structure
     const mkdirPromises = [];
     for (const [, info] of distDirInfo) {
         for (const file of info.files) {
@@ -401,11 +323,9 @@ async function flatten(pkg, flatten, logger) {
 
     await Promise.all(mkdirPromises);
 
-    // move files to root dir (rename)
     const renamePromises = [];
     const newFiles = [];
 
-    /** @type {Map<string, string>} maps new path -> old path */
     const movedFiles = new Map();
 
     for (const [, info] of distDirInfo) {
@@ -419,12 +339,8 @@ async function flatten(pkg, flatten, logger) {
 
     await Promise.all(renamePromises);
 
-    // adjust sourcemap paths for explicit flatten only
-    // (automatic flatten is safe because the common prefix is derived from package.json references)
     if (typeof flatten === 'string') {
-        // build reverse map: normalized old path -> new path
-        // so we can fix sources that point to files which themselves moved
-        /** @type {Map<string, string>} */
+
         const oldToNew = new Map();
         for (const [newPath, oldPath] of movedFiles) {
             oldToNew.set(path.normalize(oldPath), newPath);
@@ -439,8 +355,6 @@ async function flatten(pkg, flatten, logger) {
         }
     }
 
-    // clean up empty source directories
-    /** @type {string[]} */
     const cleanedDirs = [];
     for (const [, info] of distDirInfo) {
         let cleanedDir = info.relativeDistDir;
@@ -457,7 +371,6 @@ async function flatten(pkg, flatten, logger) {
 
     const allReferencesSet = new Set(allReferences);
 
-    // update package.json - replace each distDir prefix in references
     const stringsToReplace = distDirs.map(d => `${d}/`);
     const pkgClone = cloneAndUpdate(pkg, value => {
         if (!allReferencesSet.has(value)) {
@@ -472,7 +385,6 @@ async function flatten(pkg, flatten, logger) {
     });
     Object.assign(pkg, pkgClone);
 
-    // update files
     let files = pkg.files;
     if (files) {
         files = files.filter(file => {
@@ -483,7 +395,6 @@ async function flatten(pkg, flatten, logger) {
         pkg.files = [...files];
     }
 
-    // remove extra directories with package.json
     const exports = pkg.exports ? Object.keys(pkg.exports) : [];
     for (const key of exports) {
         if (key === '.') {
@@ -493,7 +404,7 @@ async function flatten(pkg, flatten, logger) {
         if (isDir) {
             const pkgPath = path.join(key, 'package.json');
             const pkgExists = await isExists(pkgPath);
-            // ensure nothing else is in the directory
+
             const files = await readdir(key);
             if (files.length === 1 && pkgExists) {
                 await rm(key, { recursive: true, force: true });
@@ -502,25 +413,15 @@ async function flatten(pkg, flatten, logger) {
     }
 }
 
-/**
- * @param {string} file
- * @returns {string}
- */
 function normalizePath(file) {
     let fileNormalized = path.normalize(file);
     if (fileNormalized.endsWith('/') || fileNormalized.endsWith('\\')) {
-        // remove trailing slash
+
         fileNormalized = fileNormalized.slice(0, -1);
     }
     return fileNormalized;
 }
 
-/**
- * Deep clones an object/array and updates all string values using the updater function
- * @param {unknown} pkg
- * @param {(value: string) => string} updater
- * @returns {unknown}
- */
 function cloneAndUpdate(pkg, updater) {
     if (typeof pkg === 'string') {
         return updater(pkg);
@@ -529,24 +430,16 @@ function cloneAndUpdate(pkg, updater) {
         return pkg.map(value => cloneAndUpdate(value, updater));
     }
     if (typeof pkg === 'object' && pkg !== null) {
-        /** @type {Record<string, unknown>} */
+
         const clone = {};
         for (const key of Object.keys(pkg)) {
-            clone[key] = cloneAndUpdate(/** @type {Record<string, unknown>} */ (pkg)[key], updater);
+            clone[key] = cloneAndUpdate( (pkg)[key], updater);
         }
         return clone;
     }
     return pkg;
 }
 
-/**
- * Adjusts the `sources` (and `sourceRoot`) in a v3 sourcemap file after it has been moved.
- * Resolves each source against the old location, then makes it relative to the new location.
- * If a source target was itself moved during flatten, the new location is used instead.
- * @param {string} newMapPath - The new path of the .map file (relative to project root).
- * @param {string} oldMapPath - The old path of the .map file (relative to project root).
- * @param {Map<string, string>} oldToNew - Map from normalized old file paths to their new paths.
- */
 async function adjustSourcemapPaths(newMapPath, oldMapPath, oldToNew) {
     const content = await readFile(newMapPath, 'utf8');
 
@@ -554,7 +447,7 @@ async function adjustSourcemapPaths(newMapPath, oldMapPath, oldToNew) {
     try {
         map = JSON.parse(content);
     } catch {
-        return; // not valid JSON, skip
+        return;
     }
 
     if (map.version !== 3 || !Array.isArray(map.sources)) {
@@ -565,18 +458,17 @@ async function adjustSourcemapPaths(newMapPath, oldMapPath, oldToNew) {
     const newDir = path.dirname(newMapPath) || '.';
     const sourceRoot = map.sourceRoot || '';
 
-    map.sources = map.sources.map((/** @type {string} */ source) => {
-        // Resolve source against old map location (incorporating sourceRoot)
+    map.sources = map.sources.map(( source) => {
+
         const resolved = path.normalize(path.join(oldDir, sourceRoot, source));
-        // If the resolved source was itself moved, use its new location
+
         const effective = oldToNew.get(resolved) ?? resolved;
-        // Make relative to new map location
+
         const newRelative = path.relative(newDir, effective);
-        // Sourcemaps always use forward slashes
+
         return newRelative.split(path.sep).join('/');
     });
 
-    // sourceRoot has been incorporated into the individual source paths
     if (map.sourceRoot !== undefined) {
         delete map.sourceRoot;
     }
@@ -584,47 +476,26 @@ async function adjustSourcemapPaths(newMapPath, oldMapPath, oldToNew) {
     await writeFile(newMapPath, `${JSON.stringify(map, null, 2)}\n`, 'utf8');
 }
 
-/**
- * @param {string} parent
- * @param {string} child
- * @returns {boolean}
- */
 function isSubDirectory(parent, child) {
     const rel = path.relative(parent, child);
     return rel !== '' && !rel.startsWith('..');
 }
 
-/**
- * @param {string} dir
- * @returns {Promise<boolean>}
- */
 async function isEmptyDir(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     return entries.filter(entry => !entry.isDirectory()).length === 0;
 }
 
-/**
- * @param {string} file
- * @returns {Promise<boolean>}
- */
 async function isDirectory(file) {
     const fileStat = await stat(file);
     return fileStat.isDirectory();
 }
 
-/**
- * @param {string} dir
- * @param {Array<string>} [ignoreDirs=[]]
- * @returns {Promise<Array<string>>}
- */
 async function walkDir(dir, ignoreDirs = []) {
     const entries = await readdir(dir, { withFileTypes: true });
-    /**
-     * @type {string[]}
-     */
+
     const files = [];
 
-    // Process files first
     for (const entry of entries) {
         if (!entry.isDirectory()) {
             const childPath = path.join(entry.parentPath, entry.name);
@@ -632,7 +503,6 @@ async function walkDir(dir, ignoreDirs = []) {
         }
     }
 
-    // Then process directories
     for (const entry of entries) {
         if (entry.isDirectory()) {
             const childPath = path.join(entry.parentPath, entry.name);
@@ -649,9 +519,6 @@ async function walkDir(dir, ignoreDirs = []) {
     return files;
 }
 
-/**
- * @param {string} file
- */
 async function isExists(file) {
     try {
         await access(file);
@@ -664,12 +531,6 @@ async function isExists(file) {
     return file;
 }
 
-/**
- * Returns the list of files always included by npm for a given package.
- * This includes `package.json`, the `main` entry, and all `bin` entries.
- * @param {PackageJson} pkg
- * @returns {string[]}
- */
 function getAlwaysIncludedFiles(pkg) {
     const files = [...alwaysIncludedExact];
     if (pkg.main && typeof pkg.main === 'string') {
@@ -686,11 +547,6 @@ function getAlwaysIncludedFiles(pkg) {
     return files;
 }
 
-/**
- * Checks whether a file or directory name matches the always-ignored patterns.
- * @param {string} basename - The basename of the file or directory.
- * @returns {boolean}
- */
 function isAlwaysIgnored(basename) {
     if (alwaysIgnored.includes(basename)) {
         return true;
@@ -698,10 +554,6 @@ function isAlwaysIgnored(basename) {
     return alwaysIgnoredPatterns.some(pattern => pattern.test(basename));
 }
 
-/**
- * Recursively removes junk files (always-ignored by npm) from a directory tree.
- * @param {string} dir
- */
 async function removeJunkFiles(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
@@ -717,11 +569,6 @@ async function removeJunkFiles(dir) {
     }
 }
 
-/**
- * Checks whether a root-level file is always included by npm (case-insensitive basename match).
- * @param {string} file - The file path relative to the package root.
- * @returns {boolean}
- */
 function isAlwaysIncludedByBasename(file) {
     const dir = path.dirname(file);
     if (dir !== '' && dir !== '.') {
@@ -731,17 +578,11 @@ function isAlwaysIncludedByBasename(file) {
     return alwaysIncludedBasenames.includes(basenameWithoutExtension);
 }
 
-/**
- * Removes files from the working directory that are not included in the `files` array
- * or the always-included list, then drops the `files` array from package.json.
- * @param {PackageJson} pkg
- * @param {Logger} logger
- */
 async function cleanupDir(pkg, logger) {
     logger.update('cleaning up files...');
 
     const alwaysIncludedFiles = getAlwaysIncludedFiles(pkg);
-    const filesEntries = /** @type {string[]} */ (pkg.files).map(normalizePath);
+    const filesEntries =  (pkg.files).map(normalizePath);
 
     const entries = await readdir('.');
 
@@ -752,42 +593,30 @@ async function cleanupDir(pkg, logger) {
 
         const normalized = normalizePath(entry);
 
-        // check if matched by files entries (exact or parent directory)
         if (filesEntries.some(f => normalized === f || normalized.startsWith(`${f}/`))) {
             continue;
         }
 
-        // check if any files entry is under this directory
         if (filesEntries.some(f => f.startsWith(`${normalized}/`))) {
-            // need to recurse into this directory for granular cleanup
+
             await cleanupSubDir(normalized, filesEntries, alwaysIncludedFiles);
             continue;
         }
 
-        // check if always-included by exact path
         if (alwaysIncludedFiles.includes(normalized)) {
             continue;
         }
 
-        // check if always-included by basename (root level)
         if (isAlwaysIncludedByBasename(normalized)) {
             continue;
         }
 
-        // not matched - remove
         await rm(entry, { recursive: true, force: true });
     }
 
     pkg.files = undefined;
 }
 
-/**
- * Recursively cleans up a subdirectory, keeping only files matched by the files entries
- * or always-included files.
- * @param {string} dir
- * @param {string[]} filesEntries
- * @param {string[]} alwaysIncludedFiles
- */
 async function cleanupSubDir(dir, filesEntries, alwaysIncludedFiles) {
     const entries = await readdir(dir);
 
@@ -800,27 +629,22 @@ async function cleanupSubDir(dir, filesEntries, alwaysIncludedFiles) {
 
         const normalized = normalizePath(fullPath);
 
-        // check if matched by files entries
         if (filesEntries.some(f => normalized === f || normalized.startsWith(`${f}/`))) {
             continue;
         }
 
-        // check if any files entry is under this path
         if (filesEntries.some(f => f.startsWith(`${normalized}/`))) {
             await cleanupSubDir(normalized, filesEntries, alwaysIncludedFiles);
             continue;
         }
 
-        // check if always-included by exact path
         if (alwaysIncludedFiles.includes(normalized)) {
             continue;
         }
 
-        // not matched - remove
         await rm(fullPath, { recursive: true, force: true });
     }
 
-    // remove the directory if it's now empty
     const remaining = await readdir(dir);
     if (remaining.length === 0) {
         await rm(dir, { recursive: true, force: true });