backfill 6.4.3 → 6.4.5

package/lib/api.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { Writable } from "stream";
 import { type Config, type ICacheStorage } from "backfill-config";
 import { type Logger, type LogLevel } from "backfill-logger";
@@ -8,4 +7,3 @@ export declare function computeHash(cwd: string, logger: Logger, hashSalt?: stri
 export declare function computeHashOfOutput(cwd: string, logger: Logger, config?: Pick<Config, "packageRoot">): Promise<string>;
 export declare function fetch(cwd: string, hash: string, logger: Logger, config?: Pick<Config, "cacheStorageConfig" | "internalCacheFolder" | "incrementalCaching">): Promise<boolean>;
 export declare function put(cwd: string, hash: string, logger: Logger, config?: Pick<Config, "cacheStorageConfig" | "internalCacheFolder" | "outputGlob" | "incrementalCaching">): Promise<void>;
-//# sourceMappingURL=api.d.ts.map

package/lib/api.js

@@ -1,64 +1,88 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.put = exports.fetch = exports.computeHashOfOutput = exports.computeHash = exports.makeLogger = void 0;
-const os_1 = require("os");
-const backfill_config_1 = require("backfill-config");
-const backfill_logger_1 = require("backfill-logger");
-const backfill_hasher_1 = require("backfill-hasher");
-const backfill_cache_1 = require("backfill-cache");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get computeHash () {
+        return computeHash;
+    },
+    get computeHashOfOutput () {
+        return computeHashOfOutput;
+    },
+    get fetch () {
+        return fetch;
+    },
+    get makeLogger () {
+        return makeLogger;
+    },
+    get put () {
+        return put;
+    }
+});
+const _os = require("os");
+const _backfillconfig = require("backfill-config");
+const _backfilllogger = require("backfill-logger");
+const _backfillhasher = require("backfill-hasher");
+const _backfillcache = require("backfill-cache");
 function makeConsole(stdout, stderr) {
     return {
-        info(...args) {
-            stdout.write(args.join(" ") + os_1.EOL);
-        },
-        warn(...args) {
-            stderr.write(args.join(" ") + os_1.EOL);
+        info (...args) {
+            stdout.write(args.join(" ") + _os.EOL);
         },
-        error(...args) {
-            stderr.write(args.join(" ") + os_1.EOL);
+        warn (...args) {
+            stderr.write(args.join(" ") + _os.EOL);
         },
+        error (...args) {
+            stderr.write(args.join(" ") + _os.EOL);
+        }
     };
 }
 function makeLogger(logLevel, stdout, stderr) {
-    return (0, backfill_logger_1.makeLogger)(logLevel, { console: makeConsole(stdout, stderr) });
+    return (0, _backfilllogger.makeLogger)(logLevel, {
+        console: makeConsole(stdout, stderr)
+    });
 }
-exports.makeLogger = makeLogger;
 async function computeHash(cwd, logger, hashSalt, config) {
     if (!config) {
-        config = (0, backfill_config_1.createConfig)(logger, cwd);
+        config = (0, _backfillconfig.createConfig)(logger, cwd);
     }
     const { packageRoot } = config;
-    const hasher = new backfill_hasher_1.Hasher({ packageRoot }, logger);
+    const hasher = new _backfillhasher.Hasher({
+        packageRoot
+    }, logger);
     const hash = await hasher.createPackageHash(hashSalt || "");
     return hash;
 }
-exports.computeHash = computeHash;
 async function computeHashOfOutput(cwd, logger, config) {
     if (!config) {
-        config = (0, backfill_config_1.createConfig)(logger, cwd);
+        config = (0, _backfillconfig.createConfig)(logger, cwd);
     }
     const { packageRoot } = config;
-    const hasher = new backfill_hasher_1.Hasher({ packageRoot }, logger);
+    const hasher = new _backfillhasher.Hasher({
+        packageRoot
+    }, logger);
     const hash = await hasher.hashOfOutput();
     return hash;
 }
-exports.computeHashOfOutput = computeHashOfOutput;
 async function fetch(cwd, hash, logger, config) {
     if (!config) {
-        config = (0, backfill_config_1.createConfig)(logger, cwd);
+        config = (0, _backfillconfig.createConfig)(logger, cwd);
     }
     const { cacheStorageConfig, internalCacheFolder, incrementalCaching } = config;
-    const cacheStorage = (0, backfill_cache_1.getCacheStorageProvider)(cacheStorageConfig, internalCacheFolder, logger, cwd, incrementalCaching);
+    const cacheStorage = (0, _backfillcache.getCacheStorageProvider)(cacheStorageConfig, internalCacheFolder, logger, cwd, incrementalCaching);
     return await cacheStorage.fetch(hash);
 }
-exports.fetch = fetch;
 async function put(cwd, hash, logger, config) {
     if (!config) {
-        config = (0, backfill_config_1.createConfig)(logger, cwd);
+        config = (0, _backfillconfig.createConfig)(logger, cwd);
     }
-    const { cacheStorageConfig, internalCacheFolder, outputGlob, incrementalCaching, } = config;
-    const cacheStorage = (0, backfill_cache_1.getCacheStorageProvider)(cacheStorageConfig, internalCacheFolder, logger, cwd, incrementalCaching);
+    const { cacheStorageConfig, internalCacheFolder, outputGlob, incrementalCaching } = config;
+    const cacheStorage = (0, _backfillcache.getCacheStorageProvider)(cacheStorageConfig, internalCacheFolder, logger, cwd, incrementalCaching);
     await cacheStorage.put(hash, outputGlob);
 }
-exports.put = put;
-//# sourceMappingURL=data:application/json;base64,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

package/lib/api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api.ts"],"sourcesContent":["import type { Writable } from \"stream\";\nimport { EOL } from \"os\";\n\nimport { createConfig, type Config, type ICacheStorage } from \"backfill-config\";\nimport {\n  type Logger,\n  makeLogger as makeLoggerInternal,\n  type Console,\n  type LogLevel,\n} from \"backfill-logger\";\nimport { Hasher } from \"backfill-hasher\";\nimport { getCacheStorageProvider } from \"backfill-cache\";\n\nexport type { Config, ICacheStorage };\n\nfunction makeConsole(stdout: Writable, stderr: Writable): Console {\n  return {\n    info(...args: string[]): void {\n      stdout.write(args.join(\" \") + EOL);\n    },\n    warn(...args: string[]): void {\n      stderr.write(args.join(\" \") + EOL);\n    },\n    error(...args: string[]): void {\n      stderr.write(args.join(\" \") + EOL);\n    },\n  };\n}\n\nexport function makeLogger(\n  logLevel: LogLevel,\n  stdout: Writable,\n  stderr: Writable\n): Logger {\n  return makeLoggerInternal(logLevel, { console: makeConsole(stdout, stderr) });\n}\n\nexport async function computeHash(\n  cwd: string,\n  logger: Logger,\n  hashSalt?: string,\n  config?: Pick<Config, \"packageRoot\">\n): Promise<string> {\n  if (!config) {\n    config = createConfig(logger, cwd);\n  }\n  const { packageRoot } = config;\n  const hasher = new Hasher({ packageRoot }, logger);\n\n  const hash = await hasher.createPackageHash(hashSalt || \"\");\n  return hash;\n}\n\nexport async function computeHashOfOutput(\n  cwd: string,\n  logger: Logger,\n  config?: Pick<Config, \"packageRoot\">\n): Promise<string> {\n  if (!config) {\n    config = createConfig(logger, cwd);\n  }\n  const { packageRoot } = config;\n  const hasher = new Hasher({ packageRoot }, logger);\n  const hash = await hasher.hashOfOutput();\n  return hash;\n}\n\nexport async function fetch(\n  cwd: string,\n  hash: string,\n  logger: Logger,\n  config?: Pick<\n    Config,\n    \"cacheStorageConfig\" | \"internalCacheFolder\" | \"incrementalCaching\"\n  >\n): Promise<boolean> {\n  if (!config) {\n    config = createConfig(logger, cwd);\n  }\n  const { cacheStorageConfig, internalCacheFolder, incrementalCaching } =\n    config;\n  const cacheStorage = getCacheStorageProvider(\n    cacheStorageConfig,\n    internalCacheFolder,\n    logger,\n    cwd,\n    incrementalCaching\n  );\n  return await cacheStorage.fetch(hash);\n}\n\nexport async function put(\n  cwd: string,\n  hash: string,\n  logger: Logger,\n  config?: Pick<\n    Config,\n    | \"cacheStorageConfig\"\n    | \"internalCacheFolder\"\n    | \"outputGlob\"\n    | \"incrementalCaching\"\n  >\n): Promise<void> {\n  if (!config) {\n    config = createConfig(logger, cwd);\n  }\n  const {\n    cacheStorageConfig,\n    internalCacheFolder,\n    outputGlob,\n    incrementalCaching,\n  } = config;\n  const cacheStorage = getCacheStorageProvider(\n    cacheStorageConfig,\n    internalCacheFolder,\n    logger,\n    cwd,\n    incrementalCaching\n  );\n  await cacheStorage.put(hash, outputGlob);\n}\n"],"names":["computeHash","computeHashOfOutput","fetch","makeLogger","put","makeConsole","stdout","stderr","info","args","write","join","EOL","warn","error","logLevel","makeLoggerInternal","console","cwd","logger","hashSalt","config","createConfig","packageRoot","hasher","Hasher","hash","createPackageHash","hashOfOutput","cacheStorageConfig","internalCacheFolder","incrementalCaching","cacheStorage","getCacheStorageProvider","outputGlob"],"mappings":";;;;;;;;;;;QAqCsBA;eAAAA;;QAgBAC;eAAAA;;QAcAC;eAAAA;;QAtCNC;eAAAA;;QA8DMC;eAAAA;;;oBA1FF;gCAE0C;gCAMvD;gCACgB;+BACiB;AAIxC,SAASC,YAAYC,MAAgB,EAAEC,MAAgB;IACrD,OAAO;QACLC,MAAK,GAAGC,IAAc;YACpBH,OAAOI,KAAK,CAACD,KAAKE,IAAI,CAAC,OAAOC,OAAG;QACnC;QACAC,MAAK,GAAGJ,IAAc;YACpBF,OAAOG,KAAK,CAACD,KAAKE,IAAI,CAAC,OAAOC,OAAG;QACnC;QACAE,OAAM,GAAGL,IAAc;YACrBF,OAAOG,KAAK,CAACD,KAAKE,IAAI,CAAC,OAAOC,OAAG;QACnC;IACF;AACF;AAEO,SAAST,WACdY,QAAkB,EAClBT,MAAgB,EAChBC,MAAgB;IAEhB,OAAOS,IAAAA,0BAAkB,EAACD,UAAU;QAAEE,SAASZ,YAAYC,QAAQC;IAAQ;AAC7E;AAEO,eAAeP,YACpBkB,GAAW,EACXC,MAAc,EACdC,QAAiB,EACjBC,MAAoC;IAEpC,IAAI,CAACA,QAAQ;QACXA,SAASC,IAAAA,4BAAY,EAACH,QAAQD;IAChC;IACA,MAAM,EAAEK,WAAW,EAAE,GAAGF;IACxB,MAAMG,SAAS,IAAIC,sBAAM,CAAC;QAAEF;IAAY,GAAGJ;IAE3C,MAAMO,OAAO,MAAMF,OAAOG,iBAAiB,CAACP,YAAY;IACxD,OAAOM;AACT;AAEO,eAAezB,oBACpBiB,GAAW,EACXC,MAAc,EACdE,MAAoC;IAEpC,IAAI,CAACA,QAAQ;QACXA,SAASC,IAAAA,4BAAY,EAACH,QAAQD;IAChC;IACA,MAAM,EAAEK,WAAW,EAAE,GAAGF;IACxB,MAAMG,SAAS,IAAIC,sBAAM,CAAC;QAAEF;IAAY,GAAGJ;IAC3C,MAAMO,OAAO,MAAMF,OAAOI,YAAY;IACtC,OAAOF;AACT;AAEO,eAAexB,MACpBgB,GAAW,EACXQ,IAAY,EACZP,MAAc,EACdE,MAGC;IAED,IAAI,CAACA,QAAQ;QACXA,SAASC,IAAAA,4BAAY,EAACH,QAAQD;IAChC;IACA,MAAM,EAAEW,kBAAkB,EAAEC,mBAAmB,EAAEC,kBAAkB,EAAE,GACnEV;IACF,MAAMW,eAAeC,IAAAA,sCAAuB,EAC1CJ,oBACAC,qBACAX,QACAD,KACAa;IAEF,OAAO,MAAMC,aAAa9B,KAAK,CAACwB;AAClC;AAEO,eAAetB,IACpBc,GAAW,EACXQ,IAAY,EACZP,MAAc,EACdE,MAMC;IAED,IAAI,CAACA,QAAQ;QACXA,SAASC,IAAAA,4BAAY,EAACH,QAAQD;IAChC;IACA,MAAM,EACJW,kBAAkB,EAClBC,mBAAmB,EACnBI,UAAU,EACVH,kBAAkB,EACnB,GAAGV;IACJ,MAAMW,eAAeC,IAAAA,sCAAuB,EAC1CJ,oBACAC,qBACAX,QACAD,KACAa;IAEF,MAAMC,aAAa5B,GAAG,CAACsB,MAAMQ;AAC/B"}

package/lib/audit.d.ts

@@ -1,7 +1,6 @@
-import { Logger } from "backfill-logger";
+import type { Logger } from "backfill-logger";
 export declare function initializeWatcher(packageRoot: string, internalCacheFolder: string, logFolder: string, outputGlob: string[], logger: Logger): void;
 export declare const sideEffectWarningString = "[audit] The following files got changed outside of the scope of the folder to be cached:";
 export declare const sideEffectCallToActionString = "[audit] You should make sure that these changes are non-essential, as they would not be brought back on a cache-hit.";
 export declare const noSideEffectString = "[audit] All observed file changes were within the scope of the folder to be cached.";
 export declare function closeWatcher(logger: Logger): Promise<void>;
-//# sourceMappingURL=audit.d.ts.map

package/lib/audit.js

@@ -1,30 +1,64 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.closeWatcher = exports.noSideEffectString = exports.sideEffectCallToActionString = exports.sideEffectWarningString = exports.initializeWatcher = void 0;
-const path_1 = __importDefault(require("path"));
-const chokidar_1 = __importDefault(require("chokidar"));
-const find_up_1 = __importDefault(require("find-up"));
-const anymatch_1 = __importDefault(require("anymatch"));
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get closeWatcher () {
+        return closeWatcher;
+    },
+    get initializeWatcher () {
+        return initializeWatcher;
+    },
+    get noSideEffectString () {
+        return noSideEffectString;
+    },
+    get sideEffectCallToActionString () {
+        return sideEffectCallToActionString;
+    },
+    get sideEffectWarningString () {
+        return sideEffectWarningString;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _chokidar = /*#__PURE__*/ _interop_require_default(require("chokidar"));
+const _findup = /*#__PURE__*/ _interop_require_default(require("find-up"));
+const _anymatch = /*#__PURE__*/ _interop_require_default(require("anymatch"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 let changedFilesOutsideScope = [];
 let changedFilesInsideScope = [];
 let watcher;
 function getGitRepositoryRoot(packageRoot) {
     // .git is typically a folder but will be a file in a worktree
-    const nearestGitInfo = find_up_1.default.sync(".git", { cwd: packageRoot, type: "directory" }) ||
-        find_up_1.default.sync(".git", { cwd: packageRoot, type: "file" });
+    const nearestGitInfo = _findup.default.sync(".git", {
+        cwd: packageRoot,
+        type: "directory"
+    }) || _findup.default.sync(".git", {
+        cwd: packageRoot,
+        type: "file"
+    });
     if (nearestGitInfo) {
         // Return the parent folder of some/path/.git
-        return path_1.default.join(nearestGitInfo, "..");
+        return _path.default.join(nearestGitInfo, "..");
     }
     return packageRoot;
 }
 function addGlobstars(globPatterns) {
-    const folders = globPatterns.map((p) => path_1.default.posix.join("**", p, "**", "*"));
-    const files = globPatterns.map((p) => path_1.default.posix.join("**", p));
-    return [...folders, ...files];
+    const folders = globPatterns.map((p)=>_path.default.posix.join("**", p, "**", "*"));
+    const files = globPatterns.map((p)=>_path.default.posix.join("**", p));
+    return [
+        ...folders,
+        ...files
+    ];
 }
 function initializeWatcher(packageRoot, internalCacheFolder, logFolder, outputGlob, logger) {
     // Trying to find the git root and using it as an approximation of code boundary
@@ -40,34 +74,30 @@ function initializeWatcher(packageRoot, internalCacheFolder, logFolder, outputGl
         ".git",
         ".cache",
         logFolder,
-        internalCacheFolder,
+        internalCacheFolder
     ]);
-    watcher = chokidar_1.default
-        .watch("**", {
+    watcher = _chokidar.default.watch("**", {
         ignored: ignoreGlobs,
         cwd: repositoryRoot,
         persistent: true,
         ignoreInitial: true,
         followSymlinks: false,
-        usePolling: true,
-    })
-        .on("all", (event, filePath) => {
+        usePolling: true
+    }).on("all", (event, filePath)=>{
         const logLine = `${filePath} (${event})`;
         logger.silly(`[audit] File change: ${logLine}`);
-        if (!(0, anymatch_1.default)(outputGlob.map((glob) => path_1.default.posix.join("**", glob)), filePath)) {
+        if (!(0, _anymatch.default)(outputGlob.map((glob)=>_path.default.posix.join("**", glob)), filePath)) {
             changedFilesOutsideScope.push(logLine);
-        }
-        else {
+        } else {
             changedFilesInsideScope.push(logLine);
         }
     });
 }
-exports.initializeWatcher = initializeWatcher;
-exports.sideEffectWarningString = "[audit] The following files got changed outside of the scope of the folder to be cached:";
-exports.sideEffectCallToActionString = "[audit] You should make sure that these changes are non-essential, as they would not be brought back on a cache-hit.";
-exports.noSideEffectString = "[audit] All observed file changes were within the scope of the folder to be cached.";
+const sideEffectWarningString = "[audit] The following files got changed outside of the scope of the folder to be cached:";
+const sideEffectCallToActionString = "[audit] You should make sure that these changes are non-essential, as they would not be brought back on a cache-hit.";
+const noSideEffectString = "[audit] All observed file changes were within the scope of the folder to be cached.";
 async function delay(time) {
-    return new Promise((resolve) => {
+    return new Promise((resolve)=>{
         setTimeout(resolve, time);
     });
 }
@@ -75,14 +105,11 @@ async function closeWatcher(logger) {
     // Wait for one second before closing, giving time for file changes to propagate
     await delay(1000);
     if (changedFilesOutsideScope.length > 0) {
-        logger.warn(exports.sideEffectWarningString);
-        changedFilesOutsideScope.forEach((file) => logger.warn(`- ${file}`));
-        logger.warn(exports.sideEffectCallToActionString);
-    }
-    else {
-        logger.info(exports.noSideEffectString);
+        logger.warn(sideEffectWarningString);
+        changedFilesOutsideScope.forEach((file)=>logger.warn(`- ${file}`));
+        logger.warn(sideEffectCallToActionString);
+    } else {
+        logger.info(noSideEffectString);
     }
-    watcher.close();
+    await watcher.close();
 }
-exports.closeWatcher = closeWatcher;
-//# sourceMappingURL=data:application/json;base64,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

package/lib/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/audit.ts"],"sourcesContent":["import path from \"path\";\nimport chokidar from \"chokidar\";\nimport findUp from \"find-up\";\nimport anymatch from \"anymatch\";\n\nimport type { Logger } from \"backfill-logger\";\n\nlet changedFilesOutsideScope: string[] = [];\nlet changedFilesInsideScope: string[] = [];\n\nlet watcher: chokidar.FSWatcher;\n\nfunction getGitRepositoryRoot(packageRoot: string) {\n  // .git is typically a folder but will be a file in a worktree\n  const nearestGitInfo =\n    findUp.sync(\".git\", { cwd: packageRoot, type: \"directory\" }) ||\n    findUp.sync(\".git\", { cwd: packageRoot, type: \"file\" });\n\n  if (nearestGitInfo) {\n    // Return the parent folder of some/path/.git\n    return path.join(nearestGitInfo, \"..\");\n  }\n\n  return packageRoot;\n}\n\nfunction addGlobstars(globPatterns: string[]): string[] {\n  const folders = globPatterns.map((p) => path.posix.join(\"**\", p, \"**\", \"*\"));\n  const files = globPatterns.map((p) => path.posix.join(\"**\", p));\n\n  return [...folders, ...files];\n}\n\nexport function initializeWatcher(\n  packageRoot: string,\n  internalCacheFolder: string,\n  logFolder: string,\n  outputGlob: string[],\n  logger: Logger\n): void {\n  // Trying to find the git root and using it as an approximation of code boundary\n  const repositoryRoot = getGitRepositoryRoot(packageRoot);\n\n  // Empty the arrays\n  changedFilesOutsideScope = [];\n  changedFilesInsideScope = [];\n\n  logger.info(\"Running in AUDIT mode\");\n  logger.info(`[audit] Watching file changes in: ${repositoryRoot}`);\n  logger.info(`[audit] Backfill will cache folder: ${outputGlob}`);\n\n  // Define globs\n  const ignoreGlobs = addGlobstars([\n    \".git\",\n    \".cache\",\n    logFolder,\n    internalCacheFolder,\n  ]);\n  watcher = chokidar\n    .watch(\"**\", {\n      ignored: ignoreGlobs,\n      cwd: repositoryRoot,\n      persistent: true,\n      ignoreInitial: true,\n      followSymlinks: false,\n      usePolling: true,\n    })\n    .on(\"all\", (event, filePath) => {\n      const logLine = `${filePath} (${event})`;\n      logger.silly(`[audit] File change: ${logLine}`);\n\n      if (\n        !anymatch(\n          outputGlob.map((glob) => path.posix.join(\"**\", glob)),\n          filePath\n        )\n      ) {\n        changedFilesOutsideScope.push(logLine);\n      } else {\n        changedFilesInsideScope.push(logLine);\n      }\n    });\n}\n\nexport const sideEffectWarningString =\n  \"[audit] The following files got changed outside of the scope of the folder to be cached:\";\nexport const sideEffectCallToActionString =\n  \"[audit] You should make sure that these changes are non-essential, as they would not be brought back on a cache-hit.\";\nexport const noSideEffectString =\n  \"[audit] All observed file changes were within the scope of the folder to be cached.\";\n\nasync function delay(time: number) {\n  return new Promise((resolve) => {\n    setTimeout(resolve, time);\n  });\n}\n\nexport async function closeWatcher(logger: Logger): Promise<void> {\n  // Wait for one second before closing, giving time for file changes to propagate\n  await delay(1000);\n\n  if (changedFilesOutsideScope.length > 0) {\n    logger.warn(sideEffectWarningString);\n    changedFilesOutsideScope.forEach((file) => logger.warn(`- ${file}`));\n    logger.warn(sideEffectCallToActionString);\n  } else {\n    logger.info(noSideEffectString);\n  }\n\n  await watcher.close();\n}\n"],"names":["closeWatcher","initializeWatcher","noSideEffectString","sideEffectCallToActionString","sideEffectWarningString","changedFilesOutsideScope","changedFilesInsideScope","watcher","getGitRepositoryRoot","packageRoot","nearestGitInfo","findUp","sync","cwd","type","path","join","addGlobstars","globPatterns","folders","map","p","posix","files","internalCacheFolder","logFolder","outputGlob","logger","repositoryRoot","info","ignoreGlobs","chokidar","watch","ignored","persistent","ignoreInitial","followSymlinks","usePolling","on","event","filePath","logLine","silly","anymatch","glob","push","delay","time","Promise","resolve","setTimeout","length","warn","forEach","file","close"],"mappings":";;;;;;;;;;;QAiGsBA;eAAAA;;QAhENC;eAAAA;;QAuDHC;eAAAA;;QAFAC;eAAAA;;QAFAC;eAAAA;;;6DApFI;iEACI;+DACF;iEACE;;;;;;AAIrB,IAAIC,2BAAqC,EAAE;AAC3C,IAAIC,0BAAoC,EAAE;AAE1C,IAAIC;AAEJ,SAASC,qBAAqBC,WAAmB;IAC/C,8DAA8D;IAC9D,MAAMC,iBACJC,eAAM,CAACC,IAAI,CAAC,QAAQ;QAAEC,KAAKJ;QAAaK,MAAM;IAAY,MAC1DH,eAAM,CAACC,IAAI,CAAC,QAAQ;QAAEC,KAAKJ;QAAaK,MAAM;IAAO;IAEvD,IAAIJ,gBAAgB;QAClB,6CAA6C;QAC7C,OAAOK,aAAI,CAACC,IAAI,CAACN,gBAAgB;IACnC;IAEA,OAAOD;AACT;AAEA,SAASQ,aAAaC,YAAsB;IAC1C,MAAMC,UAAUD,aAAaE,GAAG,CAAC,CAACC,IAAMN,aAAI,CAACO,KAAK,CAACN,IAAI,CAAC,MAAMK,GAAG,MAAM;IACvE,MAAME,QAAQL,aAAaE,GAAG,CAAC,CAACC,IAAMN,aAAI,CAACO,KAAK,CAACN,IAAI,CAAC,MAAMK;IAE5D,OAAO;WAAIF;WAAYI;KAAM;AAC/B;AAEO,SAAStB,kBACdQ,WAAmB,EACnBe,mBAA2B,EAC3BC,SAAiB,EACjBC,UAAoB,EACpBC,MAAc;IAEd,gFAAgF;IAChF,MAAMC,iBAAiBpB,qBAAqBC;IAE5C,mBAAmB;IACnBJ,2BAA2B,EAAE;IAC7BC,0BAA0B,EAAE;IAE5BqB,OAAOE,IAAI,CAAC;IACZF,OAAOE,IAAI,CAAC,CAAC,kCAAkC,EAAED,gBAAgB;IACjED,OAAOE,IAAI,CAAC,CAAC,oCAAoC,EAAEH,YAAY;IAE/D,eAAe;IACf,MAAMI,cAAcb,aAAa;QAC/B;QACA;QACAQ;QACAD;KACD;IACDjB,UAAUwB,iBAAQ,CACfC,KAAK,CAAC,MAAM;QACXC,SAASH;QACTjB,KAAKe;QACLM,YAAY;QACZC,eAAe;QACfC,gBAAgB;QAChBC,YAAY;IACd,GACCC,EAAE,CAAC,OAAO,CAACC,OAAOC;QACjB,MAAMC,UAAU,GAAGD,SAAS,EAAE,EAAED,MAAM,CAAC,CAAC;QACxCZ,OAAOe,KAAK,CAAC,CAAC,qBAAqB,EAAED,SAAS;QAE9C,IACE,CAACE,IAAAA,iBAAQ,EACPjB,WAAWN,GAAG,CAAC,CAACwB,OAAS7B,aAAI,CAACO,KAAK,CAACN,IAAI,CAAC,MAAM4B,QAC/CJ,WAEF;YACAnC,yBAAyBwC,IAAI,CAACJ;QAChC,OAAO;YACLnC,wBAAwBuC,IAAI,CAACJ;QAC/B;IACF;AACJ;AAEO,MAAMrC,0BACX;AACK,MAAMD,+BACX;AACK,MAAMD,qBACX;AAEF,eAAe4C,MAAMC,IAAY;IAC/B,OAAO,IAAIC,QAAQ,CAACC;QAClBC,WAAWD,SAASF;IACtB;AACF;AAEO,eAAe/C,aAAa2B,MAAc;IAC/C,gFAAgF;IAChF,MAAMmB,MAAM;IAEZ,IAAIzC,yBAAyB8C,MAAM,GAAG,GAAG;QACvCxB,OAAOyB,IAAI,CAAChD;QACZC,yBAAyBgD,OAAO,CAAC,CAACC,OAAS3B,OAAOyB,IAAI,CAAC,CAAC,EAAE,EAAEE,MAAM;QAClE3B,OAAOyB,IAAI,CAACjD;IACd,OAAO;QACLwB,OAAOE,IAAI,CAAC3B;IACd;IAEA,MAAMK,QAAQgD,KAAK;AACrB"}

package/lib/commandRunner.d.ts

@@ -1,7 +1,6 @@
 import execa from "execa";
-import { Logger } from "backfill-logger";
-export declare type ExecaReturns = execa.ExecaChildProcess;
-export declare type BuildCommand = () => Promise<ExecaReturns | void>;
+import type { Logger } from "backfill-logger";
+export type ExecaReturns = execa.ExecaChildProcess;
+export type BuildCommand = () => Promise<ExecaReturns | void>;
 export declare function getRawBuildCommand(): string;
 export declare function createBuildCommand(buildCommand: (string | number)[], clearOutput: boolean, outputGlob: string[], logger: Logger): () => Promise<ExecaReturns | void>;
-//# sourceMappingURL=commandRunner.d.ts.map

package/lib/commandRunner.js

@@ -1,41 +1,54 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBuildCommand = exports.getRawBuildCommand = void 0;
-const execa_1 = __importDefault(require("execa"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const globby_1 = __importDefault(require("globby"));
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createBuildCommand () {
+        return createBuildCommand;
+    },
+    get getRawBuildCommand () {
+        return getRawBuildCommand;
+    }
+});
+const _execa = /*#__PURE__*/ _interop_require_default(require("execa"));
+const _fsextra = /*#__PURE__*/ _interop_require_default(require("fs-extra"));
+const _globby = require("@lage-run/globby");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function getRawBuildCommand() {
     return process.argv.slice(2).join(" ");
 }
-exports.getRawBuildCommand = getRawBuildCommand;
 function createBuildCommand(buildCommand, clearOutput, outputGlob, logger) {
-    return async () => {
+    return async ()=>{
         const parsedBuildCommand = buildCommand.join(" ");
         if (!parsedBuildCommand) {
             throw new Error("Command not provided");
         }
         if (clearOutput) {
-            const filesToClear = globby_1.default.sync(outputGlob);
-            await Promise.all(filesToClear.map(async (file) => await fs_extra_1.default.remove(file)));
+            const filesToClear = (0, _globby.glob)(outputGlob);
+            await Promise.all(filesToClear.map(async (file)=>await _fsextra.default.remove(file)));
         }
         try {
             // Set up runner
             const tracer = logger.setTime("buildTime");
-            const runner = (0, execa_1.default)(parsedBuildCommand, {
-                shell: true,
+            const runner = (0, _execa.default)(parsedBuildCommand, {
+                shell: true
             });
             logger.pipeProcessOutput(runner.stdout, runner.stderr);
             await runner;
             tracer.stop();
-        }
-        catch (e) {
+        } catch (e) {
             logger.error(`Failed while running: "${parsedBuildCommand}"`);
             throw e;
         }
     };
 }
-exports.createBuildCommand = createBuildCommand;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZFJ1bm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb21tYW5kUnVubmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtEQUEwQjtBQUMxQix3REFBMEI7QUFDMUIsb0RBQTRCO0FBTzVCLFNBQWdCLGtCQUFrQjtJQUNoQyxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUN6QyxDQUFDO0FBRkQsZ0RBRUM7QUFFRCxTQUFnQixrQkFBa0IsQ0FDaEMsWUFBaUMsRUFDakMsV0FBb0IsRUFDcEIsVUFBb0IsRUFDcEIsTUFBYztJQUVkLE9BQU8sS0FBSyxJQUFrQyxFQUFFO1FBQzlDLE1BQU0sa0JBQWtCLEdBQUcsWUFBWSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUVsRCxJQUFJLENBQUMsa0JBQWtCLEVBQUU7WUFDdkIsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO1NBQ3pDO1FBRUQsSUFBSSxXQUFXLEVBQUU7WUFDZixNQUFNLFlBQVksR0FBRyxnQkFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUM3QyxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQ2YsWUFBWSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxNQUFNLGtCQUFFLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQ3hELENBQUM7U0FDSDtRQUVELElBQUk7WUFDRixnQkFBZ0I7WUFDaEIsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztZQUMzQyxNQUFNLE1BQU0sR0FBRyxJQUFBLGVBQUssRUFBQyxrQkFBa0IsRUFBRTtnQkFDdkMsS0FBSyxFQUFFLElBQUk7YUFDWixDQUFDLENBQUM7WUFFSCxNQUFNLENBQUMsaUJBQWlCLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7WUFFdkQsTUFBTSxNQUFNLENBQUM7WUFDYixNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7U0FDZjtRQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ1YsTUFBTSxDQUFDLEtBQUssQ0FBQywwQkFBMEIsa0JBQWtCLEdBQUcsQ0FBQyxDQUFDO1lBQzlELE1BQU0sQ0FBQyxDQUFDO1NBQ1Q7SUFDSCxDQUFDLENBQUM7QUFDSixDQUFDO0FBcENELGdEQW9DQyJ9

package/lib/commandRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commandRunner.ts"],"sourcesContent":["import execa from \"execa\";\nimport fs from \"fs-extra\";\nimport { glob } from \"@lage-run/globby\";\n\nimport type { Logger } from \"backfill-logger\";\n\nexport type ExecaReturns = execa.ExecaChildProcess;\nexport type BuildCommand = () => Promise<ExecaReturns | void>;\n\nexport function getRawBuildCommand(): string {\n  return process.argv.slice(2).join(\" \");\n}\n\nexport function createBuildCommand(\n  buildCommand: (string | number)[],\n  clearOutput: boolean,\n  outputGlob: string[],\n  logger: Logger\n): () => Promise<ExecaReturns | void> {\n  return async (): Promise<ExecaReturns | void> => {\n    const parsedBuildCommand = buildCommand.join(\" \");\n\n    if (!parsedBuildCommand) {\n      throw new Error(\"Command not provided\");\n    }\n\n    if (clearOutput) {\n      const filesToClear = glob(outputGlob);\n      await Promise.all(\n        filesToClear.map(async (file) => await fs.remove(file))\n      );\n    }\n\n    try {\n      // Set up runner\n      const tracer = logger.setTime(\"buildTime\");\n      const runner = execa(parsedBuildCommand, {\n        shell: true,\n      });\n\n      logger.pipeProcessOutput(runner.stdout, runner.stderr);\n\n      await runner;\n      tracer.stop();\n    } catch (e) {\n      logger.error(`Failed while running: \"${parsedBuildCommand}\"`);\n      throw e;\n    }\n  };\n}\n"],"names":["createBuildCommand","getRawBuildCommand","process","argv","slice","join","buildCommand","clearOutput","outputGlob","logger","parsedBuildCommand","Error","filesToClear","glob","Promise","all","map","file","fs","remove","tracer","setTime","runner","execa","shell","pipeProcessOutput","stdout","stderr","stop","e","error"],"mappings":";;;;;;;;;;;QAagBA;eAAAA;;QAJAC;eAAAA;;;8DATE;gEACH;wBACM;;;;;;AAOd,SAASA;IACd,OAAOC,QAAQC,IAAI,CAACC,KAAK,CAAC,GAAGC,IAAI,CAAC;AACpC;AAEO,SAASL,mBACdM,YAAiC,EACjCC,WAAoB,EACpBC,UAAoB,EACpBC,MAAc;IAEd,OAAO;QACL,MAAMC,qBAAqBJ,aAAaD,IAAI,CAAC;QAE7C,IAAI,CAACK,oBAAoB;YACvB,MAAM,IAAIC,MAAM;QAClB;QAEA,IAAIJ,aAAa;YACf,MAAMK,eAAeC,IAAAA,YAAI,EAACL;YAC1B,MAAMM,QAAQC,GAAG,CACfH,aAAaI,GAAG,CAAC,OAAOC,OAAS,MAAMC,gBAAE,CAACC,MAAM,CAACF;QAErD;QAEA,IAAI;YACF,gBAAgB;YAChB,MAAMG,SAASX,OAAOY,OAAO,CAAC;YAC9B,MAAMC,SAASC,IAAAA,cAAK,EAACb,oBAAoB;gBACvCc,OAAO;YACT;YAEAf,OAAOgB,iBAAiB,CAACH,OAAOI,MAAM,EAAEJ,OAAOK,MAAM;YAErD,MAAML;YACNF,OAAOQ,IAAI;QACb,EAAE,OAAOC,GAAG;YACVpB,OAAOqB,KAAK,CAAC,CAAC,uBAAuB,EAAEpB,mBAAmB,CAAC,CAAC;YAC5D,MAAMmB;QACR;IACF;AACF"}

package/lib/index.d.ts

@@ -1,7 +1,6 @@
 import { type Logger } from "backfill-logger";
 import { type Config } from "backfill-config";
-import { BuildCommand } from "./commandRunner";
+import { type BuildCommand } from "./commandRunner.js";
 export { createDefaultConfig, type Config, type ICacheStorage, } from "backfill-config";
 export declare function backfill(config: Config, buildCommand: BuildCommand, hashSalt: string, logger: Logger): Promise<void>;
 export declare function main(): Promise<void>;
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,114 +1,123 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = exports.backfill = exports.createDefaultConfig = void 0;
-const backfill_utils_dotenv_1 = require("backfill-utils-dotenv");
-const backfill_logger_1 = require("backfill-logger");
-const backfill_config_1 = require("backfill-config");
-const backfill_cache_1 = require("backfill-cache");
-const yargs_1 = __importDefault(require("yargs"));
-const commandRunner_1 = require("./commandRunner");
-const audit_1 = require("./audit");
-const api_1 = require("./api");
-var backfill_config_2 = require("backfill-config");
-Object.defineProperty(exports, "createDefaultConfig", { enumerable: true, get: function () { return backfill_config_2.createDefaultConfig; } });
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get backfill () {
+        return backfill;
+    },
+    get createDefaultConfig () {
+        return _backfillconfig.createDefaultConfig;
+    },
+    get main () {
+        return main;
+    }
+});
+const _backfillutilsdotenv = require("backfill-utils-dotenv");
+const _backfilllogger = require("backfill-logger");
+const _backfillconfig = require("backfill-config");
+const _backfillcache = require("backfill-cache");
+const _yargs = /*#__PURE__*/ _interop_require_default(require("yargs"));
+const _commandRunner = require("./commandRunner.js");
+const _audit = require("./audit.js");
+const _api = require("./api.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 // Load environment variables
-(0, backfill_utils_dotenv_1.loadDotenv)();
+(0, _backfillutilsdotenv.loadDotenv)();
 async function backfill(config, buildCommand, hashSalt, logger) {
-    const { cacheStorageConfig, name, mode, logFolder, packageRoot, producePerformanceLogs, validateOutput, } = config;
+    const { cacheStorageConfig, name, mode, logFolder, packageRoot, producePerformanceLogs, validateOutput } = config;
     logger.setName(name);
     logger.setMode(mode, mode === "READ_WRITE" ? "info" : "verbose");
-    logger.setCacheProvider((0, backfill_cache_1.isCustomProvider)(cacheStorageConfig)
-        ? cacheStorageConfig.name || "custom-storage-provider"
-        : cacheStorageConfig.provider);
-    const createPackageHash = async () => await (0, api_1.computeHash)(packageRoot, logger, hashSalt);
-    const fetch = async (hash) => await (0, api_1.fetch)(packageRoot, hash, logger, config);
-    const run = async () => {
+    logger.setCacheProvider((0, _backfillcache.isCustomProvider)(cacheStorageConfig) ? cacheStorageConfig.name || "custom-storage-provider" : cacheStorageConfig.provider);
+    const createPackageHash = async ()=>await (0, _api.computeHash)(packageRoot, logger, hashSalt);
+    const fetch = async (hash)=>await (0, _api.fetch)(packageRoot, hash, logger, config);
+    const run = async ()=>{
         try {
             await buildCommand();
-        }
-        catch (err) {
+        } catch (err) {
             throw new Error(`Command failed with the following error:\n\n${err}`);
         }
     };
-    const put = async (hash) => {
+    const put = async (hash)=>{
         try {
-            await (0, api_1.put)(packageRoot, hash, logger, config);
-        }
-        catch (err) {
+            await (0, _api.put)(packageRoot, hash, logger, config);
+        } catch (err) {
             logger.error(`Failed to persist the cache with the following error:\n\n${err}`);
         }
     };
-    switch (mode) {
-        case "READ_WRITE": {
-            const hash = await createPackageHash();
-            if (!(await fetch(hash))) {
+    switch(mode){
+        case "READ_WRITE":
+            {
+                const hash = await createPackageHash();
+                if (!await fetch(hash)) {
+                    await run();
+                    await put(hash);
+                }
+                break;
+            }
+        case "READ_ONLY":
+            {
+                const hash = await createPackageHash();
+                if (!await fetch(hash)) {
+                    await run();
+                }
+                break;
+            }
+        case "WRITE_ONLY":
+            {
                 await run();
+                const hash = await createPackageHash();
                 await put(hash);
+                break;
             }
-            break;
-        }
-        case "READ_ONLY": {
-            const hash = await createPackageHash();
-            if (!(await fetch(hash))) {
+        case "PASS":
+            {
                 await run();
+                break;
             }
-            break;
-        }
-        case "WRITE_ONLY": {
-            await run();
-            const hash = await createPackageHash();
-            await put(hash);
-            break;
-        }
-        case "PASS": {
-            await run();
-            break;
-        }
     }
     if (validateOutput) {
-        const hashOfOutput = await (0, api_1.computeHashOfOutput)(packageRoot, logger);
+        const hashOfOutput = await (0, _api.computeHashOfOutput)(packageRoot, logger);
         logger.setHashOfOutput(hashOfOutput);
     }
     if (producePerformanceLogs) {
         await logger.toFile(logFolder);
     }
 }
-exports.backfill = backfill;
 async function main() {
-    let logger = (0, backfill_logger_1.makeLogger)("info");
+    let logger = (0, _backfilllogger.makeLogger)("info");
     const cwd = process.cwd();
     try {
-        const config = (0, backfill_config_1.createConfig)(logger, cwd);
-        const { clearOutput, internalCacheFolder, logFolder, logLevel, outputGlob, packageRoot, } = config;
+        const config = (0, _backfillconfig.createConfig)(logger, cwd);
+        const { clearOutput, internalCacheFolder, logFolder, logLevel, outputGlob, packageRoot } = config;
         if (logLevel) {
-            logger = (0, backfill_logger_1.makeLogger)(logLevel);
+            logger = (0, _backfilllogger.makeLogger)(logLevel);
         }
         const helpString = "Backfills unchanged packages.";
-        const argv = yargs_1.default
-            .strict()
-            .usage(helpString)
-            .alias("h", "help")
-            .version(false)
-            .option("audit", {
+        const argv = _yargs.default.strict().usage(helpString).alias("h", "help").version(false).option("audit", {
             description: "Compare files changed with those cached",
-            type: "boolean",
+            type: "boolean"
         }).argv;
-        const buildCommand = (0, commandRunner_1.createBuildCommand)(argv["_"], clearOutput, outputGlob, logger);
+        const buildCommand = (0, _commandRunner.createBuildCommand)(argv["_"], clearOutput, outputGlob, logger);
         if (argv["audit"]) {
-            (0, audit_1.initializeWatcher)(packageRoot, internalCacheFolder, logFolder, outputGlob, logger);
+            (0, _audit.initializeWatcher)(packageRoot, internalCacheFolder, logFolder, outputGlob, logger);
         }
-        await backfill(config, buildCommand, (0, commandRunner_1.getRawBuildCommand)(), logger);
+        await backfill(config, buildCommand, (0, _commandRunner.getRawBuildCommand)(), logger);
         if (argv["audit"]) {
-            await (0, audit_1.closeWatcher)(logger);
+            await (0, _audit.closeWatcher)(logger);
         }
-    }
-    catch (err) {
+    } catch (err) {
         logger.error(err);
         process.exit(1);
     }
 }
-exports.main = main;
-//# sourceMappingURL=data:application/json;base64,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

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { loadDotenv } from \"backfill-utils-dotenv\";\nimport { type Logger, makeLogger } from \"backfill-logger\";\nimport { createConfig, type Config } from \"backfill-config\";\nimport { isCustomProvider } from \"backfill-cache\";\nimport yargs from \"yargs\";\nimport {\n  getRawBuildCommand,\n  createBuildCommand,\n  type BuildCommand,\n} from \"./commandRunner.js\";\nimport { initializeWatcher, closeWatcher } from \"./audit.js\";\nimport {\n  put as put_api,\n  fetch as fetch_api,\n  computeHash,\n  computeHashOfOutput,\n} from \"./api.js\";\n\nexport {\n  createDefaultConfig,\n  type Config,\n  type ICacheStorage,\n} from \"backfill-config\";\n\n// Load environment variables\nloadDotenv();\n\nexport async function backfill(\n  config: Config,\n  buildCommand: BuildCommand,\n  hashSalt: string,\n  logger: Logger\n): Promise<void> {\n  const {\n    cacheStorageConfig,\n    name,\n    mode,\n    logFolder,\n    packageRoot,\n    producePerformanceLogs,\n    validateOutput,\n  } = config;\n\n  logger.setName(name);\n  logger.setMode(mode, mode === \"READ_WRITE\" ? \"info\" : \"verbose\");\n  logger.setCacheProvider(\n    isCustomProvider(cacheStorageConfig)\n      ? cacheStorageConfig.name || \"custom-storage-provider\"\n      : cacheStorageConfig.provider\n  );\n\n  const createPackageHash = async () =>\n    await computeHash(packageRoot, logger, hashSalt);\n  const fetch = async (hash: string) =>\n    await fetch_api(packageRoot, hash, logger, config);\n  const run = async () => {\n    try {\n      await buildCommand();\n    } catch (err) {\n      throw new Error(`Command failed with the following error:\\n\\n${err}`);\n    }\n  };\n  const put = async (hash: string) => {\n    try {\n      await put_api(packageRoot, hash, logger, config);\n    } catch (err) {\n      logger.error(\n        `Failed to persist the cache with the following error:\\n\\n${err}`\n      );\n    }\n  };\n\n  switch (mode) {\n    case \"READ_WRITE\": {\n      const hash = await createPackageHash();\n      if (!(await fetch(hash))) {\n        await run();\n        await put(hash);\n      }\n\n      break;\n    }\n    case \"READ_ONLY\": {\n      const hash = await createPackageHash();\n      if (!(await fetch(hash))) {\n        await run();\n      }\n\n      break;\n    }\n    case \"WRITE_ONLY\": {\n      await run();\n\n      const hash = await createPackageHash();\n      await put(hash);\n\n      break;\n    }\n    case \"PASS\": {\n      await run();\n      break;\n    }\n  }\n\n  if (validateOutput) {\n    const hashOfOutput = await computeHashOfOutput(packageRoot, logger);\n    logger.setHashOfOutput(hashOfOutput);\n  }\n\n  if (producePerformanceLogs) {\n    await logger.toFile(logFolder);\n  }\n}\n\nexport async function main(): Promise<void> {\n  let logger = makeLogger(\"info\");\n  const cwd = process.cwd();\n\n  try {\n    const config = createConfig(logger, cwd);\n    const {\n      clearOutput,\n      internalCacheFolder,\n      logFolder,\n      logLevel,\n      outputGlob,\n      packageRoot,\n    } = config;\n\n    if (logLevel) {\n      logger = makeLogger(logLevel);\n    }\n\n    const helpString = \"Backfills unchanged packages.\";\n\n    const argv = yargs\n      .strict()\n      .usage(helpString)\n      .alias(\"h\", \"help\")\n      .version(false)\n      .option(\"audit\", {\n        description: \"Compare files changed with those cached\",\n        type: \"boolean\",\n      }).argv;\n\n    const buildCommand = createBuildCommand(\n      argv[\"_\"],\n      clearOutput,\n      outputGlob,\n      logger\n    );\n\n    if (argv[\"audit\"]) {\n      initializeWatcher(\n        packageRoot,\n        internalCacheFolder,\n        logFolder,\n        outputGlob,\n        logger\n      );\n    }\n\n    await backfill(config, buildCommand, getRawBuildCommand(), logger);\n\n    if (argv[\"audit\"]) {\n      await closeWatcher(logger);\n    }\n  } catch (err) {\n    logger.error(err as any);\n    process.exit(1);\n  }\n}\n"],"names":["backfill","createDefaultConfig","main","loadDotenv","config","buildCommand","hashSalt","logger","cacheStorageConfig","name","mode","logFolder","packageRoot","producePerformanceLogs","validateOutput","setName","setMode","setCacheProvider","isCustomProvider","provider","createPackageHash","computeHash","fetch","hash","fetch_api","run","err","Error","put","put_api","error","hashOfOutput","computeHashOfOutput","setHashOfOutput","toFile","makeLogger","cwd","process","createConfig","clearOutput","internalCacheFolder","logLevel","outputGlob","helpString","argv","yargs","strict","usage","alias","version","option","description","type","createBuildCommand","initializeWatcher","getRawBuildCommand","closeWatcher","exit"],"mappings":";;;;;;;;;;;QA2BsBA;eAAAA;;QARpBC;eAAAA,mCAAmB;;QA+FCC;eAAAA;;;qCAlHK;gCACa;gCACE;+BACT;8DACf;+BAKX;uBACyC;qBAMzC;;;;;;AAQP,6BAA6B;AAC7BC,IAAAA,+BAAU;AAEH,eAAeH,SACpBI,MAAc,EACdC,YAA0B,EAC1BC,QAAgB,EAChBC,MAAc;IAEd,MAAM,EACJC,kBAAkB,EAClBC,IAAI,EACJC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,sBAAsB,EACtBC,cAAc,EACf,GAAGV;IAEJG,OAAOQ,OAAO,CAACN;IACfF,OAAOS,OAAO,CAACN,MAAMA,SAAS,eAAe,SAAS;IACtDH,OAAOU,gBAAgB,CACrBC,IAAAA,+BAAgB,EAACV,sBACbA,mBAAmBC,IAAI,IAAI,4BAC3BD,mBAAmBW,QAAQ;IAGjC,MAAMC,oBAAoB,UACxB,MAAMC,IAAAA,gBAAW,EAACT,aAAaL,QAAQD;IACzC,MAAMgB,QAAQ,OAAOC,OACnB,MAAMC,IAAAA,UAAS,EAACZ,aAAaW,MAAMhB,QAAQH;IAC7C,MAAMqB,MAAM;QACV,IAAI;YACF,MAAMpB;QACR,EAAE,OAAOqB,KAAK;YACZ,MAAM,IAAIC,MAAM,CAAC,4CAA4C,EAAED,KAAK;QACtE;IACF;IACA,MAAME,MAAM,OAAOL;QACjB,IAAI;YACF,MAAMM,IAAAA,QAAO,EAACjB,aAAaW,MAAMhB,QAAQH;QAC3C,EAAE,OAAOsB,KAAK;YACZnB,OAAOuB,KAAK,CACV,CAAC,yDAAyD,EAAEJ,KAAK;QAErE;IACF;IAEA,OAAQhB;QACN,KAAK;YAAc;gBACjB,MAAMa,OAAO,MAAMH;gBACnB,IAAI,CAAE,MAAME,MAAMC,OAAQ;oBACxB,MAAME;oBACN,MAAMG,IAAIL;gBACZ;gBAEA;YACF;QACA,KAAK;YAAa;gBAChB,MAAMA,OAAO,MAAMH;gBACnB,IAAI,CAAE,MAAME,MAAMC,OAAQ;oBACxB,MAAME;gBACR;gBAEA;YACF;QACA,KAAK;YAAc;gBACjB,MAAMA;gBAEN,MAAMF,OAAO,MAAMH;gBACnB,MAAMQ,IAAIL;gBAEV;YACF;QACA,KAAK;YAAQ;gBACX,MAAME;gBACN;YACF;IACF;IAEA,IAAIX,gBAAgB;QAClB,MAAMiB,eAAe,MAAMC,IAAAA,wBAAmB,EAACpB,aAAaL;QAC5DA,OAAO0B,eAAe,CAACF;IACzB;IAEA,IAAIlB,wBAAwB;QAC1B,MAAMN,OAAO2B,MAAM,CAACvB;IACtB;AACF;AAEO,eAAeT;IACpB,IAAIK,SAAS4B,IAAAA,0BAAU,EAAC;IACxB,MAAMC,MAAMC,QAAQD,GAAG;IAEvB,IAAI;QACF,MAAMhC,SAASkC,IAAAA,4BAAY,EAAC/B,QAAQ6B;QACpC,MAAM,EACJG,WAAW,EACXC,mBAAmB,EACnB7B,SAAS,EACT8B,QAAQ,EACRC,UAAU,EACV9B,WAAW,EACZ,GAAGR;QAEJ,IAAIqC,UAAU;YACZlC,SAAS4B,IAAAA,0BAAU,EAACM;QACtB;QAEA,MAAME,aAAa;QAEnB,MAAMC,OAAOC,cAAK,CACfC,MAAM,GACNC,KAAK,CAACJ,YACNK,KAAK,CAAC,KAAK,QACXC,OAAO,CAAC,OACRC,MAAM,CAAC,SAAS;YACfC,aAAa;YACbC,MAAM;QACR,GAAGR,IAAI;QAET,MAAMvC,eAAegD,IAAAA,iCAAkB,EACrCT,IAAI,CAAC,IAAI,EACTL,aACAG,YACAnC;QAGF,IAAIqC,IAAI,CAAC,QAAQ,EAAE;YACjBU,IAAAA,wBAAiB,EACf1C,aACA4B,qBACA7B,WACA+B,YACAnC;QAEJ;QAEA,MAAMP,SAASI,QAAQC,cAAckD,IAAAA,iCAAkB,KAAIhD;QAE3D,IAAIqC,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAMY,IAAAA,mBAAY,EAACjD;QACrB;IACF,EAAE,OAAOmB,KAAK;QACZnB,OAAOuB,KAAK,CAACJ;QACbW,QAAQoB,IAAI,CAAC;IACf;AACF"}

package/package.json

@@ -1,49 +1,48 @@
 {
   "name": "backfill",
-  "version": "6.4.3",
+  "version": "6.4.5",
   "description": "Backfill CLI",
   "license": "MIT",
   "author": "Benjamin Weggersen <bewegger@microsoft.com>",
   "repository": {
     "type": "git",
-    "url": "https://github.com/microsoft/backfill"
+    "url": "https://github.com/microsoft/lage"
   },
   "main": "lib/index.js",
-  "bin": {
-    "backfill": "./bin/backfill.js"
-  },
+  "types": "lib/index.d.ts",
+  "bin": "./bin/backfill.js",
   "scripts": {
-    "build": "tsc -b --pretty",
-    "test": "jest",
-    "watch": "tsc -b -w"
+    "build": "yarn types && yarn transpile",
+    "transpile": "monorepo-scripts transpile",
+    "types": "yarn run -T tsc",
+    "lint": "monorepo-scripts lint",
+    "test": "yarn run -T jest"
   },
   "dependencies": {
-    "anymatch": "^3.0.3",
-    "backfill-cache": "^5.11.3",
-    "backfill-config": "^6.7.1",
-    "backfill-hasher": "^6.7.0",
-    "backfill-logger": "^5.4.0",
-    "backfill-utils-dotenv": "^5.3.1",
-    "chokidar": "^3.2.1",
-    "execa": "^5.0.0",
+    "@lage-run/globby": "^13.0.1",
+    "anymatch": "^3.1.3",
+    "backfill-cache": "^5.12.0",
+    "backfill-config": "^6.7.2",
+    "backfill-hasher": "^6.7.2",
+    "backfill-logger": "^5.4.1",
+    "backfill-utils-dotenv": "^5.3.2",
+    "chokidar": "^3.6.0",
+    "execa": "^5.1.1",
     "find-up": "^5.0.0",
     "fs-extra": "^8.1.0",
-    "globby": "^11.0.0",
-    "yargs": "^16.1.1"
+    "yargs": "^16.2.0"
   },
   "devDependencies": {
+    "@lage-run/monorepo-scripts": "^1.0.0",
+    "@lage-run/test-utilities": "^0.1.0",
     "@types/fs-extra": "^8.0.0",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^14.18.36",
-    "@types/yargs": "^15.0.15",
-    "backfill-utils-test": "*",
-    "backfill-utils-tsconfig": "*",
-    "jest": "^30.0.0",
-    "ts-jest": "^29.0.0",
-    "ts-mockito": "^2.6.1",
-    "typescript": "~4.7.0"
+    "@types/yargs": "^15.0.15"
   },
   "engines": {
     "node": ">=14"
-  }
+  },
+  "files": [
+    "lib/!(__*)",
+    "lib/!(__*)/**"
+  ]
 }