npmdata 0.10.3 → 0.12.0

package/dist/consumer.js

@@ -1,820 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compressGitignoreEntries = compressGitignoreEntries;
-exports.findNearestMarkerPath = findNearestMarkerPath;
-exports.extract = extract;
-exports.check = check;
-exports.purge = purge;
-exports.list = list;
-/* eslint-disable functional/no-try-statements */
-/* eslint-disable functional/no-let */
-/* eslint-disable no-continue */
-/* eslint-disable functional/immutable-data */
-/* eslint-disable no-restricted-syntax */
-/* eslint-disable max-depth */
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-const semver_1 = require("semver");
-const ignore_1 = __importDefault(require("ignore"));
-const types_1 = require("./types");
-const utils_1 = require("./utils");
-const MARKER_FILE = '.npmdata';
-const GITIGNORE_FILE = '.gitignore';
-const GITIGNORE_START = '# npmdata:start';
-const GITIGNORE_END = '# npmdata:end';
-/**
- * Read the .gitignore at dir and return parsed patterns, excluding the npmdata-managed
- * section.  These are the "external" patterns (e.g. node_modules, dist) that were written
- * by the project author rather than by npmdata itself.
- */
-function readExternalGitignore(dir) {
-    const ig = (0, ignore_1.default)();
-    const gitignorePath = node_path_1.default.join(dir, GITIGNORE_FILE);
-    if (!node_fs_1.default.existsSync(gitignorePath))
-        return ig;
-    let content = node_fs_1.default.readFileSync(gitignorePath, 'utf8');
-    // Strip out the npmdata-managed block so we only act on external entries.
-    const startIdx = content.indexOf(GITIGNORE_START);
-    const endIdx = content.indexOf(GITIGNORE_END);
-    if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
-        content = content.slice(0, startIdx) + content.slice(endIdx + GITIGNORE_END.length);
-    }
-    ig.add(content);
-    return ig;
-}
-/**
- * Update (or create) a .gitignore in the given directory so that the managed
- * files and the .npmdata marker file are ignored by git.
- * If managedFilenames is empty the npmdata section is removed; if the
- * resulting file is empty it is deleted.
- * When addEntries is false, only existing sections are updated/removed — no new
- * section is written if one did not already exist.
- */
-function updateGitignoreForDir(dir, managedFilenames, addEntries = true) {
-    const gitignorePath = node_path_1.default.join(dir, GITIGNORE_FILE);
-    let existingContent = '';
-    if (node_fs_1.default.existsSync(gitignorePath)) {
-        existingContent = node_fs_1.default.readFileSync(gitignorePath, 'utf8');
-    }
-    const startIdx = existingContent.indexOf(GITIGNORE_START);
-    const endIdx = existingContent.indexOf(GITIGNORE_END);
-    const hasExistingSection = startIdx !== -1 && endIdx !== -1 && startIdx < endIdx;
-    // When not adding entries and there is no existing section, there is nothing to clean up.
-    if (!addEntries && !hasExistingSection)
-        return;
-    let beforeSection = existingContent;
-    let afterSection = '';
-    if (hasExistingSection) {
-        beforeSection = existingContent.slice(0, startIdx).trimEnd();
-        afterSection = existingContent.slice(endIdx + GITIGNORE_END.length).trimStart();
-    }
-    if (managedFilenames.length === 0) {
-        // Remove the managed section entirely.
-        const updatedContent = [beforeSection, afterSection].filter(Boolean).join('\n');
-        if (updatedContent.trim()) {
-            node_fs_1.default.writeFileSync(gitignorePath, `${updatedContent.trimEnd()}\n`, 'utf8');
-        }
-        else if (node_fs_1.default.existsSync(gitignorePath)) {
-            node_fs_1.default.unlinkSync(gitignorePath);
-        }
-        return;
-    }
-    // When addEntries is false, only update an existing section (stale entries removed);
-    // if there is no existing section do not create one (already returned above).
-    const section = [GITIGNORE_START, MARKER_FILE, ...managedFilenames.sort(), GITIGNORE_END].join('\n');
-    const parts = [beforeSection, section, afterSection].filter(Boolean);
-    const updatedContent = `${parts.join('\n')}\n`;
-    node_fs_1.default.writeFileSync(gitignorePath, updatedContent, 'utf8');
-}
-/**
- * Optimise the list of managed file paths for use in .gitignore.
- * When every file inside a directory (recursively, excluding MARKER_FILE, GITIGNORE_FILE, and
- * symlinks) is present in managedPaths, the whole directory is represented as "dir/" rather than
- * listing each file individually.  Root-level files (no slash) are always emitted as-is.
- *
- * @param managedPaths - Paths relative to outputDir (e.g. ["docs/guide.md", "README.md"])
- * @param outputDir    - Absolute path to the root used to inspect actual disk contents
- */
-function compressGitignoreEntries(managedPaths, outputDir) {
-    const managedSet = new Set(managedPaths);
-    const gitignore = readExternalGitignore(outputDir);
-    // Returns true when every non-special, non-symlink file inside absDir (recursively)
-    // appears in managedSet under its full outputDir-relative path (relDir prefix included).
-    const isDirFullyManaged = (absDir, relDir) => {
-        if (!node_fs_1.default.existsSync(absDir))
-            return false;
-        for (const entry of node_fs_1.default.readdirSync(absDir)) {
-            if (entry === MARKER_FILE || entry === GITIGNORE_FILE)
-                continue;
-            const absEntry = node_path_1.default.join(absDir, entry);
-            const relEntry = `${relDir}/${entry}`;
-            const lstat = node_fs_1.default.lstatSync(absEntry);
-            if (lstat.isSymbolicLink())
-                continue;
-            if (lstat.isDirectory()) {
-                // Skip gitignored subdirs that have no managed files — they are not our concern
-                // and traversing them (e.g. node_modules) causes serious performance problems.
-                if (gitignore.ignores(entry) && !(0, utils_1.hasManagedFilesUnder)(relEntry, managedSet)) {
-                    continue;
-                }
-                if (!isDirFullyManaged(absEntry, relEntry))
-                    return false;
-            }
-            else if (!managedSet.has(relEntry))
-                return false;
-        }
-        return true;
-    };
-    // paths: managed paths relative to the current directory scope
-    // absRoot: absolute path of the current directory scope
-    // relRoot: path of the current scope relative to outputDir (empty string at top level)
-    const compress = (paths, absRoot, relRoot) => {
-        const result = [];
-        const subdirNames = new Set();
-        for (const p of paths) {
-            const slashIdx = p.indexOf('/');
-            if (slashIdx === -1) {
-                // File lives directly in this scope — emit its full outputDir-relative path
-                result.push(relRoot ? `${relRoot}/${p}` : p);
-            }
-            else {
-                subdirNames.add(p.slice(0, slashIdx));
-            }
-        }
-        for (const dirName of subdirNames) {
-            const absDir = node_path_1.default.join(absRoot, dirName);
-            const relDir = relRoot ? `${relRoot}/${dirName}` : dirName;
-            const prefix = `${dirName}/`;
-            const subPaths = paths.filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length));
-            if (isDirFullyManaged(absDir, relDir)) {
-                result.push(`${relDir}/`);
-            }
-            else {
-                result.push(...compress(subPaths, absDir, relDir));
-            }
-        }
-        return result;
-    };
-    return compress(managedPaths, outputDir, '');
-}
-/**
- * Find the nearest .npmdata marker file by walking up from fromDir to outputDir (inclusive).
- * Returns the path to the marker file, or null if none found within the outputDir boundary.
- */
-function findNearestMarkerPath(fromDir, outputDir) {
-    let dir = fromDir;
-    const resolvedOutput = node_path_1.default.resolve(outputDir);
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const markerPath = node_path_1.default.join(dir, MARKER_FILE);
-        if (node_fs_1.default.existsSync(markerPath))
-            return markerPath;
-        if (node_path_1.default.resolve(dir) === resolvedOutput)
-            break;
-        const parent = node_path_1.default.dirname(dir);
-        if (parent === dir)
-            break; // reached filesystem root
-        dir = parent;
-    }
-    // eslint-disable-next-line unicorn/no-null
-    return null;
-}
-/**
- * Write one .gitignore at outputDir containing all managed file paths (relative to outputDir),
- * and remove any npmdata sections from .gitignore files in subdirectories.
- * When addEntries is false, existing sections are updated/removed but no new
- * sections are created — use this to clean up without opting into gitignore management.
- */
-function updateGitignores(outputDir, addEntries = true) {
-    if (!node_fs_1.default.existsSync(outputDir))
-        return;
-    // Read managed paths up-front so we can skip gitignored dirs that have no managed files.
-    const managedPaths = new Set();
-    const rootMarkerPathForRead = node_path_1.default.join(outputDir, MARKER_FILE);
-    if (node_fs_1.default.existsSync(rootMarkerPathForRead)) {
-        // eslint-disable-next-line functional/no-try-statements
-        try {
-            for (const m of (0, utils_1.readCsvMarker)(rootMarkerPathForRead)) {
-                managedPaths.add(m.path);
-            }
-        }
-        catch {
-            // ignore unreadable marker
-        }
-    }
-    // Read external gitignore patterns once for the whole walk.
-    const gitignore = readExternalGitignore(outputDir);
-    // Remove npmdata sections from all subdirectory .gitignore files (migration / cleanup of old format)
-    const cleanupSubDirGitignores = (dir) => {
-        for (const item of node_fs_1.default.readdirSync(dir)) {
-            const fullPath = node_path_1.default.join(dir, item);
-            const lstat = node_fs_1.default.lstatSync(fullPath);
-            if (!lstat.isSymbolicLink() && lstat.isDirectory()) {
-                const relPath = node_path_1.default.relative(outputDir, fullPath);
-                // Skip gitignored directories that have no managed files under them —
-                // traversing them (e.g. node_modules) causes serious performance problems.
-                if (gitignore.ignores(item) && !(0, utils_1.hasManagedFilesUnder)(relPath, managedPaths)) {
-                    continue;
-                }
-                const subGitignore = node_path_1.default.join(fullPath, GITIGNORE_FILE);
-                if (node_fs_1.default.existsSync(subGitignore)) {
-                    updateGitignoreForDir(fullPath, [], false);
-                }
-                cleanupSubDirGitignores(fullPath);
-            }
-        }
-    };
-    cleanupSubDirGitignores(outputDir);
-    // Update (or remove) the single .gitignore at outputDir
-    const rootMarkerPath = node_path_1.default.join(outputDir, MARKER_FILE);
-    if (node_fs_1.default.existsSync(rootMarkerPath)) {
-        try {
-            const managedFiles = (0, utils_1.readCsvMarker)(rootMarkerPath);
-            const rawPaths = managedFiles.map((m) => m.path);
-            const optimisedPaths = compressGitignoreEntries(rawPaths, outputDir);
-            updateGitignoreForDir(outputDir, optimisedPaths, addEntries);
-        }
-        catch {
-            // Ignore unreadable marker files
-        }
-    }
-    else {
-        // Clean up any leftover npmdata section at root
-        updateGitignoreForDir(outputDir, [], false);
-    }
-}
-async function getPackageFiles(packageName, cwd) {
-    const pkgPath = require.resolve(`${packageName}/package.json`, {
-        // eslint-disable-next-line no-undefined
-        paths: cwd ? [cwd] : undefined,
-    });
-    const packagePath = node_path_1.default.dirname(pkgPath);
-    if (!packagePath) {
-        throw new Error(`Cannot locate installed package: ${packageName}`);
-    }
-    const contents = [];
-    const walkDir = (dir, basePath = '') => {
-        for (const file of node_fs_1.default.readdirSync(dir)) {
-            if (file === MARKER_FILE)
-                continue;
-            const fullPath = node_path_1.default.join(dir, file);
-            const relPath = basePath ? `${basePath}/${file}` : file;
-            const lstat = node_fs_1.default.lstatSync(fullPath);
-            if (!lstat.isSymbolicLink() && lstat.isDirectory()) {
-                walkDir(fullPath, relPath);
-            }
-            else if (!lstat.isSymbolicLink()) {
-                contents.push({ relPath, fullPath });
-            }
-        }
-    };
-    walkDir(packagePath);
-    return contents;
-}
-async function installPackage(packageName, version, packageManager, cwd) {
-    const packageSpec = version ? `${packageName}@${version}` : `${packageName}@latest`;
-    let cmd;
-    switch (packageManager) {
-        case 'pnpm':
-            cmd = `pnpm add ${packageSpec}`;
-            break;
-        case 'yarn':
-            cmd = `yarn add ${packageSpec}`;
-            break;
-        default:
-            cmd = `npm install ${packageSpec}`;
-    }
-    // eslint-disable-next-line functional/no-try-statements
-    try {
-        (0, node_child_process_1.execSync)(cmd, { encoding: 'utf8', stdio: 'pipe', cwd });
-    }
-    catch (error) {
-        const e = error;
-        const detail = (e.stderr ?? e.stdout ?? e.message ?? String(error)).trim();
-        throw new Error(`Failed to install ${packageSpec}: ${detail}`);
-    }
-}
-async function ensurePackageInstalled(packageName, version, packageManager, cwd, upgrade) {
-    const existingVersion = (0, utils_1.getInstalledPackageVersion)(packageName, cwd);
-    if (!existingVersion) {
-        const spec = version ? `${packageName}@${version}` : packageName;
-        // eslint-disable-next-line no-console
-        console.log(`Installing missing package ${spec}...`);
-        await installPackage(packageName, version, packageManager, cwd);
-    }
-    else if (upgrade) {
-        const spec = version ? `${packageName}@${version}` : packageName;
-        // eslint-disable-next-line no-console
-        console.log(`Bumping existing package ${spec}...`);
-        await installPackage(packageName, version, packageManager, cwd);
-    }
-    const installedVersion = (0, utils_1.getInstalledPackageVersion)(packageName, cwd);
-    if (!installedVersion) {
-        throw new Error(`Couldn't find package ${packageName}`);
-    }
-    if (version && !(0, semver_1.satisfies)(installedVersion, version)) {
-        throw new Error(`Installed version ${installedVersion} of package '${packageName}' does not match constraint ${version}`);
-    }
-    return installedVersion;
-}
-/**
- * Load all managed files from the root marker file at outputDir.
- * Paths stored in the marker are already relative to outputDir.
- * Uses findNearestMarkerPath starting from outputDir itself.
- */
-function loadAllManagedFiles(outputDir) {
-    if (!node_fs_1.default.existsSync(outputDir))
-        return [];
-    const markerPath = findNearestMarkerPath(outputDir, outputDir);
-    if (!markerPath)
-        return [];
-    try {
-        return (0, utils_1.readCsvMarker)(markerPath);
-    }
-    catch {
-        console.warn(`Warning: Failed to read marker file at ${markerPath}. Skipping.`); // eslint-disable-line no-console
-        return [];
-    }
-}
-/**
- * Load managed files from all marker files under outputDir, keyed by relative path.
- * Each value carries the package ownership metadata.
- */
-function loadManagedFilesMap(outputDir) {
-    return new Map(loadAllManagedFiles(outputDir).map((m) => [m.path, m]));
-}
-function cleanupEmptyMarkers(outputDir) {
-    if (!node_fs_1.default.existsSync(outputDir))
-        return;
-    const markerPath = node_path_1.default.join(outputDir, MARKER_FILE);
-    if (!node_fs_1.default.existsSync(markerPath))
-        return;
-    try {
-        const managedFiles = (0, utils_1.readCsvMarker)(markerPath);
-        if (managedFiles.length === 0) {
-            node_fs_1.default.chmodSync(markerPath, 0o644);
-            node_fs_1.default.unlinkSync(markerPath);
-        }
-    }
-    catch {
-        // Ignore unreadable marker files
-    }
-}
-function cleanupEmptyDirs(outputDir) {
-    const gitignore = readExternalGitignore(outputDir);
-    const managedPaths = new Set(loadAllManagedFiles(outputDir).map((m) => m.path));
-    const walkDir = (dir) => {
-        if (!node_fs_1.default.existsSync(dir))
-            return true;
-        let isEmpty = true;
-        for (const item of node_fs_1.default.readdirSync(dir)) {
-            const fullPath = node_path_1.default.join(dir, item);
-            const lstat = node_fs_1.default.lstatSync(fullPath);
-            if (!lstat.isSymbolicLink() && lstat.isDirectory()) {
-                const relPath = node_path_1.default.relative(outputDir, fullPath);
-                // Skip gitignored directories that have no managed files — they are not our concern
-                // and traversing them (e.g. node_modules) causes serious performance problems.
-                if (gitignore.ignores(item) && !(0, utils_1.hasManagedFilesUnder)(relPath, managedPaths)) {
-                    isEmpty = false; // treat as non-empty so we preserve the parent directory
-                    continue;
-                }
-                const childEmpty = walkDir(fullPath);
-                if (!childEmpty)
-                    isEmpty = false;
-            }
-            else {
-                isEmpty = false;
-            }
-        }
-        if (isEmpty && dir !== outputDir) {
-            node_fs_1.default.rmdirSync(dir);
-            return true;
-        }
-        return isEmpty;
-    };
-    walkDir(outputDir);
-}
-// eslint-disable-next-line complexity
-async function extractFiles(config, packageName) {
-    const changes = {
-        added: [],
-        modified: [],
-        deleted: [],
-        skipped: [],
-    };
-    const dryRun = config.dryRun ?? false;
-    const emit = config.onProgress;
-    const installedVersion = (0, utils_1.getInstalledPackageVersion)(packageName, config.cwd);
-    if (!installedVersion) {
-        throw new Error(`Failed to determine installed version of package ${packageName}`);
-    }
-    emit?.({ type: 'package-start', packageName, packageVersion: installedVersion });
-    const packageFiles = await getPackageFiles(packageName, config.cwd);
-    const extractedFiles = [];
-    const existingManagedMap = loadManagedFilesMap(config.outputDir);
-    // Tracks full relPaths force-claimed from a different package so the
-    // marker-file merge can evict the previous owner's entry.
-    const forceClaimedPaths = new Set();
-    // eslint-disable-next-line functional/no-let
-    let wasForced = false;
-    try {
-        for (const packageFile of packageFiles) {
-            if (!(0, utils_1.matchesFilenamePattern)(packageFile.relPath, config.filenamePatterns ?? types_1.DEFAULT_FILENAME_PATTERNS) ||
-                !(0, utils_1.matchesContentRegex)(packageFile.fullPath, config.contentRegexes)) {
-                continue;
-            }
-            const destPath = node_path_1.default.join(config.outputDir, packageFile.relPath);
-            if (!dryRun)
-                (0, utils_1.ensureDir)(node_path_1.default.dirname(destPath));
-            const existingOwner = existingManagedMap.get(packageFile.relPath);
-            // In unmanaged mode, skip files that already exist on disk.
-            if (config.unmanaged && node_fs_1.default.existsSync(destPath)) {
-                changes.skipped.push(packageFile.relPath);
-                emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
-                continue;
-            }
-            // In keep-existing mode, skip files that already exist on disk but create missing ones normally.
-            if (config.keepExisting && node_fs_1.default.existsSync(destPath)) {
-                changes.skipped.push(packageFile.relPath);
-                emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
-                continue;
-            }
-            if (node_fs_1.default.existsSync(destPath)) {
-                if (existingOwner?.packageName === packageName) {
-                    if ((0, utils_1.calculateFileHash)(packageFile.fullPath) === (0, utils_1.calculateFileHash)(destPath)) {
-                        changes.skipped.push(packageFile.relPath);
-                        emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
-                    }
-                    else {
-                        if (!dryRun)
-                            (0, utils_1.copyFile)(packageFile.fullPath, destPath);
-                        changes.modified.push(packageFile.relPath);
-                        emit?.({ type: 'file-modified', packageName, file: packageFile.relPath });
-                    }
-                    wasForced = false;
-                }
-                else {
-                    // File exists but is owned by a different package (clash) or is unmanaged (conflict).
-                    // Behaviour is identical in both cases: throw when force is false, overwrite when true.
-                    if (!config.force) {
-                        if (existingOwner) {
-                            throw new Error(`Package clash: ${packageFile.relPath} already managed by ${existingOwner.packageName}@${existingOwner.packageVersion}. Cannot extract from ${packageName}. Use force: true to override.`);
-                        }
-                        throw new Error(`File conflict: ${packageFile.relPath} already exists and is not managed by npmdata. Use force: true to override.`);
-                    }
-                    // force=true: overwrite the existing file and take ownership.
-                    if (!dryRun)
-                        (0, utils_1.copyFile)(packageFile.fullPath, destPath);
-                    changes.modified.push(packageFile.relPath);
-                    emit?.({ type: 'file-modified', packageName, file: packageFile.relPath });
-                    wasForced = true;
-                    if (existingOwner) {
-                        // Evict the previous owner's entry from the root marker file.
-                        forceClaimedPaths.add(packageFile.relPath);
-                    }
-                }
-            }
-            else {
-                if (!dryRun)
-                    (0, utils_1.copyFile)(packageFile.fullPath, destPath);
-                changes.added.push(packageFile.relPath);
-                emit?.({ type: 'file-added', packageName, file: packageFile.relPath });
-                wasForced = false;
-            }
-            if (!dryRun && !config.unmanaged && node_fs_1.default.existsSync(destPath))
-                node_fs_1.default.chmodSync(destPath, 0o444);
-            if (!config.unmanaged) {
-                // eslint-disable-next-line functional/immutable-data
-                extractedFiles.push({
-                    path: packageFile.relPath,
-                    packageName,
-                    packageVersion: installedVersion,
-                    force: wasForced,
-                });
-            }
-        }
-        // Delete files that were managed by this package but are no longer in the package.
-        // Skip this step in unmanaged mode — only extraction is wanted, no sync/deletion.
-        if (!config.unmanaged) {
-            for (const [relPath, owner] of existingManagedMap) {
-                if (owner.packageName !== packageName)
-                    continue;
-                const stillPresent = extractedFiles.some((m) => m.path === relPath);
-                if (!stillPresent) {
-                    const fullPath = node_path_1.default.join(config.outputDir, relPath);
-                    if (node_fs_1.default.existsSync(fullPath)) {
-                        if (!dryRun)
-                            (0, utils_1.removeFile)(fullPath);
-                        changes.deleted.push(relPath);
-                        emit?.({ type: 'file-deleted', packageName, file: relPath });
-                    }
-                }
-            }
-        }
-        if (!dryRun && !config.unmanaged) {
-            // Write a single root marker at outputDir with all managed file paths (relative to outputDir)
-            const rootMarkerPath = node_path_1.default.join(config.outputDir, MARKER_FILE);
-            let existingFiles = [];
-            if (node_fs_1.default.existsSync(rootMarkerPath)) {
-                existingFiles = (0, utils_1.readCsvMarker)(rootMarkerPath);
-            }
-            // Keep entries from other packages, evict entries from force-claimed paths.
-            const mergedFiles = [
-                ...existingFiles.filter((m) => m.packageName !== packageName && !forceClaimedPaths.has(m.path)),
-                ...extractedFiles,
-            ];
-            if (mergedFiles.length === 0) {
-                if (node_fs_1.default.existsSync(rootMarkerPath)) {
-                    node_fs_1.default.chmodSync(rootMarkerPath, 0o644);
-                    node_fs_1.default.unlinkSync(rootMarkerPath);
-                }
-            }
-            else {
-                (0, utils_1.writeCsvMarker)(rootMarkerPath, mergedFiles);
-            }
-            cleanupEmptyMarkers(config.outputDir);
-        }
-    }
-    catch (error) {
-        // On error, delete all files that were created during this extraction run
-        if (!dryRun) {
-            for (const relPath of changes.added) {
-                const fullPath = node_path_1.default.join(config.outputDir, relPath);
-                if (node_fs_1.default.existsSync(fullPath)) {
-                    try {
-                        (0, utils_1.removeFile)(fullPath);
-                    }
-                    catch {
-                        // ignore cleanup errors
-                    }
-                }
-            }
-            cleanupEmptyDirs(config.outputDir);
-        }
-        throw error;
-    }
-    emit?.({ type: 'package-end', packageName, packageVersion: installedVersion });
-    return changes;
-}
-/**
- * Extract files from published packages to output directory.
- *
- * Phase 1 validates and installs every package before touching disk.
- * Phase 2 runs file extraction for all packages in parallel.
- * When dryRun is true no files are written; the result reflects what would change.
- */
-async function extract(config) {
-    const dryRun = config.dryRun ?? false;
-    if (!dryRun)
-        (0, utils_1.ensureDir)(config.outputDir);
-    if (config.force && config.keepExisting) {
-        throw new Error('force and keepExisting cannot be used together');
-    }
-    const packageManager = config.packageManager ?? (0, utils_1.detectPackageManager)(config.cwd);
-    const sourcePackages = [];
-    const totalChanges = {
-        added: [],
-        modified: [],
-        deleted: [],
-        skipped: [],
-    };
-    // Phase 1: validate and install every package before touching the disk.
-    // If any package is missing or at a wrong version, we abort before writing anything.
-    const resolvedPackages = [];
-    for (const spec of config.packages) {
-        const { name, version } = (0, utils_1.parsePackageSpec)(spec);
-        // eslint-disable-next-line no-await-in-loop
-        const installedVersion = await ensurePackageInstalled(name, version, packageManager, config.cwd, config.upgrade);
-        resolvedPackages.push({ name, version, installedVersion });
-    }
-    // Phase 2: all packages are verified — extract files serially so progress events are grouped by package.
-    for (const { name, installedVersion } of resolvedPackages) {
-        // eslint-disable-next-line no-await-in-loop
-        const changes = await extractFiles(config, name);
-        totalChanges.added.push(...changes.added);
-        totalChanges.modified.push(...changes.modified);
-        totalChanges.deleted.push(...changes.deleted);
-        totalChanges.skipped.push(...changes.skipped);
-        sourcePackages.push({ name, version: installedVersion, changes });
-    }
-    if (!dryRun) {
-        if (!config.unmanaged) {
-            cleanupEmptyMarkers(config.outputDir);
-            // Always clean up .gitignore entries for removed files; only add new entries when gitignore: true.
-            updateGitignores(config.outputDir, config.gitignore ?? true);
-        }
-        // Run after gitignore cleanup so dirs kept alive only by a .gitignore get removed.
-        cleanupEmptyDirs(config.outputDir);
-    }
-    return {
-        ...totalChanges,
-        sourcePackages,
-    };
-}
-/**
- * Compute the expected hash of a package source file as it should appear in the
- * output directory after all content replacements have been applied.
- *
- * When no replacement config is provided (or none matches the file), the hash is
- * computed directly from the on-disk source content.  When one or more replacements
- * match, the source content is transformed in memory and the resulting hash is
- * returned – this makes check() tolerant of post-extract content replacements.
- */
-// eslint-disable-next-line complexity
-function computeExpectedHash(sourceFullPath, relPath, outputDir, cwd, replacements) {
-    if (!replacements || replacements.length === 0) {
-        return (0, utils_1.calculateFileHash)(sourceFullPath);
-    }
-    // The workspace path of the extracted file, relative to cwd, is used to
-    // evaluate the replacement's `files` glob (which is also relative to cwd).
-    const workspaceRelPath = node_path_1.default.relative(cwd, node_path_1.default.join(outputDir, relPath));
-    const applicable = replacements.filter((r) => (0, utils_1.matchesFilenamePattern)(workspaceRelPath, [r.files]));
-    if (applicable.length === 0) {
-        return (0, utils_1.calculateFileHash)(sourceFullPath);
-    }
-    // eslint-disable-next-line functional/no-let
-    let content = node_fs_1.default.readFileSync(sourceFullPath, 'utf8');
-    for (const r of applicable) {
-        content = content.replaceAll(new RegExp(r.match, 'gm'), r.replace);
-    }
-    return (0, utils_1.calculateBufferHash)(content);
-}
-/**
- * Check if managed files are in sync with published packages.
- *
- * Performs a bidirectional comparison:
- * - Files in the .npmdata marker that are missing from or modified in the output directory.
- * - Files present in the package (matching filters) that have not been extracted yet ("extra").
- *
- * If a version constraint is specified (e.g. "my-pkg@^1.0.0"), the installed version is
- * validated against it so stale installs are caught.
- */
-async function check(config) {
-    const sourcePackages = [];
-    const totalDifferences = {
-        missing: [],
-        modified: [],
-        extra: [],
-    };
-    for (const spec of config.packages) {
-        const { name, version: constraint } = (0, utils_1.parsePackageSpec)(spec);
-        const installedVersion = (0, utils_1.getInstalledPackageVersion)(name, config.cwd);
-        if (!installedVersion) {
-            throw new Error(`Package ${name} is not installed. Run 'extract' first.`);
-        }
-        if (constraint && !(0, semver_1.satisfies)(installedVersion, constraint)) {
-            throw new Error(`Installed version ${installedVersion} of package '${name}' does not satisfy constraint ${constraint}. Run 'extract' to update.`);
-        }
-        // Load marker entries for this package and apply the --files filter
-        const markerFiles = loadAllManagedFiles(config.outputDir)
-            .filter((m) => m.packageName === name)
-            .filter((m) => (0, utils_1.matchesFilenamePattern)(m.path, config.filenamePatterns ?? types_1.DEFAULT_FILENAME_PATTERNS));
-        const markerPaths = new Set(markerFiles.map((m) => m.path));
-        // Build a hash map of the installed package files (filtered the same way).
-        // When content replacements are configured, the expected hash for each affected file
-        // is computed from the source content AFTER applying the replacements, so that files
-        // modified in-place by a post-extract replacement are not reported as out of sync.
-        // eslint-disable-next-line no-await-in-loop
-        const packageFiles = await getPackageFiles(name, config.cwd);
-        const filteredPackageFiles = packageFiles.filter((f) => (0, utils_1.matchesFilenamePattern)(f.relPath, config.filenamePatterns ?? types_1.DEFAULT_FILENAME_PATTERNS) &&
-            (0, utils_1.matchesContentRegex)(f.fullPath, config.contentRegexes));
-        const effectiveCwd = config.cwd ?? process.cwd();
-        const packageHashMap = new Map(filteredPackageFiles.map((f) => [
-            f.relPath,
-            computeExpectedHash(f.fullPath, f.relPath, config.outputDir, effectiveCwd, config.contentReplacements),
-        ]));
-        const pkgDiff = {
-            missing: [],
-            modified: [],
-            extra: [],
-        };
-        // Check marker entries against local files and package contents
-        for (const markerFile of markerFiles) {
-            const localPath = node_path_1.default.join(config.outputDir, markerFile.path);
-            if (!node_fs_1.default.existsSync(localPath)) {
-                pkgDiff.missing.push(markerFile.path);
-                continue;
-            }
-            const packageHash = packageHashMap.get(markerFile.path);
-            // eslint-disable-next-line no-undefined
-            if (packageHash !== undefined && (0, utils_1.calculateFileHash)(localPath) !== packageHash) {
-                pkgDiff.modified.push(markerFile.path);
-            }
-        }
-        // Detect package files that were never extracted (not in the marker)
-        for (const [relPath] of packageHashMap) {
-            if (!markerPaths.has(relPath)) {
-                pkgDiff.extra.push(relPath);
-            }
-        }
-        const pkgOk = pkgDiff.missing.length === 0 && pkgDiff.modified.length === 0 && pkgDiff.extra.length === 0;
-        sourcePackages.push({ name, version: installedVersion, ok: pkgOk, differences: pkgDiff });
-        totalDifferences.missing.push(...pkgDiff.missing);
-        totalDifferences.modified.push(...pkgDiff.modified);
-        totalDifferences.extra.push(...pkgDiff.extra);
-    }
-    return {
-        ok: totalDifferences.missing.length === 0 &&
-            totalDifferences.modified.length === 0 &&
-            totalDifferences.extra.length === 0,
-        differences: totalDifferences,
-        sourcePackages,
-    };
-}
-/**
- * Remove all managed files previously extracted by the given packages from outputDir.
- * Reads .npmdata marker files to discover which files are owned by each package,
- * deletes them from disk, updates the marker files, and cleans up empty directories.
- * No package installation is required – only the local marker state is used.
- */
-async function purge(config) {
-    const dryRun = config.dryRun ?? false;
-    const emit = config.onProgress;
-    const totalChanges = {
-        added: [],
-        modified: [],
-        deleted: [],
-        skipped: [],
-    };
-    const sourcePackages = [];
-    for (const spec of config.packages) {
-        const { name: packageName } = (0, utils_1.parsePackageSpec)(spec);
-        const deleted = [];
-        emit?.({ type: 'package-start', packageName, packageVersion: 'unknown' });
-        const allManaged = loadManagedFilesMap(config.outputDir);
-        for (const [relPath, owner] of allManaged) {
-            if (owner.packageName !== packageName)
-                continue;
-            const fullPath = node_path_1.default.join(config.outputDir, relPath);
-            if (node_fs_1.default.existsSync(fullPath)) {
-                if (!dryRun)
-                    (0, utils_1.removeFile)(fullPath);
-                deleted.push(relPath);
-                emit?.({ type: 'file-deleted', packageName, file: relPath });
-            }
-        }
-        if (!dryRun) {
-            // Update root marker: remove entries owned by this package.
-            const rootMarkerPath = node_path_1.default.join(config.outputDir, MARKER_FILE);
-            if (node_fs_1.default.existsSync(rootMarkerPath)) {
-                // eslint-disable-next-line functional/no-try-statements
-                try {
-                    const existingFiles = (0, utils_1.readCsvMarker)(rootMarkerPath);
-                    const mergedFiles = existingFiles.filter((m) => m.packageName !== packageName);
-                    if (mergedFiles.length === 0) {
-                        node_fs_1.default.chmodSync(rootMarkerPath, 0o644);
-                        node_fs_1.default.unlinkSync(rootMarkerPath);
-                    }
-                    else {
-                        (0, utils_1.writeCsvMarker)(rootMarkerPath, mergedFiles);
-                    }
-                }
-                catch {
-                    // Ignore unreadable marker files
-                }
-            }
-            cleanupEmptyMarkers(config.outputDir);
-            // Clean up any leftover .gitignore sections without adding new ones.
-            updateGitignores(config.outputDir, false);
-            cleanupEmptyDirs(config.outputDir);
-        }
-        totalChanges.deleted.push(...deleted);
-        sourcePackages.push({
-            name: packageName,
-            version: 'unknown',
-            changes: { added: [], modified: [], deleted, skipped: [] },
-        });
-        emit?.({ type: 'package-end', packageName, packageVersion: 'unknown' });
-    }
-    return {
-        ...totalChanges,
-        sourcePackages,
-    };
-}
-/**
- * List all managed files currently extracted in outputDir, grouped by package.
- */
-function list(outputDir) {
-    const allManaged = loadAllManagedFiles(outputDir);
-    const grouped = new Map();
-    for (const managed of allManaged) {
-        const key = `${managed.packageName}@${managed.packageVersion}`;
-        if (!grouped.has(key)) {
-            grouped.set(key, {
-                packageName: managed.packageName,
-                packageVersion: managed.packageVersion,
-                files: [],
-            });
-        }
-        grouped.get(key).files.push(managed.path);
-    }
-    return [...grouped.values()].map((entry) => ({
-        ...entry,
-        files: entry.files.sort(),
-    }));
-}
-//# sourceMappingURL=consumer.js.map