@psync/patch-package 1.0.0

package/dist/detectPackageManager.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPackageManager = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("./path");
+const chalk_1 = __importDefault(require("chalk"));
+const process_1 = __importDefault(require("process"));
+const find_yarn_workspace_root_1 = __importDefault(require("find-yarn-workspace-root"));
+function printNoYarnLockfileError() {
+    console.log(`
+${chalk_1.default.red.bold("**ERROR**")} ${chalk_1.default.red(`The --use-yarn option was specified but there is no yarn.lock file`)}
+`);
+}
+function printNoBunLockfileError() {
+    console.log(`
+${chalk_1.default.red.bold("**ERROR**")} ${chalk_1.default.red(`The --use-bun option was specified but there is no bun.lockb file`)}
+`);
+}
+function printNoLockfilesError() {
+    console.log(`
+${chalk_1.default.red.bold("**ERROR**")} ${chalk_1.default.red(`No package-lock.json, npm-shrinkwrap.json, yarn.lock, or bun.lockb file.
+
+You must use either npm@>=5, yarn, npm-shrinkwrap, or bun to manage this project's
+dependencies.`)}
+`);
+}
+function printSelectingDefaultMessage() {
+    console.info(`${chalk_1.default.bold("patch-package")}: you have multiple lockfiles, e.g. yarn.lock and package-lock.json
+Defaulting to using ${chalk_1.default.bold("npm")}
+You can override this setting by passing --use-yarn, --use-bun, or
+deleting the conflicting lockfile if you don't need it
+`);
+}
+function printSelectingDefaultYarnMessage() {
+    console.info(`${chalk_1.default.bold("patch-package")}: you have both yarn.lock and bun.lockb lockfiles
+Defaulting to using ${chalk_1.default.bold("yarn")}
+You can override this setting by passing --use-bun, or
+deleting yarn.lock if you don't need it
+`);
+}
+function checkForYarnOverride(overridePackageManager) {
+    if (overridePackageManager === "yarn") {
+        printNoYarnLockfileError();
+        process_1.default.exit(1);
+    }
+}
+function checkForBunOverride(overridePackageManager) {
+    if (overridePackageManager === "bun") {
+        printNoBunLockfileError();
+        process_1.default.exit(1);
+    }
+}
+const detectPackageManager = (appRootPath, overridePackageManager) => {
+    const packageLockExists = fs_extra_1.default.existsSync((0, path_1.join)(appRootPath, "package-lock.json"));
+    const shrinkWrapExists = fs_extra_1.default.existsSync((0, path_1.join)(appRootPath, "npm-shrinkwrap.json"));
+    const yarnLockExists = fs_extra_1.default.existsSync((0, path_1.join)((0, find_yarn_workspace_root_1.default)() ?? appRootPath, "yarn.lock"));
+    // Bun workspaces seem to work the same as yarn workspaces - https://bun.sh/docs/install/workspaces
+    const bunLockbExists = fs_extra_1.default.existsSync((0, path_1.join)((0, find_yarn_workspace_root_1.default)() ?? appRootPath, "bun.lockb"));
+    if ([
+        packageLockExists || shrinkWrapExists,
+        yarnLockExists,
+        bunLockbExists,
+    ].filter(Boolean).length > 1) {
+        if (overridePackageManager) {
+            return overridePackageManager;
+        }
+        if (!packageLockExists && !shrinkWrapExists) {
+            // The only case where we don't want to default to npm is when we have both yarn and bun lockfiles.
+            printSelectingDefaultYarnMessage();
+            return "yarn";
+        }
+        printSelectingDefaultMessage();
+        return shrinkWrapExists ? "npm-shrinkwrap" : "npm";
+    }
+    else if (packageLockExists || shrinkWrapExists) {
+        checkForYarnOverride(overridePackageManager);
+        checkForBunOverride(overridePackageManager);
+        return shrinkWrapExists ? "npm-shrinkwrap" : "npm";
+    }
+    else if (yarnLockExists) {
+        checkForBunOverride(overridePackageManager);
+        return "yarn";
+    }
+    else if (bunLockbExists) {
+        checkForYarnOverride(overridePackageManager);
+        return "bun";
+    }
+    else {
+        printNoLockfilesError();
+        process_1.default.exit(1);
+    }
+    throw Error();
+};
+exports.detectPackageManager = detectPackageManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"detectPackageManager.js","sourceRoot":"","sources":["../src/detectPackageManager.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs-extra\"\r\nimport { join } from \"./path\"\r\nimport chalk from \"chalk\"\r\nimport process from \"process\"\r\nimport findWorkspaceRoot from \"find-yarn-workspace-root\"\r\n\r\nexport type PackageManager = \"yarn\" | \"npm\" | \"npm-shrinkwrap\" | \"bun\"\r\n\r\nfunction printNoYarnLockfileError() {\r\n  console.log(`\r\n${chalk.red.bold(\"**ERROR**\")} ${chalk.red(\r\n    `The --use-yarn option was specified but there is no yarn.lock file`,\r\n  )}\r\n`)\r\n}\r\n\r\nfunction printNoBunLockfileError() {\r\n  console.log(`\r\n${chalk.red.bold(\"**ERROR**\")} ${chalk.red(\r\n    `The --use-bun option was specified but there is no bun.lockb file`,\r\n  )}\r\n`)\r\n}\r\n\r\nfunction printNoLockfilesError() {\r\n  console.log(`\r\n${chalk.red.bold(\"**ERROR**\")} ${chalk.red(\r\n    `No package-lock.json, npm-shrinkwrap.json, yarn.lock, or bun.lockb file.\r\n\r\nYou must use either npm@>=5, yarn, npm-shrinkwrap, or bun to manage this project's\r\ndependencies.`,\r\n  )}\r\n`)\r\n}\r\n\r\nfunction printSelectingDefaultMessage() {\r\n  console.info(\r\n    `${chalk.bold(\r\n      \"patch-package\",\r\n    )}: you have multiple lockfiles, e.g. yarn.lock and package-lock.json\r\nDefaulting to using ${chalk.bold(\"npm\")}\r\nYou can override this setting by passing --use-yarn, --use-bun, or\r\ndeleting the conflicting lockfile if you don't need it\r\n`,\r\n  )\r\n}\r\n\r\nfunction printSelectingDefaultYarnMessage() {\r\n  console.info(\r\n    `${chalk.bold(\r\n      \"patch-package\",\r\n    )}: you have both yarn.lock and bun.lockb lockfiles\r\nDefaulting to using ${chalk.bold(\"yarn\")}\r\nYou can override this setting by passing --use-bun, or\r\ndeleting yarn.lock if you don't need it\r\n`,\r\n  )\r\n}\r\n\r\nfunction checkForYarnOverride(overridePackageManager: PackageManager | null) {\r\n  if (overridePackageManager === \"yarn\") {\r\n    printNoYarnLockfileError()\r\n    process.exit(1)\r\n  }\r\n}\r\n\r\nfunction checkForBunOverride(overridePackageManager: PackageManager | null) {\r\n  if (overridePackageManager === \"bun\") {\r\n    printNoBunLockfileError()\r\n    process.exit(1)\r\n  }\r\n}\r\n\r\nexport const detectPackageManager = (\r\n  appRootPath: string,\r\n  overridePackageManager: PackageManager | null,\r\n): PackageManager => {\r\n  const packageLockExists = fs.existsSync(\r\n    join(appRootPath, \"package-lock.json\"),\r\n  )\r\n  const shrinkWrapExists = fs.existsSync(\r\n    join(appRootPath, \"npm-shrinkwrap.json\"),\r\n  )\r\n  const yarnLockExists = fs.existsSync(\r\n    join(findWorkspaceRoot() ?? appRootPath, \"yarn.lock\"),\r\n  )\r\n  // Bun workspaces seem to work the same as yarn workspaces - https://bun.sh/docs/install/workspaces\r\n  const bunLockbExists = fs.existsSync(\r\n    join(findWorkspaceRoot() ?? appRootPath, \"bun.lockb\"),\r\n  )\r\n  if (\r\n    [\r\n      packageLockExists || shrinkWrapExists,\r\n      yarnLockExists,\r\n      bunLockbExists,\r\n    ].filter(Boolean).length > 1\r\n  ) {\r\n    if (overridePackageManager) {\r\n      return overridePackageManager\r\n    }\r\n    if (!packageLockExists && !shrinkWrapExists) {\r\n      // The only case where we don't want to default to npm is when we have both yarn and bun lockfiles.\r\n      printSelectingDefaultYarnMessage()\r\n      return \"yarn\"\r\n    }\r\n    printSelectingDefaultMessage()\r\n    return shrinkWrapExists ? \"npm-shrinkwrap\" : \"npm\"\r\n  } else if (packageLockExists || shrinkWrapExists) {\r\n    checkForYarnOverride(overridePackageManager)\r\n    checkForBunOverride(overridePackageManager)\r\n    return shrinkWrapExists ? \"npm-shrinkwrap\" : \"npm\"\r\n  } else if (yarnLockExists) {\r\n    checkForBunOverride(overridePackageManager)\r\n    return \"yarn\"\r\n  } else if (bunLockbExists) {\r\n    checkForYarnOverride(overridePackageManager)\r\n    return \"bun\"\r\n  } else {\r\n    printNoLockfilesError()\r\n    process.exit(1)\r\n  }\r\n  throw Error()\r\n}\r\n"]}

package/dist/filterFiles.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeIgnoredFiles = removeIgnoredFiles;
+const path_1 = require("./path");
+const fs_extra_1 = require("fs-extra");
+const klaw_sync_1 = __importDefault(require("klaw-sync"));
+function removeIgnoredFiles(dir, includePaths, excludePaths) {
+    (0, klaw_sync_1.default)(dir, { nodir: true })
+        .map((item) => item.path.slice(`${dir}/`.length))
+        .filter((relativePath) => !relativePath.match(includePaths) || relativePath.match(excludePaths))
+        .forEach((relativePath) => (0, fs_extra_1.removeSync)((0, path_1.join)(dir, relativePath)));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyRmlsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZmlsdGVyRmlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFJQSxnREFZQztBQWhCRCxpQ0FBNkI7QUFDN0IsdUNBQXFDO0FBQ3JDLDBEQUFnQztBQUVoQyxTQUFnQixrQkFBa0IsQ0FDaEMsR0FBVyxFQUNYLFlBQW9CLEVBQ3BCLFlBQW9CO0lBRXBCLElBQUEsbUJBQVEsRUFBQyxHQUFHLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7U0FDM0IsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEdBQUcsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1NBQ2hELE1BQU0sQ0FDTCxDQUFDLFlBQVksRUFBRSxFQUFFLENBQ2YsQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxJQUFJLFlBQVksQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLENBQ3hFO1NBQ0EsT0FBTyxDQUFDLENBQUMsWUFBWSxFQUFFLEVBQUUsQ0FBQyxJQUFBLHFCQUFVLEVBQUMsSUFBQSxXQUFJLEVBQUMsR0FBRyxFQUFFLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUNuRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgam9pbiB9IGZyb20gXCIuL3BhdGhcIlxyXG5pbXBvcnQgeyByZW1vdmVTeW5jIH0gZnJvbSBcImZzLWV4dHJhXCJcclxuaW1wb3J0IGtsYXdTeW5jIGZyb20gXCJrbGF3LXN5bmNcIlxyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIHJlbW92ZUlnbm9yZWRGaWxlcyhcclxuICBkaXI6IHN0cmluZyxcclxuICBpbmNsdWRlUGF0aHM6IFJlZ0V4cCxcclxuICBleGNsdWRlUGF0aHM6IFJlZ0V4cCxcclxuKSB7XHJcbiAga2xhd1N5bmMoZGlyLCB7IG5vZGlyOiB0cnVlIH0pXHJcbiAgICAubWFwKChpdGVtKSA9PiBpdGVtLnBhdGguc2xpY2UoYCR7ZGlyfS9gLmxlbmd0aCkpXHJcbiAgICAuZmlsdGVyKFxyXG4gICAgICAocmVsYXRpdmVQYXRoKSA9PlxyXG4gICAgICAgICFyZWxhdGl2ZVBhdGgubWF0Y2goaW5jbHVkZVBhdGhzKSB8fCByZWxhdGl2ZVBhdGgubWF0Y2goZXhjbHVkZVBhdGhzKSxcclxuICAgIClcclxuICAgIC5mb3JFYWNoKChyZWxhdGl2ZVBhdGgpID0+IHJlbW92ZVN5bmMoam9pbihkaXIsIHJlbGF0aXZlUGF0aCkpKVxyXG59XHJcbiJdfQ==

package/dist/getAppRootPath.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppRootPath = void 0;
+const path_1 = require("./path");
+const process_1 = __importDefault(require("process"));
+const fs_extra_1 = require("fs-extra");
+const getAppRootPath = () => {
+    let cwd = process_1.default.cwd();
+    while (!(0, fs_extra_1.existsSync)((0, path_1.join)(cwd, "package.json"))) {
+        const up = (0, path_1.resolve)(cwd, "../");
+        if (up === cwd) {
+            throw new Error("no package.json found for this project");
+        }
+        cwd = up;
+    }
+    return cwd;
+};
+exports.getAppRootPath = getAppRootPath;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0QXBwUm9vdFBhdGguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZ2V0QXBwUm9vdFBhdGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsaUNBQXNDO0FBQ3RDLHNEQUE2QjtBQUM3Qix1Q0FBcUM7QUFFOUIsTUFBTSxjQUFjLEdBQUcsR0FBVyxFQUFFO0lBQ3pDLElBQUksR0FBRyxHQUFHLGlCQUFPLENBQUMsR0FBRyxFQUFFLENBQUE7SUFDdkIsT0FBTyxDQUFDLElBQUEscUJBQVUsRUFBQyxJQUFBLFdBQUksRUFBQyxHQUFHLEVBQUUsY0FBYyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzlDLE1BQU0sRUFBRSxHQUFHLElBQUEsY0FBTyxFQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQTtRQUM5QixJQUFJLEVBQUUsS0FBSyxHQUFHLEVBQUUsQ0FBQztZQUNmLE1BQU0sSUFBSSxLQUFLLENBQUMsd0NBQXdDLENBQUMsQ0FBQTtRQUMzRCxDQUFDO1FBQ0QsR0FBRyxHQUFHLEVBQUUsQ0FBQTtJQUNWLENBQUM7SUFDRCxPQUFPLEdBQUcsQ0FBQTtBQUNaLENBQUMsQ0FBQTtBQVZZLFFBQUEsY0FBYyxrQkFVMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBqb2luLCByZXNvbHZlIH0gZnJvbSBcIi4vcGF0aFwiXHJcbmltcG9ydCBwcm9jZXNzIGZyb20gXCJwcm9jZXNzXCJcclxuaW1wb3J0IHsgZXhpc3RzU3luYyB9IGZyb20gXCJmcy1leHRyYVwiXHJcblxyXG5leHBvcnQgY29uc3QgZ2V0QXBwUm9vdFBhdGggPSAoKTogc3RyaW5nID0+IHtcclxuICBsZXQgY3dkID0gcHJvY2Vzcy5jd2QoKVxyXG4gIHdoaWxlICghZXhpc3RzU3luYyhqb2luKGN3ZCwgXCJwYWNrYWdlLmpzb25cIikpKSB7XHJcbiAgICBjb25zdCB1cCA9IHJlc29sdmUoY3dkLCBcIi4uL1wiKVxyXG4gICAgaWYgKHVwID09PSBjd2QpIHtcclxuICAgICAgdGhyb3cgbmV3IEVycm9yKFwibm8gcGFja2FnZS5qc29uIGZvdW5kIGZvciB0aGlzIHByb2plY3RcIilcclxuICAgIH1cclxuICAgIGN3ZCA9IHVwXHJcbiAgfVxyXG4gIHJldHVybiBjd2RcclxufVxyXG4iXX0=

package/dist/getPackageResolution.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageResolution = getPackageResolution;
+const path_1 = require("./path");
+const PackageDetails_1 = require("./PackageDetails");
+const detectPackageManager_1 = require("./detectPackageManager");
+const fs_extra_1 = require("fs-extra");
+const lockfile_1 = require("@yarnpkg/lockfile");
+const yaml_1 = __importDefault(require("yaml"));
+const find_yarn_workspace_root_1 = __importDefault(require("find-yarn-workspace-root"));
+const getPackageVersion_1 = require("./getPackageVersion");
+const coerceSemVer_1 = require("./coerceSemVer");
+const parseBunLockfile_1 = require("./parseBunLockfile");
+function getPackageResolution({ packageDetails, packageManager, appPath, }) {
+    if (packageManager === "yarn" || packageManager === "bun") {
+        const isBun = packageManager === "bun";
+        const lockFileName = isBun ? "bun.lockb" : "yarn.lock";
+        let lockFilePath = lockFileName;
+        if (!(0, fs_extra_1.existsSync)(lockFilePath)) {
+            const workspaceRoot = (0, find_yarn_workspace_root_1.default)();
+            if (!workspaceRoot) {
+                throw new Error(`Can't find ${lockFileName} file`);
+            }
+            lockFilePath = (0, path_1.join)(workspaceRoot, lockFilePath);
+        }
+        if (!(0, fs_extra_1.existsSync)(lockFilePath)) {
+            throw new Error(`Can't find ${lockFileName} file`);
+        }
+        const lockFileString = isBun
+            ? (0, parseBunLockfile_1.parseBunLockfile)(lockFilePath)
+            : (0, fs_extra_1.readFileSync)(lockFilePath).toString();
+        let appLockFile;
+        if (lockFileString.includes("yarn lockfile v1")) {
+            const parsedYarnLockFile = (0, lockfile_1.parse)(lockFileString);
+            if (parsedYarnLockFile.type !== "success") {
+                throw new Error(`Could not parse yarn v1 lock file ${isBun ? "- was originally a bun.lockb file" : ""}`);
+            }
+            else {
+                appLockFile = parsedYarnLockFile.object;
+            }
+        }
+        else {
+            try {
+                appLockFile = yaml_1.default.parse(lockFileString);
+            }
+            catch (e) {
+                console.log(e);
+                throw new Error(`Could not parse yarn v2 lock file ${isBun ? "- was originally a bun.lockb file (should not happen)" : ""}`);
+            }
+        }
+        const installedVersion = (0, getPackageVersion_1.getPackageVersion)((0, path_1.join)((0, path_1.resolve)(appPath, packageDetails.path), "package.json"));
+        const entries = Object.entries(appLockFile).filter(([k, v]) => k.startsWith(packageDetails.name + "@") &&
+            // @ts-ignore
+            (0, coerceSemVer_1.coerceSemVer)(v.version) === (0, coerceSemVer_1.coerceSemVer)(installedVersion));
+        const resolutions = entries.map(([_, v]) => {
+            // @ts-ignore
+            return v.resolved;
+        });
+        if (resolutions.length === 0) {
+            throw new Error(`\`${packageDetails.pathSpecifier}\`'s installed version is ${installedVersion} but a lockfile entry for it couldn't be found. Your lockfile is likely to be corrupt or you forgot to reinstall your packages.`);
+        }
+        if (new Set(resolutions).size !== 1) {
+            console.log(`Ambigious lockfile entries for ${packageDetails.pathSpecifier}. Using version ${installedVersion}`);
+            return installedVersion;
+        }
+        if (resolutions[0]) {
+            return resolutions[0];
+        }
+        const resolution = entries[0][0].slice(packageDetails.name.length + 1);
+        // resolve relative file path
+        if (resolution.startsWith("file:.")) {
+            return `file:${(0, path_1.resolve)(appPath, resolution.slice("file:".length))}`;
+        }
+        if (resolution.startsWith("npm:")) {
+            return resolution.replace("npm:", "");
+        }
+        return resolution;
+    }
+    else {
+        const lockfile = require((0, path_1.join)(appPath, packageManager === "npm-shrinkwrap"
+            ? "npm-shrinkwrap.json"
+            : "package-lock.json"));
+        const lockFileStack = [lockfile];
+        for (const name of packageDetails.packageNames.slice(0, -1)) {
+            const child = lockFileStack[0].dependencies;
+            if (child && name in child) {
+                lockFileStack.push(child[name]);
+            }
+        }
+        lockFileStack.reverse();
+        const relevantStackEntry = lockFileStack.find((entry) => {
+            if (entry.dependencies) {
+                return entry.dependencies && packageDetails.name in entry.dependencies;
+            }
+            else if (entry.packages) {
+                return entry.packages && packageDetails.path in entry.packages;
+            }
+            throw new Error("Cannot find dependencies or packages in lockfile");
+        });
+        const pkg = relevantStackEntry.dependencies
+            ? relevantStackEntry.dependencies[packageDetails.name]
+            : relevantStackEntry.packages[packageDetails.path];
+        return pkg.resolved || pkg.version || pkg.from;
+    }
+}
+if (require.main === module) {
+    const packageDetails = (0, PackageDetails_1.getPatchDetailsFromCliString)(process.argv[2]);
+    if (!packageDetails) {
+        console.log(`Can't find package ${process.argv[2]}`);
+        process.exit(1);
+    }
+    console.log(getPackageResolution({
+        appPath: process.cwd(),
+        packageDetails,
+        packageManager: (0, detectPackageManager_1.detectPackageManager)(process.cwd(), null),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"getPackageResolution.js","sourceRoot":"","sources":["../src/getPackageResolution.ts"],"names":[],"mappings":"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","sourcesContent":["import { join, resolve } from \"./path\"\r\nimport { PackageDetails, getPatchDetailsFromCliString } from \"./PackageDetails\"\r\nimport { PackageManager, detectPackageManager } from \"./detectPackageManager\"\r\nimport { readFileSync, existsSync } from \"fs-extra\"\r\nimport { parse as parseYarnLockFile } from \"@yarnpkg/lockfile\"\r\nimport yaml from \"yaml\"\r\nimport findWorkspaceRoot from \"find-yarn-workspace-root\"\r\nimport { getPackageVersion } from \"./getPackageVersion\"\r\nimport { coerceSemVer } from \"./coerceSemVer\"\r\nimport { parseBunLockfile } from \"./parseBunLockfile\"\r\n\r\nexport function getPackageResolution({\r\n  packageDetails,\r\n  packageManager,\r\n  appPath,\r\n}: {\r\n  packageDetails: PackageDetails\r\n  packageManager: PackageManager\r\n  appPath: string\r\n}) {\r\n  if (packageManager === \"yarn\" || packageManager === \"bun\") {\r\n    const isBun = packageManager === \"bun\"\r\n    const lockFileName = isBun ? \"bun.lockb\" : \"yarn.lock\"\r\n    let lockFilePath = lockFileName\r\n    if (!existsSync(lockFilePath)) {\r\n      const workspaceRoot = findWorkspaceRoot()\r\n      if (!workspaceRoot) {\r\n        throw new Error(`Can't find ${lockFileName} file`)\r\n      }\r\n      lockFilePath = join(workspaceRoot, lockFilePath)\r\n    }\r\n    if (!existsSync(lockFilePath)) {\r\n      throw new Error(`Can't find ${lockFileName} file`)\r\n    }\r\n    const lockFileString = isBun\r\n      ? parseBunLockfile(lockFilePath)\r\n      : readFileSync(lockFilePath).toString()\r\n    let appLockFile\r\n    if (lockFileString.includes(\"yarn lockfile v1\")) {\r\n      const parsedYarnLockFile = parseYarnLockFile(lockFileString)\r\n      if (parsedYarnLockFile.type !== \"success\") {\r\n        throw new Error(\r\n          `Could not parse yarn v1 lock file ${\r\n            isBun ? \"- was originally a bun.lockb file\" : \"\"\r\n          }`,\r\n        )\r\n      } else {\r\n        appLockFile = parsedYarnLockFile.object\r\n      }\r\n    } else {\r\n      try {\r\n        appLockFile = yaml.parse(lockFileString)\r\n      } catch (e) {\r\n        console.log(e)\r\n        throw new Error(\r\n          `Could not parse yarn v2 lock file ${\r\n            isBun ? \"- was originally a bun.lockb file (should not happen)\" : \"\"\r\n          }`,\r\n        )\r\n      }\r\n    }\r\n\r\n    const installedVersion = getPackageVersion(\r\n      join(resolve(appPath, packageDetails.path), \"package.json\"),\r\n    )\r\n\r\n    const entries = Object.entries(appLockFile).filter(\r\n      ([k, v]) =>\r\n        k.startsWith(packageDetails.name + \"@\") &&\r\n        // @ts-ignore\r\n        coerceSemVer(v.version) === coerceSemVer(installedVersion),\r\n    )\r\n\r\n    const resolutions = entries.map(([_, v]) => {\r\n      // @ts-ignore\r\n      return v.resolved\r\n    })\r\n\r\n    if (resolutions.length === 0) {\r\n      throw new Error(\r\n        `\\`${packageDetails.pathSpecifier}\\`'s installed version is ${installedVersion} but a lockfile entry for it couldn't be found. Your lockfile is likely to be corrupt or you forgot to reinstall your packages.`,\r\n      )\r\n    }\r\n\r\n    if (new Set(resolutions).size !== 1) {\r\n      console.log(\r\n        `Ambigious lockfile entries for ${packageDetails.pathSpecifier}. Using version ${installedVersion}`,\r\n      )\r\n      return installedVersion\r\n    }\r\n\r\n    if (resolutions[0]) {\r\n      return resolutions[0]\r\n    }\r\n\r\n    const resolution = entries[0][0].slice(packageDetails.name.length + 1)\r\n\r\n    // resolve relative file path\r\n    if (resolution.startsWith(\"file:.\")) {\r\n      return `file:${resolve(appPath, resolution.slice(\"file:\".length))}`\r\n    }\r\n\r\n    if (resolution.startsWith(\"npm:\")) {\r\n      return resolution.replace(\"npm:\", \"\")\r\n    }\r\n\r\n    return resolution\r\n  } else {\r\n    const lockfile = require(\r\n      join(\r\n        appPath,\r\n        packageManager === \"npm-shrinkwrap\"\r\n          ? \"npm-shrinkwrap.json\"\r\n          : \"package-lock.json\",\r\n      ),\r\n    )\r\n    const lockFileStack = [lockfile]\r\n    for (const name of packageDetails.packageNames.slice(0, -1)) {\r\n      const child = lockFileStack[0].dependencies\r\n      if (child && name in child) {\r\n        lockFileStack.push(child[name])\r\n      }\r\n    }\r\n    lockFileStack.reverse()\r\n    const relevantStackEntry = lockFileStack.find((entry) => {\r\n      if (entry.dependencies) {\r\n        return entry.dependencies && packageDetails.name in entry.dependencies\r\n      } else if (entry.packages) {\r\n        return entry.packages && packageDetails.path in entry.packages\r\n      }\r\n      throw new Error(\"Cannot find dependencies or packages in lockfile\")\r\n    })\r\n    const pkg = relevantStackEntry.dependencies\r\n      ? relevantStackEntry.dependencies[packageDetails.name]\r\n      : relevantStackEntry.packages[packageDetails.path]\r\n    return pkg.resolved || pkg.version || pkg.from\r\n  }\r\n}\r\n\r\nif (require.main === module) {\r\n  const packageDetails = getPatchDetailsFromCliString(process.argv[2])\r\n  if (!packageDetails) {\r\n    console.log(`Can't find package ${process.argv[2]}`)\r\n    process.exit(1)\r\n  }\r\n  console.log(\r\n    getPackageResolution({\r\n      appPath: process.cwd(),\r\n      packageDetails,\r\n      packageManager: detectPackageManager(process.cwd(), null),\r\n    }),\r\n  )\r\n}\r\n"]}

package/dist/getPackageVersion.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = getPackageVersion;
+function getPackageVersion(packageJsonPath) {
+    // remove build metadata
+    return require(packageJsonPath).version.replace(/\+.*$/, "");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0UGFja2FnZVZlcnNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZ2V0UGFja2FnZVZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSw4Q0FHQztBQUhELFNBQWdCLGlCQUFpQixDQUFDLGVBQXVCO0lBQ3ZELHdCQUF3QjtJQUN4QixPQUFPLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQTtBQUM5RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGdldFBhY2thZ2VWZXJzaW9uKHBhY2thZ2VKc29uUGF0aDogc3RyaW5nKTogc3RyaW5nIHtcclxuICAvLyByZW1vdmUgYnVpbGQgbWV0YWRhdGFcclxuICByZXR1cm4gcmVxdWlyZShwYWNrYWdlSnNvblBhdGgpLnZlcnNpb24ucmVwbGFjZSgvXFwrLiokLywgXCJcIilcclxufVxyXG4iXX0=

package/dist/hash.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashFile = hashFile;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const bufferSize = 1024;
+const buffer = Buffer.alloc(bufferSize);
+function hashFile(filePath) {
+    const sha = (0, crypto_1.createHash)("sha256");
+    const fileDescriptor = (0, fs_1.openSync)(filePath, "r");
+    const size = (0, fs_1.statSync)(filePath).size;
+    let totalBytesRead = 0;
+    while (totalBytesRead < size) {
+        const bytesRead = (0, fs_1.readSync)(fileDescriptor, buffer, 0, Math.min(size - totalBytesRead, bufferSize), totalBytesRead);
+        if (bytesRead < bufferSize) {
+            sha.update(buffer.slice(0, bytesRead));
+        }
+        else {
+            sha.update(buffer);
+        }
+        totalBytesRead += bytesRead;
+    }
+    (0, fs_1.closeSync)(fileDescriptor);
+    return sha.digest("hex");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const process_1 = __importDefault(require("process"));
+const minimist_1 = __importDefault(require("minimist"));
+const applyPatches_1 = require("./applyPatches");
+const getAppRootPath_1 = require("./getAppRootPath");
+const makePatch_1 = require("./makePatch");
+const makeRegExp_1 = require("./makeRegExp");
+const detectPackageManager_1 = require("./detectPackageManager");
+const path_1 = require("./path");
+const path_2 = require("path");
+const slash = require("slash");
+const ci_info_1 = require("ci-info");
+const rebase_1 = require("./rebase");
+const appPath = (0, getAppRootPath_1.getAppRootPath)();
+const argv = (0, minimist_1.default)(process_1.default.argv.slice(2), {
+    boolean: [
+        "use-yarn",
+        "use-bun",
+        "case-sensitive-path-filtering",
+        "reverse",
+        "help",
+        "version",
+        "error-on-fail",
+        "error-on-warn",
+        "create-issue",
+        "partial",
+        "",
+    ],
+    string: ["patch-dir", "append", "rebase"],
+});
+const packageNames = argv._;
+console.log(chalk_1.default.bold("patch-package"), 
+// tslint:disable-next-line:no-var-requires
+require((0, path_1.join)(__dirname, "../package.json")).version);
+if (argv.version || argv.v) {
+    // noop
+}
+else if (argv.help || argv.h) {
+    printHelp();
+}
+else {
+    const patchDir = slash((0, path_2.normalize)((argv["patch-dir"] || "patches") + path_2.sep));
+    if (patchDir.startsWith("/")) {
+        throw new Error("--patch-dir must be a relative path");
+    }
+    if ("rebase" in argv) {
+        if (!argv.rebase) {
+            console.log(chalk_1.default.red("You must specify a patch file name or number when rebasing patches"));
+            process_1.default.exit(1);
+        }
+        if (packageNames.length !== 1) {
+            console.log(chalk_1.default.red("You must specify exactly one package name when rebasing patches"));
+            process_1.default.exit(1);
+        }
+        (0, rebase_1.rebase)({
+            appPath,
+            packagePathSpecifier: packageNames[0],
+            patchDir,
+            targetPatch: argv.rebase,
+        });
+    }
+    else if (packageNames.length) {
+        const includePaths = (0, makeRegExp_1.makeRegExp)(argv.include, "include", /.*/, argv["case-sensitive-path-filtering"]);
+        const excludePaths = (0, makeRegExp_1.makeRegExp)(argv.exclude, "exclude", /^package\.json$/, argv["case-sensitive-path-filtering"]);
+        const packageManager = (0, detectPackageManager_1.detectPackageManager)(appPath, argv["use-yarn"] ? "yarn" : argv["use-bun"] ? "bun" : null);
+        const createIssue = argv["create-issue"];
+        packageNames.forEach((packagePathSpecifier) => {
+            (0, makePatch_1.makePatch)({
+                packagePathSpecifier,
+                appPath,
+                packageManager,
+                includePaths,
+                excludePaths,
+                patchDir,
+                createIssue,
+                mode: "append" in argv
+                    ? { type: "append", name: argv.append || undefined }
+                    : { type: "overwrite_last" },
+            });
+        });
+    }
+    else {
+        console.log("Applying patches...");
+        const reverse = !!argv["reverse"];
+        // don't want to exit(1) on postinstall locally.
+        // see https://github.com/ds300/patch-package/issues/86
+        const shouldExitWithError = !!argv["error-on-fail"] ||
+            (process_1.default.env.NODE_ENV === "production" && ci_info_1.isCI) ||
+            (ci_info_1.isCI && !process_1.default.env.PATCH_PACKAGE_INTEGRATION_TEST) ||
+            process_1.default.env.NODE_ENV === "test";
+        const shouldExitWithWarning = !!argv["error-on-warn"];
+        (0, applyPatches_1.applyPatchesForApp)({
+            appPath,
+            reverse,
+            patchDir,
+            shouldExitWithError,
+            shouldExitWithWarning,
+            bestEffort: argv.partial,
+        });
+    }
+}
+function printHelp() {
+    console.log(`
+Usage:
+
+  1. Patching packages
+  ====================
+
+    ${chalk_1.default.bold("patch-package")}
+
+  Without arguments, the ${chalk_1.default.bold("patch-package")} command will attempt to find and apply
+  patch files to your project. It looks for files named like
+
+     ./patches/<package-name>+<version>.patch
+
+  Options:
+
+    ${chalk_1.default.bold("--patch-dir <dirname>")}
+
+      Specify the name for the directory in which the patch files are located.
+
+    ${chalk_1.default.bold("--error-on-fail")}
+
+      Forces patch-package to exit with code 1 after failing.
+
+      When running locally patch-package always exits with 0 by default.
+      This happens even after failing to apply patches because otherwise
+      yarn.lock and package.json might get out of sync with node_modules,
+      which can be very confusing.
+
+      --error-on-fail is ${chalk_1.default.bold("switched on")} by default on CI.
+
+      See https://github.com/ds300/patch-package/issues/86 for background.
+
+    ${chalk_1.default.bold("--error-on-warn")}
+
+      Forces patch-package to exit with code 1 after warning.
+
+      See https://github.com/ds300/patch-package/issues/314 for background.
+
+    ${chalk_1.default.bold("--reverse")}
+
+      Un-applies all patches.
+
+      Note that this will fail if the patched files have changed since being
+      patched. In that case, you'll probably need to re-install 'node_modules'.
+
+      This option was added to help people using CircleCI avoid an issue around caching
+      and patch file updates (https://github.com/ds300/patch-package/issues/37),
+      but might be useful in other contexts too.
+
+
+  2. Creating patch files
+  =======================
+
+    ${chalk_1.default.bold("patch-package")} <package-name>${chalk_1.default.italic("[ <package-name>]")}
+
+  When given package names as arguments, patch-package will create patch files
+  based on any changes you've made to the versions installed by yarn/npm.
+
+  Options:
+
+    ${chalk_1.default.bold("--create-issue")}
+
+       For packages whose source is hosted on GitHub this option opens a web
+       browser with a draft issue based on your diff.
+
+    ${chalk_1.default.bold("--use-yarn")}
+
+        By default, patch-package checks whether you use npm, yarn or bun based on
+        which lockfile you have. If you have multiple lockfiles, it uses npm by
+        default (in cases where npm is not available, it will resort to yarn). Set
+        this option to override that default and always use yarn.
+
+    ${chalk_1.default.bold("--use-bun")}
+
+        Similar to --use-yarn, but for bun. If both --use-yarn and --use-bun are
+        specified, --use-yarn takes precedence.
+
+    ${chalk_1.default.bold("--exclude <regexp>")}
+
+        Ignore paths matching the regexp when creating patch files.
+        Paths are relative to the root dir of the package to be patched.
+
+        Default: 'package\\.json$'
+
+    ${chalk_1.default.bold("--include <regexp>")}
+
+        Only consider paths matching the regexp when creating patch files.
+        Paths are relative to the root dir of the package to be patched.
+
+        Default '.*'
+
+    ${chalk_1.default.bold("--case-sensitive-path-filtering")}
+
+        Make regexps used in --include or --exclude filters case-sensitive.
+
+    ${chalk_1.default.bold("--patch-dir")}
+
+        Specify the name for the directory in which to put the patch files.
+`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAAA,kDAAyB;AACzB,sDAA6B;AAC7B,wDAA+B;AAE/B,iDAAmD;AACnD,qDAAiD;AACjD,2CAAuC;AACvC,6CAAyC;AACzC,iEAA6D;AAC7D,iCAA6B;AAC7B,+BAAqC;AACrC,+BAA+B;AAC/B,qCAA8B;AAC9B,qCAAiC;AAEjC,MAAM,OAAO,GAAG,IAAA,+BAAc,GAAE,CAAA;AAChC,MAAM,IAAI,GAAG,IAAA,kBAAQ,EAAC,iBAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;IAC3C,OAAO,EAAE;QACP,UAAU;QACV,SAAS;QACT,+BAA+B;QAC/B,SAAS;QACT,MAAM;QACN,SAAS;QACT,eAAe;QACf,eAAe;QACf,cAAc;QACd,SAAS;QACT,EAAE;KACH;IACD,MAAM,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC1C,CAAC,CAAA;AACF,MAAM,YAAY,GAAG,IAAI,CAAC,CAAC,CAAA;AAE3B,OAAO,CAAC,GAAG,CACT,eAAK,CAAC,IAAI,CAAC,eAAe,CAAC;AAC3B,2CAA2C;AAC3C,OAAO,CAAC,IAAA,WAAI,EAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,OAAO,CACpD,CAAA;AAED,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC;IAC3B,OAAO;AACT,CAAC;KAAM,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC;IAC/B,SAAS,EAAE,CAAA;AACb,CAAC;KAAM,CAAC;IACN,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAA,gBAAS,EAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,SAAS,CAAC,GAAG,UAAG,CAAC,CAAC,CAAA;IACzE,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAA;IACxD,CAAC;IACD,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,OAAO,CAAC,GAAG,CACT,eAAK,CAAC,GAAG,CACP,oEAAoE,CACrE,CACF,CAAA;YACD,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACjB,CAAC;QACD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CACT,eAAK,CAAC,GAAG,CACP,iEAAiE,CAClE,CACF,CAAA;YACD,iBAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACjB,CAAC;QACD,IAAA,eAAM,EAAC;YACL,OAAO;YACP,oBAAoB,EAAE,YAAY,CAAC,CAAC,CAAC;YACrC,QAAQ;YACR,WAAW,EAAE,IAAI,CAAC,MAAM;SACzB,CAAC,CAAA;IACJ,CAAC;SAAM,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QAC/B,MAAM,YAAY,GAAG,IAAA,uBAAU,EAC7B,IAAI,CAAC,OAAO,EACZ,SAAS,EACT,IAAI,EACJ,IAAI,CAAC,+BAA+B,CAAC,CACtC,CAAA;QACD,MAAM,YAAY,GAAG,IAAA,uBAAU,EAC7B,IAAI,CAAC,OAAO,EACZ,SAAS,EACT,iBAAiB,EACjB,IAAI,CAAC,+BAA+B,CAAC,CACtC,CAAA;QACD,MAAM,cAAc,GAAG,IAAA,2CAAoB,EACzC,OAAO,EACP,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAC3D,CAAA;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,CAAA;QACxC,YAAY,CAAC,OAAO,CAAC,CAAC,oBAA4B,EAAE,EAAE;YACpD,IAAA,qBAAS,EAAC;gBACR,oBAAoB;gBACpB,OAAO;gBACP,cAAc;gBACd,YAAY;gBACZ,YAAY;gBACZ,QAAQ;gBACR,WAAW;gBACX,IAAI,EACF,QAAQ,IAAI,IAAI;oBACd,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,IAAI,SAAS,EAAE;oBACpD,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE;aACjC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAA;QAClC,MAAM,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACjC,gDAAgD;QAChD,uDAAuD;QACvD,MAAM,mBAAmB,GACvB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC;YACvB,CAAC,iBAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,IAAI,cAAI,CAAC;YAC/C,CAAC,cAAI,IAAI,CAAC,iBAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC;YACrD,iBAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,CAAA;QAEjC,MAAM,qBAAqB,GAAG,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;QAErD,IAAA,iCAAkB,EAAC;YACjB,OAAO;YACP,OAAO;YACP,QAAQ;YACR,mBAAmB;YACnB,qBAAqB;YACrB,UAAU,EAAE,IAAI,CAAC,OAAO;SACzB,CAAC,CAAA;IACJ,CAAC;AACH,CAAC;AAED,SAAS,SAAS;IAChB,OAAO,CAAC,GAAG,CAAC;;;;;;MAMR,eAAK,CAAC,IAAI,CAAC,eAAe,CAAC;;2BAEN,eAAK,CAAC,IAAI,CACjC,eAAe,CAChB;;;;;;;MAOG,eAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC;;;;MAInC,eAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC;;;;;;;;;2BASR,eAAK,CAAC,IAAI,CAAC,aAAa,CAAC;;;;MAI9C,eAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC;;;;;;MAM7B,eAAK,CAAC,IAAI,CAAC,WAAW,CAAC;;;;;;;;;;;;;;;MAevB,eAAK,CAAC,IAAI,CAAC,eAAe,CAAC,kBAAkB,eAAK,CAAC,MAAM,CACzD,mBAAmB,CACpB;;;;;;;MAOC,eAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC;;;;;MAK5B,eAAK,CAAC,IAAI,CAAC,YAAY,CAAC;;;;;;;MAOxB,eAAK,CAAC,IAAI,CAAC,WAAW,CAAC;;;;;MAKvB,eAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC;;;;;;;MAOhC,eAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC;;;;;;;MAOhC,eAAK,CAAC,IAAI,CAAC,iCAAiC,CAAC;;;;MAI7C,eAAK,CAAC,IAAI,CAAC,aAAa,CAAC;;;CAG9B,CAAC,CAAA;AACF,CAAC","sourcesContent":["import chalk from \"chalk\"\r\nimport process from \"process\"\r\nimport minimist from \"minimist\"\r\n\r\nimport { applyPatchesForApp } from \"./applyPatches\"\r\nimport { getAppRootPath } from \"./getAppRootPath\"\r\nimport { makePatch } from \"./makePatch\"\r\nimport { makeRegExp } from \"./makeRegExp\"\r\nimport { detectPackageManager } from \"./detectPackageManager\"\r\nimport { join } from \"./path\"\r\nimport { normalize, sep } from \"path\"\r\nimport slash = require(\"slash\")\r\nimport { isCI } from \"ci-info\"\r\nimport { rebase } from \"./rebase\"\r\n\r\nconst appPath = getAppRootPath()\r\nconst argv = minimist(process.argv.slice(2), {\r\n  boolean: [\r\n    \"use-yarn\",\r\n    \"use-bun\",\r\n    \"case-sensitive-path-filtering\",\r\n    \"reverse\",\r\n    \"help\",\r\n    \"version\",\r\n    \"error-on-fail\",\r\n    \"error-on-warn\",\r\n    \"create-issue\",\r\n    \"partial\",\r\n    \"\",\r\n  ],\r\n  string: [\"patch-dir\", \"append\", \"rebase\"],\r\n})\r\nconst packageNames = argv._\r\n\r\nconsole.log(\r\n  chalk.bold(\"patch-package\"),\r\n  // tslint:disable-next-line:no-var-requires\r\n  require(join(__dirname, \"../package.json\")).version,\r\n)\r\n\r\nif (argv.version || argv.v) {\r\n  // noop\r\n} else if (argv.help || argv.h) {\r\n  printHelp()\r\n} else {\r\n  const patchDir = slash(normalize((argv[\"patch-dir\"] || \"patches\") + sep))\r\n  if (patchDir.startsWith(\"/\")) {\r\n    throw new Error(\"--patch-dir must be a relative path\")\r\n  }\r\n  if (\"rebase\" in argv) {\r\n    if (!argv.rebase) {\r\n      console.log(\r\n        chalk.red(\r\n          \"You must specify a patch file name or number when rebasing patches\",\r\n        ),\r\n      )\r\n      process.exit(1)\r\n    }\r\n    if (packageNames.length !== 1) {\r\n      console.log(\r\n        chalk.red(\r\n          \"You must specify exactly one package name when rebasing patches\",\r\n        ),\r\n      )\r\n      process.exit(1)\r\n    }\r\n    rebase({\r\n      appPath,\r\n      packagePathSpecifier: packageNames[0],\r\n      patchDir,\r\n      targetPatch: argv.rebase,\r\n    })\r\n  } else if (packageNames.length) {\r\n    const includePaths = makeRegExp(\r\n      argv.include,\r\n      \"include\",\r\n      /.*/,\r\n      argv[\"case-sensitive-path-filtering\"],\r\n    )\r\n    const excludePaths = makeRegExp(\r\n      argv.exclude,\r\n      \"exclude\",\r\n      /^package\\.json$/,\r\n      argv[\"case-sensitive-path-filtering\"],\r\n    )\r\n    const packageManager = detectPackageManager(\r\n      appPath,\r\n      argv[\"use-yarn\"] ? \"yarn\" : argv[\"use-bun\"] ? \"bun\" : null,\r\n    )\r\n    const createIssue = argv[\"create-issue\"]\r\n    packageNames.forEach((packagePathSpecifier: string) => {\r\n      makePatch({\r\n        packagePathSpecifier,\r\n        appPath,\r\n        packageManager,\r\n        includePaths,\r\n        excludePaths,\r\n        patchDir,\r\n        createIssue,\r\n        mode:\r\n          \"append\" in argv\r\n            ? { type: \"append\", name: argv.append || undefined }\r\n            : { type: \"overwrite_last\" },\r\n      })\r\n    })\r\n  } else {\r\n    console.log(\"Applying patches...\")\r\n    const reverse = !!argv[\"reverse\"]\r\n    // don't want to exit(1) on postinstall locally.\r\n    // see https://github.com/ds300/patch-package/issues/86\r\n    const shouldExitWithError =\r\n      !!argv[\"error-on-fail\"] ||\r\n      (process.env.NODE_ENV === \"production\" && isCI) ||\r\n      (isCI && !process.env.PATCH_PACKAGE_INTEGRATION_TEST) ||\r\n      process.env.NODE_ENV === \"test\"\r\n\r\n    const shouldExitWithWarning = !!argv[\"error-on-warn\"]\r\n\r\n    applyPatchesForApp({\r\n      appPath,\r\n      reverse,\r\n      patchDir,\r\n      shouldExitWithError,\r\n      shouldExitWithWarning,\r\n      bestEffort: argv.partial,\r\n    })\r\n  }\r\n}\r\n\r\nfunction printHelp() {\r\n  console.log(`\r\nUsage:\r\n\r\n  1. Patching packages\r\n  ====================\r\n\r\n    ${chalk.bold(\"patch-package\")}\r\n\r\n  Without arguments, the ${chalk.bold(\r\n    \"patch-package\",\r\n  )} command will attempt to find and apply\r\n  patch files to your project. It looks for files named like\r\n\r\n     ./patches/<package-name>+<version>.patch\r\n\r\n  Options:\r\n\r\n    ${chalk.bold(\"--patch-dir <dirname>\")}\r\n\r\n      Specify the name for the directory in which the patch files are located.\r\n\r\n    ${chalk.bold(\"--error-on-fail\")}\r\n\r\n      Forces patch-package to exit with code 1 after failing.\r\n\r\n      When running locally patch-package always exits with 0 by default.\r\n      This happens even after failing to apply patches because otherwise\r\n      yarn.lock and package.json might get out of sync with node_modules,\r\n      which can be very confusing.\r\n\r\n      --error-on-fail is ${chalk.bold(\"switched on\")} by default on CI.\r\n\r\n      See https://github.com/ds300/patch-package/issues/86 for background.\r\n\r\n    ${chalk.bold(\"--error-on-warn\")}\r\n\r\n      Forces patch-package to exit with code 1 after warning.\r\n\r\n      See https://github.com/ds300/patch-package/issues/314 for background.\r\n\r\n    ${chalk.bold(\"--reverse\")}\r\n\r\n      Un-applies all patches.\r\n\r\n      Note that this will fail if the patched files have changed since being\r\n      patched. In that case, you'll probably need to re-install 'node_modules'.\r\n\r\n      This option was added to help people using CircleCI avoid an issue around caching\r\n      and patch file updates (https://github.com/ds300/patch-package/issues/37),\r\n      but might be useful in other contexts too.\r\n\r\n\r\n  2. Creating patch files\r\n  =======================\r\n\r\n    ${chalk.bold(\"patch-package\")} <package-name>${chalk.italic(\r\n      \"[ <package-name>]\",\r\n    )}\r\n\r\n  When given package names as arguments, patch-package will create patch files\r\n  based on any changes you've made to the versions installed by yarn/npm.\r\n\r\n  Options:\r\n\r\n    ${chalk.bold(\"--create-issue\")}\r\n\r\n       For packages whose source is hosted on GitHub this option opens a web\r\n       browser with a draft issue based on your diff.\r\n\r\n    ${chalk.bold(\"--use-yarn\")}\r\n\r\n        By default, patch-package checks whether you use npm, yarn or bun based on\r\n        which lockfile you have. If you have multiple lockfiles, it uses npm by\r\n        default (in cases where npm is not available, it will resort to yarn). Set\r\n        this option to override that default and always use yarn.\r\n\r\n    ${chalk.bold(\"--use-bun\")}\r\n\r\n        Similar to --use-yarn, but for bun. If both --use-yarn and --use-bun are\r\n        specified, --use-yarn takes precedence.\r\n\r\n    ${chalk.bold(\"--exclude <regexp>\")}\r\n\r\n        Ignore paths matching the regexp when creating patch files.\r\n        Paths are relative to the root dir of the package to be patched.\r\n\r\n        Default: 'package\\\\.json$'\r\n\r\n    ${chalk.bold(\"--include <regexp>\")}\r\n\r\n        Only consider paths matching the regexp when creating patch files.\r\n        Paths are relative to the root dir of the package to be patched.\r\n\r\n        Default '.*'\r\n\r\n    ${chalk.bold(\"--case-sensitive-path-filtering\")}\r\n\r\n        Make regexps used in --include or --exclude filters case-sensitive.\r\n\r\n    ${chalk.bold(\"--patch-dir\")}\r\n\r\n        Specify the name for the directory in which to put the patch files.\r\n`)\r\n}\r\n"]}