pkgprn 0.1.0 → 0.2.1

package/prune.js

@@ -1,18 +1,40 @@
-import {
-    access,
-    mkdir,
-    readdir,
-    readFile,
-    rename,
-    rm,
-    stat,
-    writeFile,
-} from 'node:fs/promises';
+import { access, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 /**
- * @typedef {Object} Logger
- * @property {function(string): void} update
+ * 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) },
+];
+
+/**
+ * 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
  */
 
 /**
@@ -23,9 +45,9 @@ import path from 'node:path';
  * @property {string} [main]
  * @property {string|Object.<string, string>} [bin]
  * @property {Array<string>} [files]
- * @property {Object} [directories]
- * @property {Object} [exports]
- * @property {Object} [typesVersions]
+ * @property {Record<string, unknown>} [directories]
+ * @property {Record<string, unknown>} [exports]
+ * @property {Record<string, unknown>} [typesVersions]
  */
 
 /**
@@ -34,6 +56,7 @@ import path from 'node:path';
  * @property {string|boolean} flatten
  * @property {boolean} removeSourcemaps
  * @property {boolean} optimizeFiles
+ * @property {boolean} cleanupFiles
  */
 
 /**
@@ -45,8 +68,7 @@ import path from 'node:path';
 export async function prunePkg(pkg, options, logger) {
     const scriptsToKeep = getScriptsData();
 
-    const keys =
-        scriptsToKeep[/** @type {'library'|'app'} */ (options.profile)];
+    const keys = scriptsToKeep[/** @type {'library'|'app'} */ (options.profile)];
 
     if (!keys) {
         throw new Error(`unknown profile ${options.profile}`);
@@ -67,14 +89,18 @@ export async function prunePkg(pkg, options, logger) {
         }
     }
 
+    if (options.cleanupFiles) {
+        await removeJunkFiles('.');
+    } else if (options.flatten) {
+        logger('cleanup is disabled, junk files may cause flatten to fail', 2);
+    }
+
     if (options.flatten) {
         await flatten(pkg, options.flatten, logger);
     }
 
     if (options.removeSourcemaps) {
-        const sourceMaps = await walkDir('.', ['node_modules']).then((files) =>
-            files.filter((file) => file.endsWith('.map'))
-        );
+        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);
@@ -92,19 +118,7 @@ export async function prunePkg(pkg, options, logger) {
     }
 
     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 filterFiles = getAlwaysIncludedFiles(pkg);
 
         const depthToFiles = new Map();
 
@@ -136,9 +150,7 @@ export async function prunePkg(pkg, options, logger) {
                 // 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;
+                const allFilesInDir = realFiles.every(file => filesInDir.includes(file)) || realFiles.length === 0;
                 if (allFilesInDir && dirname !== '.') {
                     if (!depthToFiles.has(depth - 1)) {
                         depthToFiles.set(depth - 1, [dirname]);
@@ -149,10 +161,7 @@ export async function prunePkg(pkg, options, logger) {
                     depthToFiles.set(
                         depth,
                         thisDepth.filter((/** @type {string} */ file) =>
-                            filesInDir.every(
-                                (/** @type {string} */ fileInDir) =>
-                                    path.join(dirname, fileInDir) !== file
-                            )
+                            filesInDir.every((/** @type {string} */ fileInDir) => path.join(dirname, fileInDir) !== file)
                         )
                     );
                 }
@@ -164,13 +173,10 @@ export async function prunePkg(pkg, options, logger) {
         pkg.files = pkg.files.filter((/** @type {string} */ file) => {
             const fileNormalized = normalizePath(file);
             const dirname = path.dirname(fileNormalized);
-            const basenameWithoutExtension = path
-                .basename(fileNormalized, path.extname(fileNormalized))
-                .toUpperCase();
+            const basenameWithoutExtension = path.basename(fileNormalized, path.extname(fileNormalized)).toUpperCase();
             return (
                 !filterFiles.includes(fileNormalized) &&
-                ((dirname !== '' && dirname !== '.') ||
-                    !specialFiles.includes(basenameWithoutExtension))
+                ((dirname !== '' && dirname !== '.') || !alwaysIncludedBasenames.includes(basenameWithoutExtension))
             );
         });
 
@@ -193,16 +199,21 @@ export async function prunePkg(pkg, options, logger) {
             }
         }
 
-        pkg.files = pkg.files.filter((dir) => !ignoreDirs.includes(dir));
+        pkg.files = pkg.files.filter(dir => !ignoreDirs.includes(dir));
 
         if (pkg.files.length === 0) {
             pkg.files = undefined;
         }
     }
+
+    if (pkg.files && Array.isArray(pkg.files) && options.cleanupFiles) {
+        await cleanupDir(pkg, 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
@@ -212,11 +223,11 @@ async function flatten(pkg, flatten, logger) {
 
     // find out where is the dist folder
 
-    const expression = jsonata(
-        '[bin, bin.*, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*, directories.bin]'
-    );
+    const expression = jsonata('[bin, bin.*, main, module, unpkg, umd, types, typings, exports[].*.*, typesVersions.*.*, directories.bin]');
     const allReferences = await expression.evaluate(pkg);
-    let distDir;
+
+    /** @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
@@ -233,9 +244,7 @@ async function flatten(pkg, flatten, logger) {
 
             const dirname = path.dirname(entry);
 
-            const cleanedSegments = dirname
-                .split('/')
-                .filter((path) => path && path !== '.');
+            const cleanedSegments = dirname.split('/').filter(path => path && path !== '.');
             if (!commonSegments) {
                 commonSegments = cleanedSegments;
             } else {
@@ -247,29 +256,55 @@ async function flatten(pkg, flatten, logger) {
                 }
             }
         }
-        distDir = commonSegments?.join('/');
+        const distDir = commonSegments?.join('/');
+        if (!distDir) {
+            throw new Error('could not find dist folder');
+        }
+        distDirs = [distDir];
     } else {
-        distDir = normalizePath(flatten);
+        // split on comma to support multiple directories
+        distDirs = flatten
+            .split(',')
+            .map(d => normalizePath(d.trim()))
+            .filter(Boolean);
     }
 
-    if (!distDir) {
-        throw new Error('could not find dist folder');
-    }
+    logger.update(`flattening ${distDirs.join(', ')}...`);
 
-    logger.update(`flattening ${distDir}...`);
+    // collect files from all dist directories
 
-    // check if dist can be flattened
+    /** @type {Map<string, { distDir: string, relativeDistDir: string, files: string[] }>} */
+    const distDirInfo = new Map();
 
-    const relativeDistDir = `./${distDir}`;
+    for (const distDir of distDirs) {
+        const relativeDistDir = `./${distDir}`;
+        const files = await walkDir(relativeDistDir);
+        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);
 
-    const filesInDist = await walkDir(relativeDistDir);
+            // 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);
 
-    for (const file of filesInDist) {
-        // check file is not in root dir
-        const relativePath = path.relative(relativeDistDir, file);
-        existsPromises.push(isExists(relativePath));
+            // check if file already exists in root
+            existsKeys.push(relativePath);
+            existsPromises.push(isExists(relativePath));
+        }
     }
 
     const exists = await Promise.all(existsPromises);
@@ -277,44 +312,42 @@ async function flatten(pkg, flatten, logger) {
     const filesAlreadyExist = exists.filter(Boolean);
 
     if (filesAlreadyExist.length) {
-        throw new Error(
-            `dist folder cannot be flattened because files already exist: ${filesAlreadyExist.join(', ')}`
-        );
-    }
-
-    if (
-        typeof flatten === 'string' &&
-        'directories' in pkg &&
-        pkg.directories != null &&
-        typeof pkg.directories === 'object' &&
-        'bin' in pkg.directories &&
-        typeof pkg.directories.bin === 'string' &&
-        normalizePath(pkg.directories.bin) === normalizePath(flatten)
-    ) {
-        // biome-ignore lint/performance/noDelete: <explanation>
-        delete pkg.directories.bin;
-        if (Object.keys(pkg.directories).length === 0) {
-            pkg.directories = undefined;
-        }
-        const files = await readdir(flatten);
-        if (files.length === 1) {
-            pkg.bin = files[0];
-        } else {
-            pkg.bin = {};
-            for (const file of files) {
-                pkg.bin[path.basename(file, path.extname(file))] = file;
+        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 &&
+            pkg.directories != null &&
+            typeof pkg.directories === 'object' &&
+            'bin' in pkg.directories &&
+            typeof pkg.directories.bin === 'string' &&
+            normalizePath(pkg.directories.bin) === distDir
+        ) {
+            delete pkg.directories.bin;
+            if (Object.keys(pkg.directories).length === 0) {
+                pkg.directories = undefined;
+            }
+            const files = await readdir(distDir);
+            if (files.length === 1) {
+                pkg.bin = files[0];
+            } else {
+                pkg.bin = {};
+                for (const file of files) {
+                    pkg.bin[path.basename(file, path.extname(file))] = file;
+                }
             }
         }
     }
 
     // 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 })
-        );
+    for (const [, info] of distDirInfo) {
+        for (const file of info.files) {
+            const relativePath = path.relative(info.relativeDistDir, file);
+            mkdirPromises.push(mkdir(path.dirname(relativePath), { recursive: true }));
+        }
     }
 
     await Promise.all(mkdirPromises);
@@ -323,45 +356,55 @@ async function flatten(pkg, flatten, logger) {
     const renamePromises = [];
     const newFiles = [];
 
-    for (const file of filesInDist) {
-        // check file is not in root dir
-        const relativePath = path.relative(relativeDistDir, file);
-        newFiles.push(relativePath);
-        renamePromises.push(rename(file, relativePath));
+    for (const [, info] of distDirInfo) {
+        for (const file of info.files) {
+            const relativePath = path.relative(info.relativeDistDir, file);
+            newFiles.push(relativePath);
+            renamePromises.push(rename(file, relativePath));
+        }
     }
 
     await Promise.all(renamePromises);
 
-    let cleanedDir = relativeDistDir;
-    while (await isEmptyDir(cleanedDir)) {
-        await rm(cleanedDir, { recursive: true, force: true });
-        const parentDir = path.dirname(cleanedDir);
-        if (parentDir === '.') {
-            break;
+    // clean up empty source directories
+    /** @type {string[]} */
+    const cleanedDirs = [];
+    for (const [, info] of distDirInfo) {
+        let cleanedDir = info.relativeDistDir;
+        while (await isEmptyDir(cleanedDir)) {
+            await rm(cleanedDir, { recursive: true, force: true });
+            const parentDir = path.dirname(cleanedDir);
+            if (parentDir === '.') {
+                break;
+            }
+            cleanedDir = parentDir;
         }
-        cleanedDir = parentDir;
+        cleanedDirs.push(normalizePath(cleanedDir));
     }
 
-    const normalizedCleanDir = normalizePath(cleanedDir);
-
     const allReferencesSet = new Set(allReferences);
 
-    // update package.json
-    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
-    );
+    // update package.json - replace each distDir prefix in references
+    const stringsToReplace = distDirs.map(d => `${d}/`);
+    const pkgClone = cloneAndUpdate(pkg, value => {
+        if (!allReferencesSet.has(value)) {
+            return value;
+        }
+        for (const stringToReplace of stringsToReplace) {
+            if (value.includes(stringToReplace)) {
+                return value.replace(stringToReplace, '');
+            }
+        }
+        return value;
+    });
     Object.assign(pkg, pkgClone);
 
     // update files
     let files = pkg.files;
     if (files) {
-        files = files.filter((file) => {
+        files = files.filter(file => {
             const fileNormalized = normalizePath(file);
-            return (
-                !isSubDirectory(cleanedDir, fileNormalized) &&
-                fileNormalized !== normalizedCleanDir
-            );
+            return !cleanedDirs.some(cleanedDir => isSubDirectory(cleanedDir, fileNormalized) || fileNormalized === cleanedDir);
         });
         files.push(...newFiles);
         pkg.files = [...files];
@@ -410,16 +453,13 @@ function cloneAndUpdate(pkg, updater) {
         return updater(pkg);
     }
     if (Array.isArray(pkg)) {
-        return pkg.map((value) => cloneAndUpdate(value, 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(/** @type {Record<string, unknown>} */ (pkg)[key], updater);
         }
         return clone;
     }
@@ -441,7 +481,7 @@ function isSubDirectory(parent, child) {
  */
 async function isEmptyDir(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
-    return entries.filter((entry) => !entry.isDirectory()).length === 0;
+    return entries.filter(entry => !entry.isDirectory()).length === 0;
 }
 
 /**
@@ -459,26 +499,30 @@ async function isDirectory(file) {
  * @returns {Promise<Array<string>>}
  */
 async function walkDir(dir, ignoreDirs = []) {
-    const entries = await readdir(dir, {
-        recursive: true,
-        withFileTypes: true,
-    });
+    const entries = await readdir(dir, { withFileTypes: true });
+    /**
+     * @type {string[]}
+     */
     const files = [];
 
+    // Process files first
     for (const entry of entries) {
-        if (entry.isFile()) {
-            const childPath = entry.parentPath
-                ? path.join(entry.parentPath, entry.name)
-                : entry.name;
-
-            // Check if any part of the path contains ignored directories
-            const pathParts = path.relative(dir, childPath).split(path.sep);
-            const shouldIgnore = pathParts.some((part) =>
-                ignoreDirs.includes(part)
-            );
+        if (!entry.isDirectory()) {
+            const childPath = path.join(entry.parentPath, entry.name);
+            files.push(childPath);
+        }
+    }
 
-            if (!shouldIgnore) {
-                files.push(childPath);
+    // Then process directories
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const childPath = path.join(entry.parentPath, entry.name);
+            const relativePath = path.relative(dir, childPath);
+            const topLevelDir = relativePath.split(path.sep)[0];
+
+            if (!ignoreDirs.includes(topLevelDir)) {
+                const childFiles = await walkDir(childPath);
+                files.push(...childFiles);
             }
         }
     }
@@ -493,12 +537,7 @@ async function isExists(file) {
     try {
         await access(file);
     } catch (e) {
-        if (
-            typeof e === 'object' &&
-            e != null &&
-            'code' in e &&
-            e.code === 'ENOENT'
-        ) {
+        if (typeof e === 'object' && e != null && 'code' in e && e.code === 'ENOENT') {
             return false;
         }
         throw e;
@@ -506,16 +545,171 @@ 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') {
+        files.push(normalizePath(pkg.main));
+    }
+    if (pkg.bin) {
+        if (typeof pkg.bin === 'string') {
+            files.push(normalizePath(pkg.bin));
+        }
+        if (typeof pkg.bin === 'object' && pkg.bin !== null) {
+            files.push(...Object.values(pkg.bin).map(normalizePath));
+        }
+    }
+    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;
+    }
+    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) {
+        if (hardIgnored.has(entry.name)) {
+            continue;
+        }
+        const fullPath = path.join(dir, entry.name);
+        if (isAlwaysIgnored(entry.name)) {
+            await rm(fullPath, { recursive: true, force: true });
+        } else if (entry.isDirectory()) {
+            await removeJunkFiles(fullPath);
+        }
+    }
+}
+
+/**
+ * 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 !== '.') {
+        return false;
+    }
+    const basenameWithoutExtension = path.basename(file, path.extname(file)).toUpperCase();
+    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 entries = await readdir('.');
+
+    for (const entry of entries) {
+        if (hardIgnored.has(entry)) {
+            continue;
+        }
+
+        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);
+
+    for (const entry of entries) {
+        if (hardIgnored.has(entry)) {
+            continue;
+        }
+
+        const fullPath = path.join(dir, entry);
+
+        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 });
+    }
+}
+
 function getScriptsData() {
-    const libraryScripts = new Set([
-        'preinstall',
-        'install',
-        'postinstall',
-        'prepublish',
-        'preprepare',
-        'prepare',
-        'postprepare',
-    ]);
+    const libraryScripts = new Set(['preinstall', 'install', 'postinstall', 'prepublish', 'preprepare', 'prepare', 'postprepare']);
 
     const appScripts = new Set([
         ...libraryScripts,