@lage-run/hasher 0.2.2 → 1.0.0

package/lib/getRepoState.d.ts

@@ -1,76 +0,0 @@
-export interface IGitVersion {
-    major: number;
-    minor: number;
-    patch: number;
-}
-/**
- * Parses the output of the "git ls-tree -r -z" command
- * @internal
- */
-export declare function parseGitLsTree(output: string): Map<string, string>;
-/**
- * Information about the changes to a file.
- * @beta
- */
-export interface IFileDiffStatus {
-    mode: string;
-    oldhash: string;
-    newhash: string;
-    status: "A" | "D" | "M";
-}
-/**
- * Parses the output of `git diff-index --color=never --no-renames --no-commit-id -z <REVISION> --
- * Returns a map of file path to diff
- * @internal
- */
-export declare function parseGitDiffIndex(output: string): Map<string, IFileDiffStatus>;
-/**
- * Parses the output of `git status -z -u` to extract the set of files that have changed since HEAD.
- *
- * @param output - The raw output from Git
- * @returns a map of file path to if it exists
- * @internal
- */
-export declare function parseGitStatus(output: string): Map<string, boolean>;
-/**
- * Finds the root of the current Git repository
- *
- * @param cwd - The working directory for which to locate the repository
- * @param gitPath - The path to the Git executable
- *
- * @returns The full path to the root directory of the Git repository
- * @beta
- */
-export declare function getRepoRoot(cwd: string, gitPath?: string): string;
-/**
- * Augments the state value with modifications that are not in the index.
- * @param rootDirectory - The root directory of the Git repository
- * @param state - The current map of git path -> object hash. Will be mutated.
- * @param gitPath - The path to the Git executable
- * @internal
- */
-export declare function applyWorkingTreeState(rootDirectory: string, state: Map<string, string>, gitPath?: string): void;
-/**
- * Gets the object hashes for all files in the Git repo, combining the current commit with working tree state.
- * @param cwd - The working directory. Only used to find the repository root.
- * @param gitPath - The path to the Git executable
- * @beta
- */
-export declare function getRepoState(cwd: string, gitPath?: string): Map<string, string>;
-/**
- * Find all changed files tracked by Git, their current hashes, and the nature of the change. Only useful if all changes are staged or committed.
- * @param cwd - The working directory. Only used to find the repository root.
- * @param revision - The Git revision specifier to detect changes relative to. Defaults to HEAD (i.e. will compare staged vs. committed)
- *   If comparing against a different branch, call `git merge-base` first to find the target commit.
- * @param gitPath - The path to the Git executable
- * @returns A map from the Git file path to the corresponding file change metadata
- * @beta
- */
-export declare function getRepoChanges(cwd: string, revision?: string, gitPath?: string): Map<string, IFileDiffStatus>;
-/**
- * Checks the git version and throws an error if it is less than the minimum required version.
- *
- * @public
- */
-export declare function ensureGitMinimumVersion(gitPath?: string): void;
-export declare function parseGitVersion(gitVersionOutput: string): IGitVersion;

package/lib/getRepoState.js

@@ -1,256 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    parseGitLsTree: ()=>parseGitLsTree,
-    parseGitDiffIndex: ()=>parseGitDiffIndex,
-    parseGitStatus: ()=>parseGitStatus,
-    getRepoRoot: ()=>getRepoRoot,
-    applyWorkingTreeState: ()=>applyWorkingTreeState,
-    getRepoState: ()=>getRepoState,
-    getRepoChanges: ()=>getRepoChanges,
-    ensureGitMinimumVersion: ()=>ensureGitMinimumVersion,
-    parseGitVersion: ()=>parseGitVersion
-});
-const _execa = /*#__PURE__*/ _interopRequireDefault(require("execa"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const MINIMUM_GIT_VERSION = {
-    major: 2,
-    minor: 20,
-    patch: 0
-};
-function parseGitLsTree(output) {
-    const result = new Map();
-    // Parse the output
-    // With the -z modifier, paths are delimited by nulls
-    // A line looks like:
-    // <mode> <type> <newhash>\t<path>\0
-    // 100644 blob a300ccb0b36bd2c85ef18e3c619a2c747f95959e\ttools/prettier-git/prettier-git.js\0
-    let last = 0;
-    let index = output.indexOf("\0", last);
-    while(index >= 0){
-        const item = output.slice(last, index);
-        const tabIndex = item.indexOf("\t");
-        const filePath = item.slice(tabIndex + 1);
-        // The newHash will be all zeros if the file is deleted, or a hash if it exists
-        const hash = item.slice(tabIndex - 40, tabIndex);
-        result.set(filePath, hash);
-        last = index + 1;
-        index = output.indexOf("\0", last);
-    }
-    return result;
-}
-function parseGitDiffIndex(output) {
-    const result = new Map();
-    // Parse the output
-    // With the -z modifier, paths are delimited by nulls
-    // A line looks like:
-    // :<oldmode> <newmode> <oldhash> <newhash> <status>\0<path>\0
-    // :100644 100644 a300ccb0b36bd2c85ef18e3c619a2c747f95959e 0000000000000000000000000000000000000000 M\0tools/prettier-git/prettier-git.js\0
-    let last = 0;
-    let index = output.indexOf("\0", last);
-    while(index >= 0){
-        const header = output.slice(last, index);
-        const status = header.slice(-1);
-        last = index + 1;
-        index = output.indexOf("\0", last);
-        const filePath = output.slice(last, index);
-        // We passed --no-renames above, so a rename will be a delete of the old location and an add at the new.
-        // The newHash will be all zeros if the file is deleted, or a hash if it exists
-        const mode = header.slice(8, 14);
-        const oldhash = header.slice(-83, -43);
-        const newhash = header.slice(-42, -2);
-        result.set(filePath, {
-            mode,
-            oldhash,
-            newhash,
-            status
-        });
-        last = index + 1;
-        index = output.indexOf("\0", last);
-    }
-    return result;
-}
-function parseGitStatus(output) {
-    const result = new Map();
-    // Parse the output
-    // With the -z modifier, paths are delimited by nulls
-    // A line looks like:
-    // XY <path>\0
-    //  M tools/prettier-git/prettier-git.js\0
-    let startOfLine = 0;
-    let eolIndex = output.indexOf("\0", startOfLine);
-    while(eolIndex >= 0){
-        // We passed --no-renames above, so a rename will be a delete of the old location and an add at the new.
-        // charAt(startOfLine) is the index status, charAt(startOfLine + 1) is the working tree status
-        const workingTreeStatus = output.charAt(startOfLine + 1);
-        // Deleted in working tree, or not modified in working tree and deleted in index
-        const deleted = workingTreeStatus === "D" || workingTreeStatus === " " && output.charAt(startOfLine) === "D";
-        const filePath = output.slice(startOfLine + 3, eolIndex);
-        result.set(filePath, !deleted);
-        startOfLine = eolIndex + 1;
-        eolIndex = output.indexOf("\0", startOfLine);
-    }
-    return result;
-}
-const repoRootCache = new Map();
-function getRepoRoot(cwd, gitPath) {
-    let cachedResult = repoRootCache.get(cwd);
-    if (!cachedResult) {
-        const result = _execa.default.sync(gitPath || "git", [
-            "--no-optional-locks",
-            "rev-parse",
-            "--show-toplevel"
-        ], {
-            cwd
-        });
-        if (result.exitCode !== 0) {
-            ensureGitMinimumVersion(gitPath);
-            throw new Error(`git rev-parse exited with status ${result.exitCode}: ${result.stderr}`);
-        }
-        repoRootCache.set(cwd, cachedResult = result.stdout.trim());
-    }
-    return cachedResult;
-}
-function applyWorkingTreeState(rootDirectory, state, gitPath) {
-    const statusResult = _execa.default.sync(gitPath || "git", [
-        "--no-optional-locks",
-        "status",
-        "-z",
-        "-u",
-        "--no-renames",
-        "--"
-    ], {
-        cwd: rootDirectory
-    });
-    if (statusResult.exitCode !== 0) {
-        ensureGitMinimumVersion(gitPath);
-        throw new Error(`git status exited with status ${statusResult.exitCode}: ${statusResult.stderr}`);
-    }
-    const locallyModified = parseGitStatus(statusResult.stdout);
-    const filesToHash = [];
-    for (const [filePath, exists] of locallyModified){
-        if (exists) {
-            filesToHash.push(filePath);
-        } else {
-            state.delete(filePath);
-        }
-    }
-    if (filesToHash.length) {
-        // Use --stdin-paths arg to pass the list of files to git in order to avoid issues with
-        // command length
-        const hashObjectResult = _execa.default.sync(gitPath || "git", [
-            "hash-object",
-            "--stdin-paths"
-        ], {
-            cwd: rootDirectory,
-            input: filesToHash.join("\n")
-        });
-        if (hashObjectResult.exitCode !== 0) {
-            ensureGitMinimumVersion(gitPath);
-            throw new Error(`git hash-object exited with status ${hashObjectResult.exitCode}: ${hashObjectResult.stderr}`);
-        }
-        const hashStdout = hashObjectResult.stdout.trim();
-        // The result of "git hash-object" will be a list of file hashes delimited by newlines
-        const hashes = hashStdout.split("\n");
-        if (hashes.length !== filesToHash.length) {
-            throw new Error(`Passed ${filesToHash.length} file paths to Git to hash, but received ${hashes.length} hashes.`);
-        }
-        const len = hashes.length;
-        for(let i = 0; i < len; i++){
-            const hash = hashes[i];
-            const filePath = filesToHash[i];
-            state.set(filePath, hash);
-        }
-    }
-}
-function getRepoState(cwd, gitPath) {
-    const rootDirectory = getRepoRoot(cwd, gitPath);
-    const lsTreeResult = _execa.default.sync(gitPath || "git", [
-        "--no-optional-locks",
-        "ls-tree",
-        "-r",
-        "-z",
-        "--full-name",
-        "HEAD",
-        "--"
-    ], {
-        cwd: rootDirectory
-    });
-    if (lsTreeResult.exitCode !== 0) {
-        ensureGitMinimumVersion(gitPath);
-        throw new Error(`git ls-tree exited with status ${lsTreeResult.exitCode}: ${lsTreeResult.stderr}`);
-    }
-    const state = parseGitLsTree(lsTreeResult.stdout);
-    applyWorkingTreeState(rootDirectory, state, gitPath);
-    return state;
-}
-function getRepoChanges(cwd, revision = "HEAD", gitPath) {
-    const rootDirectory = getRepoRoot(cwd, gitPath);
-    const result = _execa.default.sync(gitPath || "git", [
-        "--no-optional-locks",
-        "diff-index",
-        "--color=never",
-        "--no-renames",
-        "--no-commit-id",
-        "--cached",
-        "-z",
-        revision,
-        "--"
-    ], {
-        cwd: rootDirectory
-    });
-    if (result.exitCode !== 0) {
-        ensureGitMinimumVersion(gitPath);
-        throw new Error(`git diff-index exited with status ${result.exitCode}: ${result.stderr}`);
-    }
-    const changes = parseGitDiffIndex(result.stdout);
-    return changes;
-}
-function ensureGitMinimumVersion(gitPath) {
-    const gitVersion = getGitVersion(gitPath);
-    if (gitVersion.major < MINIMUM_GIT_VERSION.major || gitVersion.major === MINIMUM_GIT_VERSION.major && gitVersion.minor < MINIMUM_GIT_VERSION.minor || gitVersion.major === MINIMUM_GIT_VERSION.major && gitVersion.minor === MINIMUM_GIT_VERSION.minor && gitVersion.patch < MINIMUM_GIT_VERSION.patch) {
-        throw new Error(`The minimum Git version required is ` + `${MINIMUM_GIT_VERSION.major}.${MINIMUM_GIT_VERSION.minor}.${MINIMUM_GIT_VERSION.patch}. ` + `Your version is ${gitVersion.major}.${gitVersion.minor}.${gitVersion.patch}.`);
-    }
-}
-function getGitVersion(gitPath) {
-    const result = _execa.default.sync(gitPath || "git", [
-        "version"
-    ]);
-    if (result.exitCode !== 0) {
-        throw new Error(`While validating the Git installation, the "git version" command failed with ` + `status ${result.exitCode}: ${result.stderr}`);
-    }
-    return parseGitVersion(result.stdout);
-}
-function parseGitVersion(gitVersionOutput) {
-    // This regexp matches output of "git version" that looks like `git version <number>.<number>.<number>(+whatever)`
-    // Examples:
-    // - git version 1.2.3
-    // - git version 1.2.3.4.5
-    // - git version 1.2.3windows.1
-    // - git version 1.2.3.windows.1
-    const versionRegex = /^git version (\d+)\.(\d+)\.(\d+)/;
-    const match = versionRegex.exec(gitVersionOutput);
-    if (!match) {
-        throw new Error(`While validating the Git installation, the "git version" command produced ` + `unexpected output: "${gitVersionOutput}"`);
-    }
-    const major = parseInt(match[1], 10);
-    const minor = parseInt(match[2], 10);
-    const patch = parseInt(match[3], 10);
-    return {
-        major,
-        minor,
-        patch
-    };
-}

package/lib/hashOfFiles.d.ts

@@ -1,14 +0,0 @@
-import type { RepoInfo } from "./repoInfo.js";
-/**
- * Generates a hash string based on files in a package
- *
- * This implementation relies on `git hash-object` to quickly calculate all files
- * in the repo, caching this result so repeated calls to this function will be
- * a simple lookup.
- *
- * Note: We have to force the types because globby types are wrong
- *
- * @param packageRoot The root of the package
- * @param repoInfo The repoInfo that carries information about repo-wide hashes
- */
-export declare function generateHashOfFiles(packageRoot: string, repoInfo: RepoInfo): Promise<string>;

package/lib/hashOfFiles.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "generateHashOfFiles", {
-    enumerable: true,
-    get: ()=>generateHashOfFiles
-});
-const _path = /*#__PURE__*/ _interopRequireWildcard(require("path"));
-const _helpersJs = require("./helpers.js");
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interopRequireWildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {};
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-async function generateHashOfFiles(packageRoot, repoInfo) {
-    const { repoHashes , root , packageHashes  } = repoInfo;
-    const hashes = [];
-    const packageRelativeRoot = _path.default.relative(root, packageRoot).replace(/\\/g, "/");
-    if (packageHashes[packageRelativeRoot]) {
-        // Fast path: if files are clearly inside a package as per the packageHashes cache
-        for (const hash of packageHashes[packageRelativeRoot]){
-            hashes.push(hash[0], hash[1]);
-        }
-        return (0, _helpersJs.hashStrings)(hashes);
-    } else {
-        // Slow old path: if files are not clearly inside a package (mostly the case for malformed monorepos, like tests)
-        const normalized = _path.default.normalize(packageRoot) + _path.sep;
-        const files = Object.keys(repoHashes).filter((f)=>_path.default.join(root, f).includes(normalized));
-        files.sort((a, b)=>a.localeCompare(b));
-        const hashes = [];
-        for (const file of files){
-            hashes.push(file, repoHashes[file]);
-        }
-        return (0, _helpersJs.hashStrings)(hashes);
-    }
-}

package/lib/hashOfPackage.d.ts

@@ -1,9 +0,0 @@
-import type { RepoInfo } from "./repoInfo.js";
-export type PackageHashInfo = {
-    name: string;
-    filesHash: string;
-    dependenciesHash: string;
-    internalDependencies: string[];
-};
-export declare function generateHashOfInternalPackages(internalPackages: PackageHashInfo[]): string;
-export declare function getPackageHash(packageRoot: string, repoInfo: RepoInfo): Promise<PackageHashInfo>;

package/lib/hashOfPackage.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    generateHashOfInternalPackages: ()=>generateHashOfInternalPackages,
-    getPackageHash: ()=>getPackageHash
-});
-const _crypto = /*#__PURE__*/ _interopRequireDefault(require("crypto"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _resolveInternalDependenciesJs = require("./resolveInternalDependencies.js");
-const _resolveExternalDependenciesJs = require("./resolveExternalDependencies.js");
-const _hashOfFilesJs = require("./hashOfFiles.js");
-const _helpersJs = require("./helpers.js");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function generateHashOfInternalPackages(internalPackages) {
-    internalPackages.sort((a, b)=>a.name.localeCompare(b.name));
-    const hasher = _crypto.default.createHash("sha1");
-    internalPackages.forEach((pkg)=>{
-        hasher.update(pkg.name);
-        hasher.update(pkg.filesHash);
-        hasher.update(pkg.dependenciesHash);
-    });
-    return hasher.digest("hex");
-}
-const memoization = {};
-async function getPackageHash(packageRoot, repoInfo) {
-    const { workspaceInfo , parsedLock  } = repoInfo;
-    const memoizationKey = _path.default.resolve(packageRoot);
-    if (memoization[memoizationKey]) {
-        return memoization[memoizationKey];
-    }
-    const { name , dependencies , devDependencies  } = JSON.parse(_fs.default.readFileSync(_path.default.join(packageRoot, "package.json"), "utf-8"));
-    const allDependencies = {
-        ...dependencies,
-        ...devDependencies
-    };
-    const internalDependencies = (0, _resolveInternalDependenciesJs.resolveInternalDependencies)(allDependencies, workspaceInfo);
-    const externalDeoendencies = (0, _resolveExternalDependenciesJs.resolveExternalDependencies)(allDependencies, workspaceInfo, parsedLock);
-    const resolvedDependencies = [
-        ...internalDependencies,
-        ...externalDeoendencies
-    ];
-    const filesHash = await (0, _hashOfFilesJs.generateHashOfFiles)(packageRoot, repoInfo);
-    const dependenciesHash = (0, _helpersJs.hashStrings)(resolvedDependencies);
-    const packageHash = {
-        name,
-        filesHash,
-        dependenciesHash,
-        internalDependencies
-    };
-    memoization[memoizationKey] = packageHash;
-    return packageHash;
-}

package/lib/helpers.d.ts

@@ -1,3 +0,0 @@
-export declare function hashStrings(strings: string | string[]): string;
-export declare function getPackageRoot(cwd: string): Promise<string>;
-export declare function nameAtVersion(name: string, version: string): string;

package/lib/helpers.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    hashStrings: ()=>hashStrings,
-    getPackageRoot: ()=>getPackageRoot,
-    nameAtVersion: ()=>nameAtVersion
-});
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _crypto = /*#__PURE__*/ _interopRequireDefault(require("crypto"));
-const _findUp = /*#__PURE__*/ _interopRequireDefault(require("find-up"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function hashStrings(strings) {
-    const hasher = _crypto.default.createHash("sha1");
-    const anArray = typeof strings === "string" ? [
-        strings
-    ] : strings;
-    const elements = [
-        ...anArray
-    ];
-    elements.sort((a, b)=>a.localeCompare(b));
-    elements.forEach((element)=>hasher.update(element));
-    return hasher.digest("hex");
-}
-async function getPackageRoot(cwd) {
-    const packageRoot = await (0, _findUp.default)("package.json", {
-        cwd
-    });
-    if (!packageRoot) {
-        throw new Error(`Could not find package.json inside ${cwd}.`);
-    }
-    return _path.default.dirname(packageRoot);
-}
-function nameAtVersion(name, version) {
-    return `${name}@${version}`;
-}

package/lib/repoInfo.d.ts

@@ -1,26 +0,0 @@
-import type { WorkspaceInfo, ParsedLock } from "workspace-tools";
-export interface RepoInfo {
-    root: string;
-    workspaceInfo: WorkspaceInfo;
-    parsedLock: ParsedLock;
-    repoHashes: {
-        [key: string]: string;
-    };
-    packageHashes: Record<string, [string, string][]>;
-}
-export declare function getRepoInfoNoCache(cwd: string): Promise<{
-    root: string;
-    workspaceInfo: WorkspaceInfo;
-    parsedLock: ParsedLock;
-    repoHashes: Record<string, string>;
-    packageHashes: Record<string, [string, string][]>;
-}>;
-/**
- * Retrieves the repoInfo, one at a time
- *
- * No parallel of this function is allowed; this maximizes the cache hit even
- * though the getWorkspaces and parseLockFile are async functions from workspace-tools
- *
- * @param cwd
- */
-export declare function getRepoInfo(cwd: string): Promise<RepoInfo>;

package/lib/repoInfo.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getRepoInfoNoCache: ()=>getRepoInfoNoCache,
-    getRepoInfo: ()=>getRepoInfo
-});
-const _workspaceTools = require("workspace-tools");
-const _getPackageDepsJs = require("./getPackageDeps.js");
-const _createPackageHashesJs = require("./createPackageHashes.js");
-const repoInfoCache = [];
-/**
- * repoInfo cache lookup - it is specialized to be using a substring match to make it run as fast as possible
- * @param packageRoot
- */ function searchRepoInfoCache(packageRoot) {
-    for (const repoInfo of repoInfoCache){
-        if (repoInfo.workspaceInfo && packageRoot.startsWith(repoInfo.root)) {
-            return repoInfo;
-        }
-    }
-}
-async function getRepoInfoNoCache(cwd) {
-    const root = (0, _workspaceTools.getWorkspaceRoot)(cwd);
-    if (!root) {
-        throw new Error("Cannot initialize Repo class without a workspace root");
-    }
-    // Assuming the package-deps-hash package returns a map of files to hashes that are unordered
-    const unorderedRepoHashes = Object.fromEntries((0, _getPackageDepsJs.getPackageDeps)(root));
-    // Sorting repoHash by key because we want to consistent hashing based on the order of the files
-    const repoHashes = Object.keys(unorderedRepoHashes).sort((a, b)=>a.localeCompare(b)).reduce((obj, key)=>{
-        obj[key] = unorderedRepoHashes[key];
-        return obj;
-    }, {});
-    const workspaceInfo = (0, _workspaceTools.getWorkspaces)(root);
-    const parsedLock = await (0, _workspaceTools.parseLockFile)(root);
-    const packageHashes = (0, _createPackageHashesJs.createPackageHashes)(root, workspaceInfo, repoHashes);
-    const repoInfo = {
-        root,
-        workspaceInfo,
-        parsedLock,
-        repoHashes,
-        packageHashes
-    };
-    repoInfoCache.push(repoInfo);
-    return repoInfo;
-}
-// A promise to guarantee the getRepoInfo is done one at a time
-let oneAtATime = Promise.resolve();
-async function getRepoInfo(cwd) {
-    oneAtATime = oneAtATime.then(async ()=>{
-        const searchResult = searchRepoInfoCache(cwd);
-        if (searchResult) {
-            return searchResult;
-        }
-        return getRepoInfoNoCache(cwd);
-    });
-    return oneAtATime;
-}