@serwist/build 8.4.3 → 9.0.0-preview.0

package/src/_types.js

@@ -0,0 +1,112 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+/**
+ * @typedef {Object} ManifestEntry
+ * @property {string} url The URL to the asset in the manifest.
+ * @property {string} revision The revision details for the file. This should be
+ * either a hash generated based on the file contents, or `null` if there is
+ * versioning already included in the URL.
+ * @property {string} [integrity] Integrity metadata that will be used when
+ * making the network request for the URL.
+ */
+
+/**
+ * @typedef {Object} ManifestTransformResult
+ * @property {Array<module:workbox-build.ManifestEntry>} manifest
+ * @property {Array<string>|undefined} warnings
+ */
+
+/**
+ * @typedef {Object} RuntimeCachingEntry
+ *
+ * @property {string|module:workbox-routing~handlerCallback} handler
+ * Either the name of one of the [built-in strategy classes]{@link module:workbox-strategies},
+ * or custom handler callback to use when the generated route matches.
+ *
+ * @property {string|RegExp|module:workbox-routing~matchCallback} urlPattern
+ * The value that will be passed to [`registerRoute()`]{@link module:workbox-routing.registerRoute},
+ * used to determine whether the generated route will match a given request.
+ *
+ * @property {string} [method='GET'] The
+ * [HTTP method](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) that
+ * will match the generated route.
+ *
+ * @property {Object} [options]
+ *
+ * @property {Object} [options.backgroundSync]
+ *
+ * @property {string} [options.backgroundSync.name] The `name` property to use
+ * when creating the
+ * [`BackgroundSyncPlugin`]{@link module:workbox-background-sync.BackgroundSyncPlugin}.
+ *
+ * @property {Object} [options.backgroundSync.options] The `options` property
+ * to use when creating the
+ * [`BackgroundSyncPlugin`]{@link module:workbox-background-sync.BackgroundSyncPlugin}.
+ *
+ * @property {Object} [options.broadcastUpdate]
+ *
+ * @property {string} [options.broadcastUpdate.channelName] The `channelName`
+ * property to use when creating the
+ * [`BroadcastCacheUpdatePlugin`]{@link module:workbox-broadcast-update.BroadcastUpdatePlugin}.
+ *
+ * @property {Object} [options.broadcastUpdate.options] The `options` property
+ * to use when creating the
+ * [`BroadcastCacheUpdatePlugin`]{@link module:workbox-broadcast-update.BroadcastUpdatePlugin}.
+ *
+ * @property {Object} [options.cacheableResponse]
+ *
+ * @property {Object} [options.cacheableResponse.headers] The `headers` property
+ * to use when creating the
+ * [`CacheableResponsePlugin`]{@link module:workbox-cacheable-response.CacheableResponsePlugin}.
+ *
+ * @property {Array<number>} [options.cacheableResponse.statuses] `statuses`
+ * property to use when creating the
+ * [`CacheableResponsePlugin`]{@link module:workbox-cacheable-response.CacheableResponsePlugin}.
+ *
+ * @property {string} [options.cacheName] The `cacheName` to use when
+ * constructing one of the
+ * [Workbox strategy classes]{@link module:workbox-strategies}.
+ *
+ * @property {Object} [options.fetchOptions] The `fetchOptions` property value
+ * to use when constructing one of the
+ * [Workbox strategy classes]{@link module:workbox-strategies}.
+ *
+ * @property {Object} [options.expiration]
+ *
+ * @property {number} [options.expiration.maxAgeSeconds] The `maxAgeSeconds`
+ * property to use when creating the
+ * [`ExpirationPlugin`]{@link module:workbox-expiration.ExpirationPlugin}.
+ *
+ * @property {number} [options.expiration.maxEntries] The `maxEntries`
+ * property to use when creating the
+ * [`ExpirationPlugin`]{@link module:workbox-expiration.ExpirationPlugin}.
+ *
+ * @property {Object} [options.precacheFallback]
+ *
+ * @property {string} [options.precacheFallback.fallbackURL] The `fallbackURL`
+ * property to use when creating the
+ * [`PrecacheFallbackPlugin`]{@link module:workbox-precaching.PrecacheFallbackPlugin}.
+ *
+ * @property {boolean} [options.rangeRequests] Set to `true` to add the
+ * [`RangeRequestsPlugin`]{@link module:workbox-range-requests.RangeRequestsPlugin}
+ * for the strategy being configured.
+ *
+ * @property {Object} [options.matchOptions] The `matchOptions` property value
+ * to use when constructing one of the
+ * [Workbox strategy classes]{@link module:workbox-strategies}.
+ *
+ * @property {number} [options.networkTimeoutSeconds] The
+ * `networkTimeoutSeconds` property value to use when creating a
+ * [`NetworkFirst`]{@link module:workbox-strategies.NetworkFirst} strategy.
+ *
+ * @property {Array<Object>} [options.plugins]
+ * One or more [additional plugins](https://developers.google.com/web/tools/workbox/guides/using-plugins#custom_plugins)
+ * to apply to the handler. Useful when you want a plugin that doesn't have a
+ * "shortcut" configuration.
+ */

package/src/get-manifest.ts

@@ -0,0 +1,33 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { getFileManifestEntries } from "./lib/get-file-manifest-entries.js";
+import { validateGetManifestOptions } from "./lib/validate-options.js";
+import type { GetManifestOptions, GetManifestResult } from "./types.js";
+
+/**
+ * This method returns a list of URLs to precache, referred to as a "precache
+ * manifest", along with details about the number of entries and their size,
+ * based on the options you provide.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * const {count, manifestEntries, size, warnings} = await getManifest({
+ *   dontCacheBustURLsMatching: [new RegExp('...')],
+ *   globDirectory: '...',
+ *   globPatterns: ['...', '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ * });
+ * ```
+ */
+export const getManifest = async (config: GetManifestOptions): Promise<GetManifestResult> => {
+  const options = await validateGetManifestOptions(config);
+
+  return await getFileManifestEntries(options);
+};

package/src/index.next.ts

@@ -0,0 +1,3 @@
+import { validateNextInjectManifestOptions } from "./lib/validate-next-options.js";
+
+export { validateNextInjectManifestOptions };

package/{dist/index.d.cts → src/index.ts}

@@ -1,4 +1,12 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
 import stringify from "fast-json-stable-stringify";
+
 import { getManifest } from "./get-manifest.js";
 import { injectManifest } from "./inject-manifest.js";
 import { errors } from "./lib/errors.js";
@@ -10,5 +18,22 @@ import { replaceAndUpdateSourceMap } from "./lib/replace-and-update-source-map.j
 import { transformManifest } from "./lib/transform-manifest.js";
 import { translateURLToSourcemapPaths } from "./lib/translate-url-to-sourcemap-paths.js";
 import { validateInjectManifestOptions, validateViteInjectManifestOptions, validateWebpackInjectManifestOptions } from "./lib/validate-options.js";
-export { errors, escapeRegExp, getFileManifestEntries, getManifest, getSourceMapURL, injectManifest, rebasePath, replaceAndUpdateSourceMap, stringify, transformManifest, translateURLToSourcemapPaths, validateInjectManifestOptions, validateViteInjectManifestOptions, validateWebpackInjectManifestOptions, };
-export * from "./types.js";
+
+export {
+  errors,
+  escapeRegExp,
+  getFileManifestEntries,
+  getManifest,
+  getSourceMapURL,
+  injectManifest,
+  rebasePath,
+  replaceAndUpdateSourceMap,
+  stringify,
+  transformManifest,
+  translateURLToSourcemapPaths,
+  validateInjectManifestOptions,
+  validateViteInjectManifestOptions,
+  validateWebpackInjectManifestOptions,
+};
+
+export type * from "./types.js";

package/src/inject-manifest.ts

@@ -0,0 +1,140 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import assert from "assert";
+import stringify from "fast-json-stable-stringify";
+import fse from "fs-extra";
+import type { RawSourceMap } from "source-map";
+import upath from "upath";
+
+import { errors } from "./lib/errors.js";
+import { escapeRegExp } from "./lib/escape-regexp.js";
+import { getFileManifestEntries } from "./lib/get-file-manifest-entries.js";
+import { getSourceMapURL } from "./lib/get-source-map-url.js";
+import { rebasePath } from "./lib/rebase-path.js";
+import { replaceAndUpdateSourceMap } from "./lib/replace-and-update-source-map.js";
+import { translateURLToSourcemapPaths } from "./lib/translate-url-to-sourcemap-paths.js";
+import { validateInjectManifestOptions } from "./lib/validate-options.js";
+import type { BuildResult, InjectManifestOptions } from "./types.js";
+
+/**
+ * This method creates a list of URLs to precache, referred to as a "precache
+ * manifest", based on the options you provide.
+ *
+ * The manifest is injected into the `swSrc` file, and the placeholder string
+ * `injectionPoint` determines where in the file the manifest should go.
+ *
+ * The final service worker file, with the manifest injected, is written to
+ * disk at `swDest`.
+ *
+ * This method will not compile or bundle your `swSrc` file; it just handles
+ * injecting the manifest.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * const {count, size, warnings} = await injectManifest({
+ *   dontCacheBustURLsMatching: [new RegExp('...')],
+ *   globDirectory: '...',
+ *   globPatterns: ['...', '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swDest: '...',
+ *   swSrc: '...',
+ * });
+ * ```
+ */
+export const injectManifest = async (config: InjectManifestOptions): Promise<BuildResult> => {
+  const options = await validateInjectManifestOptions(config);
+
+  // Make sure we leave swSrc and swDest out of the precache manifest.
+  for (const file of [options.swSrc, options.swDest]) {
+    options.globIgnores!.push(
+      rebasePath({
+        file,
+        baseDirectory: options.globDirectory,
+      }),
+    );
+  }
+
+  const globalRegexp = new RegExp(escapeRegExp(options.injectionPoint!), "g");
+
+  const { count, size, manifestEntries, warnings } = await getFileManifestEntries(options);
+  let swFileContents: string;
+  try {
+    swFileContents = await fse.readFile(options.swSrc, "utf8");
+  } catch (error) {
+    throw new Error(`${errors["invalid-sw-src"]} ${error instanceof Error && error.message ? error.message : ""}`);
+  }
+
+  const injectionResults = swFileContents.match(globalRegexp);
+  // See https://github.com/GoogleChrome/workbox/issues/2230
+  const injectionPoint = options.injectionPoint ? options.injectionPoint : "";
+  if (!injectionResults) {
+    if (upath.resolve(options.swSrc) === upath.resolve(options.swDest)) {
+      throw new Error(`${errors["same-src-and-dest"]} ${injectionPoint}`);
+    }
+    throw new Error(`${errors["injection-point-not-found"]} ${injectionPoint}`);
+  }
+
+  assert(injectionResults.length === 1, `${errors["multiple-injection-points"]} ${injectionPoint}`);
+
+  const manifestString = manifestEntries === undefined ? "undefined" : stringify(manifestEntries);
+  const filesToWrite: { [key: string]: string } = {};
+
+  const url = getSourceMapURL(swFileContents);
+  // See https://github.com/GoogleChrome/workbox/issues/2957
+  const { destPath, srcPath, warning } = translateURLToSourcemapPaths(url, options.swSrc, options.swDest);
+  if (warning) {
+    warnings.push(warning);
+  }
+
+  // If our swSrc file contains a sourcemap, we would invalidate that
+  // mapping if we just replaced injectionPoint with the stringified manifest.
+  // Instead, we need to update the swDest contents as well as the sourcemap
+  // (assuming it's a real file, not a data: URL) at the same time.
+  // See https://github.com/GoogleChrome/workbox/issues/2235
+  // and https://github.com/GoogleChrome/workbox/issues/2648
+  if (srcPath && destPath) {
+    const originalMap = (await fse.readJSON(srcPath, {
+      encoding: "utf8",
+    })) as RawSourceMap;
+
+    const { map, source } = await replaceAndUpdateSourceMap({
+      originalMap,
+      jsFilename: upath.basename(options.swDest),
+      originalSource: swFileContents,
+      replaceString: manifestString,
+      searchString: options.injectionPoint!,
+    });
+
+    filesToWrite[options.swDest] = source;
+    filesToWrite[destPath] = map;
+  } else {
+    // If there's no sourcemap associated with swSrc, a simple string
+    // replacement will suffice.
+    filesToWrite[options.swDest] = swFileContents.replace(globalRegexp, manifestString);
+  }
+
+  for (const [file, contents] of Object.entries(filesToWrite)) {
+    try {
+      await fse.mkdirp(upath.dirname(file));
+    } catch (error: unknown) {
+      throw new Error(`${errors["unable-to-make-sw-directory"]} '${error instanceof Error && error.message ? error.message : ""}'`);
+    }
+
+    await fse.writeFile(file, contents);
+  }
+
+  return {
+    count,
+    size,
+    warnings,
+    // Use upath.resolve() to make all the paths absolute.
+    filePaths: Object.keys(filesToWrite).map((f) => upath.resolve(f)),
+  };
+};

package/src/lib/additional-precache-entries-transform.ts

@@ -0,0 +1,58 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { ManifestEntry } from "../types.js";
+import { errors } from "./errors.js";
+
+type AdditionalManifestEntriesTransform = {
+  (
+    manifest: (ManifestEntry & { size: number })[],
+  ): {
+    manifest: (ManifestEntry & { size: number })[];
+    warnings: string[];
+  };
+};
+
+export const additionalPrecacheEntriesTransform = (additionalPrecacheEntries: (ManifestEntry | string)[]): AdditionalManifestEntriesTransform => {
+  return (manifest: (ManifestEntry & { size: number })[]) => {
+    const warnings: string[] = [];
+    const stringEntries = new Set<string>();
+
+    for (const additionalEntry of additionalPrecacheEntries) {
+      // Warn about either a string or an object that lacks a revision property.
+      // (An object with a revision property set to null is okay.)
+      if (typeof additionalEntry === "string") {
+        stringEntries.add(additionalEntry);
+        manifest.push({
+          revision: null,
+          size: 0,
+          url: additionalEntry,
+        });
+      } else {
+        if (additionalEntry && additionalEntry.revision === undefined) {
+          stringEntries.add(additionalEntry.url);
+        }
+        manifest.push(Object.assign({ size: 0 }, additionalEntry));
+      }
+    }
+
+    if (stringEntries.size > 0) {
+      let urls = "\n";
+      for (const stringEntry of stringEntries) {
+        urls += `  - ${stringEntry}\n`;
+      }
+
+      warnings.push(errors["string-entry-warning"] + urls);
+    }
+
+    return {
+      manifest,
+      warnings,
+    };
+  };
+};

package/src/lib/errors.ts

@@ -0,0 +1,99 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { oneLine as ol } from "common-tags";
+
+export const errors = {
+  "unable-to-get-rootdir": "Unable to get the root directory of your web app.",
+  "no-extension": ol`Unable to detect a usable extension for a file in your web
+    app directory.`,
+  "invalid-file-manifest-name": ol`The File Manifest Name must have at least one
+    character.`,
+  "unable-to-get-file-manifest-name": "Unable to get a file manifest name.",
+  "invalid-sw-dest": `The 'swDest' value must be a valid path.`,
+  "unable-to-get-sw-name": "Unable to get a service worker file name.",
+  "unable-to-get-save-config": ol`An error occurred when asking to save details
+    in a config file.`,
+  "unable-to-get-file-hash": ol`An error occurred when attempting to create a
+    file hash.`,
+  "unable-to-get-file-size": ol`An error occurred when attempting to get a file
+    size.`,
+  "unable-to-glob-files": "An error occurred when globbing for files.",
+  "unable-to-make-manifest-directory": ol`Unable to make output directory for
+    file manifest.`,
+  "read-manifest-template-failure": "Unable to read template for file manifest",
+  "populating-manifest-tmpl-failed": ol`An error occurred when populating the
+    file manifest template.`,
+  "manifest-file-write-failure": "Unable to write the file manifest.",
+  "unable-to-make-sw-directory": ol`Unable to make the directories to output
+    the service worker path.`,
+  "sw-write-failure": "Unable to write the service worker file.",
+  "sw-write-failure-directory": ol`Unable to write the service worker file;
+    'swDest' should be a full path to the file, not a path to a directory.`,
+  "unable-to-copy-serwist-libraries": ol`One or more of the Serwist libraries
+    could not be copied over to the destination directory: `,
+  "invalid-glob-directory": ol`The supplied globDirectory must be a path as a
+    string.`,
+  "invalid-dont-cache-bust": ol`The supplied 'dontCacheBustURLsMatching'
+    parameter must be a RegExp.`,
+  "invalid-exclude-files": "The excluded files should be an array of strings.",
+  "invalid-get-manifest-entries-input": ol`The input to
+    'getFileManifestEntries()' must be an object.`,
+  "invalid-manifest-path": ol`The supplied manifest path is not a string with
+    at least one character.`,
+  "invalid-manifest-entries": ol`The manifest entries must be an array of
+    strings or JavaScript objects containing a url parameter.`,
+  "invalid-manifest-format": ol`The value of the 'format' option passed to
+    generateFileManifest() must be either 'iife' (the default) or 'es'.`,
+  "invalid-static-file-globs": ol`The 'globPatterns' value must be an array
+    of strings.`,
+  "invalid-templated-urls": ol`The 'templatedURLs' value should be an object
+    that maps URLs to either a string, or to an array of glob patterns.`,
+  "templated-url-matches-glob": ol`One of the 'templatedURLs' URLs is already
+    being tracked via 'globPatterns': `,
+  "invalid-glob-ignores": ol`The 'globIgnores' parameter must be an array of
+    glob pattern strings.`,
+  "manifest-entry-bad-url": ol`The generated manifest contains an entry without
+    a URL string. This is likely an error with @serwist/build.`,
+  "modify-url-prefix-bad-prefixes": ol`The 'modifyURLPrefix' parameter must be
+    an object with string key value pairs.`,
+  "invalid-inject-manifest-arg": ol`The input to 'injectManifest()' must be an
+    object.`,
+  "injection-point-not-found": ol`Unable to find a place to inject the manifest.
+    Please ensure that your service worker file contains the following: `,
+  "multiple-injection-points": ol`Please ensure that your 'swSrc' file contains
+    only one match for the following: `,
+  "useless-glob-pattern": ol`One of the glob patterns doesn't match any files.
+    Please remove or fix the following: `,
+  "bad-template-urls-asset": ol`There was an issue using one of the provided
+    'templatedURLs'.`,
+  "invalid-runtime-caching": ol`The 'runtimeCaching' parameter must an an
+    array of objects with at least a 'urlPattern' and 'handler'.`,
+  "urlPattern-is-required": ol`The 'urlPattern' option is required when using
+    'runtimeCaching'.`,
+  "handler-is-required": ol`The 'handler' option is required when using
+    runtimeCaching.`,
+  "invalid-generate-file-manifest-arg": ol`The input to generateFileManifest()
+    must be an Object.`,
+  "invalid-sw-src": `The 'swSrc' file can't be read.`,
+  "same-src-and-dest": ol`Unable to find a place to inject the manifest. This is
+    likely because swSrc and swDest are configured to the same file.
+    Please ensure that your swSrc file contains the following:`,
+  "no-module-name": ol`You must provide a moduleName parameter when calling
+    getModuleURL().`,
+  "bad-manifest-transforms-return-value": ol`The return value from a
+    manifestTransform should be an object with 'manifest' and optionally
+    'warnings' properties.`,
+  "string-entry-warning": ol`Some items were passed to additionalPrecacheEntries
+    without revisioning info. This is generally NOT safe. Learn more at
+    https://bit.ly/wb-precache.`,
+  "cant-find-sourcemap": ol`The swSrc file refers to a sourcemap that can't be
+    opened:`,
+  "manifest-transforms": ol`When using manifestTransforms, you must provide
+    an array of functions.`,
+};

package/src/lib/escape-regexp.ts

@@ -0,0 +1,12 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+export const escapeRegExp = (str: string): string => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};

package/src/lib/get-composite-details.ts

@@ -0,0 +1,31 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import crypto from "crypto";
+
+import type { FileDetails } from "../types.js";
+
+export const getCompositeDetails = (compositeURL: string, dependencyDetails: FileDetails[]): FileDetails => {
+  let totalSize = 0;
+  let compositeHash = "";
+
+  for (const fileDetails of dependencyDetails) {
+    totalSize += fileDetails.size;
+    compositeHash += fileDetails.hash;
+  }
+
+  const md5 = crypto.createHash("md5");
+  md5.update(compositeHash);
+  const hashOfHashes = md5.digest("hex");
+
+  return {
+    file: compositeURL,
+    hash: hashOfHashes,
+    size: totalSize,
+  };
+};

package/src/lib/get-file-details.ts

@@ -0,0 +1,68 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { glob } from "glob";
+import upath from "upath";
+
+import type { GlobPartial } from "../types.js";
+import { errors } from "./errors.js";
+import { getFileHash } from "./get-file-hash.js";
+import { getFileSize } from "./get-file-size.js";
+
+interface FileDetails {
+  file: string;
+  hash: string;
+  size: number;
+}
+
+export function getFileDetails({
+  globDirectory,
+  globFollow,
+  globIgnores,
+  globPattern,
+}: Omit<GlobPartial, "globDirectory" | "globPatterns" | "templatedURLs"> & {
+  // This will only be called when globDirectory is not undefined.
+  globDirectory: string;
+  globPattern: string;
+}): {
+  globbedFileDetails: FileDetails[];
+  warning: string;
+} {
+  let globbedFiles: string[];
+  let warning = "";
+
+  try {
+    globbedFiles = glob.sync(globPattern, {
+      cwd: globDirectory,
+      follow: globFollow,
+      ignore: globIgnores,
+    });
+  } catch (err) {
+    throw new Error(`${errors["unable-to-glob-files"]} '${err instanceof Error && err.message ? err.message : ""}'`);
+  }
+
+  if (globbedFiles.length === 0) {
+    warning = `${errors["useless-glob-pattern"]} ${JSON.stringify({ globDirectory, globPattern, globIgnores }, null, 2)}`;
+  }
+
+  const globbedFileDetails: FileDetails[] = [];
+  for (const file of globbedFiles) {
+    const fullPath = upath.join(globDirectory, file);
+    const fileSize = getFileSize(fullPath);
+    if (fileSize !== null) {
+      const fileHash = getFileHash(fullPath);
+      globbedFileDetails.push({
+        file: `${upath.relative(globDirectory, fullPath)}`,
+        hash: fileHash,
+        size: fileSize,
+      });
+    }
+  }
+
+  return { globbedFileDetails, warning };
+}

package/src/lib/get-file-hash.ts

@@ -0,0 +1,21 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import fse from "fs-extra";
+
+import { errors } from "./errors.js";
+import { getStringHash } from "./get-string-hash.js";
+
+export function getFileHash(file: string): string {
+  try {
+    const buffer = fse.readFileSync(file);
+    return getStringHash(buffer);
+  } catch (err) {
+    throw new Error(`${errors["unable-to-get-file-hash"]} '${err instanceof Error && err.message ? err.message : ""}'`);
+  }
+}