@lage-run/hasher 0.1.1 → 0.1.2

package/lib/hashOfFiles.js

@@ -1,65 +1,71 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "generateHashOfFiles", {
+    enumerable: true,
+    get: ()=>generateHashOfFiles
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateHashOfFiles = void 0;
-const path_1 = __importStar(require("path"));
-const helpers_js_1 = require("./helpers.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
- */
+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 { repoHashes , root , packageHashes  } = repoInfo;
     const hashes = [];
-    const packageRelativeRoot = path_1.default.relative(root, packageRoot).replace(/\\/g, "/");
+    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]) {
+        for (const hash of packageHashes[packageRelativeRoot]){
             hashes.push(hash[0], hash[1]);
         }
-        return (0, helpers_js_1.hashStrings)(hashes);
-    }
-    else {
+        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_1.default.normalize(packageRoot) + path_1.sep;
-        const files = Object.keys(repoHashes).filter((f) => path_1.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]);
+        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 hashes1 = [];
+        for (const file of files){
+            hashes1.push(file, repoHashes[file]);
         }
-        return (0, helpers_js_1.hashStrings)(hashes);
+        return (0, _helpersJs.hashStrings)(hashes1);
     }
 }
-exports.generateHashOfFiles = generateHashOfFiles;
-//# sourceMappingURL=hashOfFiles.js.map

package/lib/hashOfPackage.js

@@ -1,52 +1,65 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageHash = exports.generateHashOfInternalPackages = void 0;
-const crypto_1 = __importDefault(require("crypto"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const resolveInternalDependencies_js_1 = require("./resolveInternalDependencies.js");
-const resolveExternalDependencies_js_1 = require("./resolveExternalDependencies.js");
-const hashOfFiles_js_1 = require("./hashOfFiles.js");
-const helpers_js_1 = require("./helpers.js");
+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_1.default.createHash("sha1");
-    internalPackages.forEach((pkg) => {
+    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");
 }
-exports.generateHashOfInternalPackages = generateHashOfInternalPackages;
 const memoization = {};
 async function getPackageHash(packageRoot, repoInfo) {
-    const { workspaceInfo, parsedLock } = repoInfo;
-    const memoizationKey = path_1.default.resolve(packageRoot);
+    const { workspaceInfo , parsedLock  } = repoInfo;
+    const memoizationKey = _path.default.resolve(packageRoot);
     if (memoization[memoizationKey]) {
         return memoization[memoizationKey];
     }
-    const { name, dependencies, devDependencies } = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packageRoot, "package.json"), "utf-8"));
+    const { name , dependencies , devDependencies  } = JSON.parse(_fs.default.readFileSync(_path.default.join(packageRoot, "package.json"), "utf-8"));
     const allDependencies = {
         ...dependencies,
-        ...devDependencies,
+        ...devDependencies
     };
-    const internalDependencies = (0, resolveInternalDependencies_js_1.resolveInternalDependencies)(allDependencies, workspaceInfo);
-    const externalDeoendencies = (0, resolveExternalDependencies_js_1.resolveExternalDependencies)(allDependencies, workspaceInfo, parsedLock);
-    const resolvedDependencies = [...internalDependencies, ...externalDeoendencies];
-    const filesHash = await (0, hashOfFiles_js_1.generateHashOfFiles)(packageRoot, repoInfo);
-    const dependenciesHash = (0, helpers_js_1.hashStrings)(resolvedDependencies);
+    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,
+        internalDependencies
     };
     memoization[memoizationKey] = packageHash;
     return packageHash;
 }
-exports.getPackageHash = getPackageHash;
-//# sourceMappingURL=hashOfPackage.js.map

package/lib/helpers.js

@@ -1,31 +1,47 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nameAtVersion = exports.getPackageRoot = exports.hashStrings = void 0;
-const path_1 = __importDefault(require("path"));
-const crypto_1 = __importDefault(require("crypto"));
-const find_up_1 = __importDefault(require("find-up"));
+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_1.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));
+    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");
 }
-exports.hashStrings = hashStrings;
 async function getPackageRoot(cwd) {
-    const packageRoot = await (0, find_up_1.default)("package.json", { cwd });
+    const packageRoot = await (0, _findUp.default)("package.json", {
+        cwd
+    });
     if (!packageRoot) {
         throw new Error(`Could not find package.json inside ${cwd}.`);
     }
-    return path_1.default.dirname(packageRoot);
+    return _path.default.dirname(packageRoot);
 }
-exports.getPackageRoot = getPackageRoot;
 function nameAtVersion(name, version) {
     return `${name}@${version}`;
 }
-exports.nameAtVersion = nameAtVersion;
-//# sourceMappingURL=helpers.js.map

package/lib/index.js

@@ -1,33 +1,41 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hasher = exports.addToQueue = void 0;
-const workspace_tools_1 = require("workspace-tools");
-const hashOfPackage_js_1 = require("./hashOfPackage.js");
-const helpers_js_1 = require("./helpers.js");
-const repoInfo_js_1 = require("./repoInfo.js");
+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, {
+    addToQueue: ()=>addToQueue,
+    Hasher: ()=>Hasher
+});
+const _workspaceTools = require("workspace-tools");
+const _hashOfPackageJs = require("./hashOfPackage.js");
+const _helpersJs = require("./helpers.js");
+const _repoInfoJs = _exportStar(require("./repoInfo.js"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}
 function isDone(done, packageName) {
-    return Boolean(done.find(({ name }) => name === packageName));
+    return Boolean(done.find(({ name  })=>name === packageName));
 }
 function isInQueue(queue, packagePath) {
     return queue.indexOf(packagePath) >= 0;
 }
 function addToQueue(dependencyNames, queue, done, workspaces) {
-    dependencyNames.forEach((name) => {
-        const dependencyPath = (0, workspace_tools_1.findWorkspacePath)(workspaces, name);
+    dependencyNames.forEach((name)=>{
+        const dependencyPath = (0, _workspaceTools.findWorkspacePath)(workspaces, name);
         if (dependencyPath) {
             if (!isDone(done, name) && !isInQueue(queue, dependencyPath)) {
                 queue.push(dependencyPath);
@@ -35,32 +43,33 @@ function addToQueue(dependencyNames, queue, done, workspaces) {
         }
     });
 }
-exports.addToQueue = addToQueue;
 class Hasher {
-    constructor(packageRoot) {
-        this.packageRoot = packageRoot;
-    }
     async createPackageHash(salt) {
-        const packageRoot = await (0, helpers_js_1.getPackageRoot)(this.packageRoot);
-        this.repoInfo = await (0, repoInfo_js_1.getRepoInfo)(packageRoot);
-        const { workspaceInfo } = this.repoInfo;
-        const queue = [packageRoot];
+        const packageRoot = await (0, _helpersJs.getPackageRoot)(this.packageRoot);
+        this.repoInfo = await (0, _repoInfoJs.getRepoInfo)(packageRoot);
+        const { workspaceInfo  } = this.repoInfo;
+        const queue = [
+            packageRoot
+        ];
         const done = [];
-        while (queue.length > 0) {
-            const packageRoot = queue.shift();
-            if (!packageRoot) {
+        while(queue.length > 0){
+            const packageRoot1 = queue.shift();
+            if (!packageRoot1) {
                 continue;
             }
-            const packageHash = await (0, hashOfPackage_js_1.getPackageHash)(packageRoot, this.repoInfo);
+            const packageHash = await (0, _hashOfPackageJs.getPackageHash)(packageRoot1, this.repoInfo);
             addToQueue(packageHash.internalDependencies, queue, done, workspaceInfo);
             done.push(packageHash);
         }
-        const internalPackagesHash = (0, hashOfPackage_js_1.generateHashOfInternalPackages)(done);
-        const buildCommandHash = (0, helpers_js_1.hashStrings)(salt);
-        const combinedHash = (0, helpers_js_1.hashStrings)([internalPackagesHash, buildCommandHash]);
+        const internalPackagesHash = (0, _hashOfPackageJs.generateHashOfInternalPackages)(done);
+        const buildCommandHash = (0, _helpersJs.hashStrings)(salt);
+        const combinedHash = (0, _helpersJs.hashStrings)([
+            internalPackagesHash,
+            buildCommandHash
+        ]);
         return combinedHash;
     }
+    constructor(packageRoot){
+        this.packageRoot = packageRoot;
+    }
 }
-exports.Hasher = Hasher;
-__exportStar(require("./repoInfo.js"), exports);
-//# sourceMappingURL=index.js.map

package/lib/repoInfo.js

@@ -1,61 +1,60 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRepoInfo = exports.getRepoInfoNoCache = void 0;
-const workspace_tools_1 = require("workspace-tools");
-const getPackageDeps_js_1 = require("./getPackageDeps.js");
-const createPackageHashes_js_1 = require("./createPackageHashes.js");
+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) {
+ */ function searchRepoInfoCache(packageRoot) {
+    for (const repoInfo of repoInfoCache){
         if (repoInfo.workspaceInfo && packageRoot.startsWith(repoInfo.root)) {
             return repoInfo;
         }
     }
 }
 async function getRepoInfoNoCache(cwd) {
-    const root = (0, workspace_tools_1.getWorkspaceRoot)(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, getPackageDeps_js_1.getPackageDeps)(root));
+    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) => {
+    const repoHashes = Object.keys(unorderedRepoHashes).sort((a, b)=>a.localeCompare(b)).reduce((obj, key)=>{
         obj[key] = unorderedRepoHashes[key];
         return obj;
     }, {});
-    const workspaceInfo = (0, workspace_tools_1.getWorkspaces)(root);
-    const parsedLock = await (0, workspace_tools_1.parseLockFile)(root);
-    const packageHashes = (0, createPackageHashes_js_1.createPackageHashes)(root, workspaceInfo, repoHashes);
+    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,
+        packageHashes
     };
     repoInfoCache.push(repoInfo);
     return repoInfo;
 }
-exports.getRepoInfoNoCache = getRepoInfoNoCache;
 // A promise to guarantee the getRepoInfo is done one at a time
 let oneAtATime = Promise.resolve();
-/**
- * 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
- */
 async function getRepoInfo(cwd) {
-    oneAtATime = oneAtATime.then(async () => {
+    oneAtATime = oneAtATime.then(async ()=>{
         const searchResult = searchRepoInfoCache(cwd);
         if (searchResult) {
             return searchResult;
@@ -64,5 +63,3 @@ async function getRepoInfo(cwd) {
     });
     return oneAtATime;
 }
-exports.getRepoInfo = getRepoInfo;
-//# sourceMappingURL=repoInfo.js.map

package/lib/resolveExternalDependencies.js

@@ -1,59 +1,69 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveExternalDependencies = exports.addToQueue = exports.filterExternalDependencies = void 0;
-const workspace_tools_1 = require("workspace-tools");
-const helpers_js_1 = require("./helpers.js");
+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, {
+    filterExternalDependencies: ()=>filterExternalDependencies,
+    addToQueue: ()=>addToQueue,
+    resolveExternalDependencies: ()=>resolveExternalDependencies
+});
+const _workspaceTools = require("workspace-tools");
+const _helpersJs = require("./helpers.js");
 function filterExternalDependencies(dependencies, workspaces) {
-    const workspacePackageNames = (0, workspace_tools_1.listOfWorkspacePackageNames)(workspaces);
+    const workspacePackageNames = (0, _workspaceTools.listOfWorkspacePackageNames)(workspaces);
     const externalDependencies = {};
-    Object.entries(dependencies).forEach(([name, versionRange]) => {
+    Object.entries(dependencies).forEach(([name, versionRange])=>{
         if (workspacePackageNames.indexOf(name) < 0) {
             externalDependencies[name] = versionRange;
         }
     });
     return externalDependencies;
 }
-exports.filterExternalDependencies = filterExternalDependencies;
 function isDone(done, key) {
     return done.indexOf(key) >= 0;
 }
 function isInQueue(queue, key) {
-    return Boolean(queue.find(([name, versionRange]) => (0, helpers_js_1.nameAtVersion)(name, versionRange) === key));
+    return Boolean(queue.find(([name, versionRange])=>(0, _helpersJs.nameAtVersion)(name, versionRange) === key));
 }
 function addToQueue(dependencies, done, queue) {
     if (dependencies) {
-        Object.entries(dependencies).forEach(([name, versionRange]) => {
-            const versionRangeSignature = (0, helpers_js_1.nameAtVersion)(name, versionRange);
+        Object.entries(dependencies).forEach(([name, versionRange])=>{
+            const versionRangeSignature = (0, _helpersJs.nameAtVersion)(name, versionRange);
             if (!isDone(done, versionRangeSignature) && !isInQueue(queue, versionRangeSignature)) {
-                queue.push([name, versionRange]);
+                queue.push([
+                    name,
+                    versionRange
+                ]);
             }
         });
     }
 }
-exports.addToQueue = addToQueue;
 function resolveExternalDependencies(allDependencies, workspaces, lockInfo) {
     const externalDependencies = filterExternalDependencies(allDependencies, workspaces);
     const done = [];
     const doneRange = [];
     const queue = Object.entries(externalDependencies);
-    while (queue.length > 0) {
+    while(queue.length > 0){
         const next = queue.shift();
         if (!next) {
             continue;
         }
         const [name, versionRange] = next;
-        doneRange.push((0, helpers_js_1.nameAtVersion)(name, versionRange));
-        const lockFileResult = (0, workspace_tools_1.queryLockFile)(name, versionRange, lockInfo);
+        doneRange.push((0, _helpersJs.nameAtVersion)(name, versionRange));
+        const lockFileResult = (0, _workspaceTools.queryLockFile)(name, versionRange, lockInfo);
         if (lockFileResult) {
-            const { version, dependencies } = lockFileResult;
+            const { version , dependencies  } = lockFileResult;
             addToQueue(dependencies, doneRange, queue);
-            done.push((0, helpers_js_1.nameAtVersion)(name, version));
-        }
-        else {
-            done.push((0, helpers_js_1.nameAtVersion)(name, versionRange));
+            done.push((0, _helpersJs.nameAtVersion)(name, version));
+        } else {
+            done.push((0, _helpersJs.nameAtVersion)(name, versionRange));
         }
     }
     return done;
 }
-exports.resolveExternalDependencies = resolveExternalDependencies;
-//# sourceMappingURL=resolveExternalDependencies.js.map

package/lib/resolveInternalDependencies.js

@@ -1,15 +1,23 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveInternalDependencies = exports.filterInternalDependencies = void 0;
-const workspace_tools_1 = require("workspace-tools");
+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, {
+    filterInternalDependencies: ()=>filterInternalDependencies,
+    resolveInternalDependencies: ()=>resolveInternalDependencies
+});
+const _workspaceTools = require("workspace-tools");
 function filterInternalDependencies(dependencies, workspaces) {
-    const workspacePackageNames = (0, workspace_tools_1.listOfWorkspacePackageNames)(workspaces);
-    return Object.keys(dependencies).filter((dependency) => workspacePackageNames.indexOf(dependency) >= 0);
+    const workspacePackageNames = (0, _workspaceTools.listOfWorkspacePackageNames)(workspaces);
+    return Object.keys(dependencies).filter((dependency)=>workspacePackageNames.indexOf(dependency) >= 0);
 }
-exports.filterInternalDependencies = filterInternalDependencies;
 function resolveInternalDependencies(allDependencies, workspaces) {
     const dependencyNames = filterInternalDependencies(allDependencies, workspaces);
     return dependencyNames;
 }
-exports.resolveInternalDependencies = resolveInternalDependencies;
-//# sourceMappingURL=resolveInternalDependencies.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/hasher",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Hasher for Lage Targets",
   "repository": {
     "url": "https://github.com/microsoft/lage"
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "execa": "5.1.1",
-    "workspace-tools": "0.29.0",
+    "workspace-tools": "0.29.1",
     "find-up": "^5.0.0"
   },
   "devDependencies": {

package/lib/__fixtures__/config/backfill.config.js

@@ -1,5 +0,0 @@
-"use strict";
-module.exports = {
-    internalCacheFolder: "foo",
-};
-//# sourceMappingURL=backfill.config.js.map

package/lib/__fixtures__/config/backfill.config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill.config.js","sourceRoot":"","sources":["../../../src/__fixtures__/config/backfill.config.js"],"names":[],"mappings":";AAAA,MAAM,CAAC,OAAO,GAAG;IACf,mBAAmB,EAAE,KAAK;CAC3B,CAAC"}