@depup/gatsby 5.16.1-depup.0

package/dist/utils/js-chunk-names.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.generateComponentChunkName = generateComponentChunkName;
+var _kebabCase3 = _interopRequireDefault(require("lodash/kebabCase"));
+var _memoizee = _interopRequireDefault(require("memoizee"));
+var _murmurhash2 = require("gatsby-core-utils/murmurhash");
+var _path = _interopRequireDefault(require("path"));
+var _redux = require("../redux");
+const kebabCase = (0, _memoizee.default)(_kebabCase3.default);
+const pathRelative = (0, _memoizee.default)(_path.default.relative);
+const murmurhash = (0, _memoizee.default)(_murmurhash2.murmurhash);
+
+// unified routes adds support for files with [] and {},
+// the problem with our generateComponentChunkName is that when you
+// call kebabCase, is strips off characters like that. This means
+// that when you have a app with this sort of setup, the resolutions fail
+//
+// src/pages/products/{id}.js (collection route)
+// src/pages/products/[...id].js (should render when a non-matched id is passed in)
+//
+// without this function, what happens is that all visits to /products/__ resolve to only one
+// of these because the componentChunkName ends up being duplicate. This function ensures that
+// the {} and [] are kept in the componentChunkName. Also there are tests for this.
+function replaceUnifiedRoutesKeys(kebabedName, filePath) {
+  let newString = kebabedName;
+  filePath.split(_path.default.sep).forEach(part => {
+    if (part[0] === `[` || part[0] === `{`) {
+      const match = /(\[(.*)\]|\{(.*)\})/.exec(part);
+      newString = newString.replace(`-${match[2] || match[3]}-`, `-${match[0]}-`);
+    }
+  });
+  return newString;
+}
+const chunkNameCache = new Map();
+function generateComponentChunkName(componentPath, kind = `component`) {
+  if (chunkNameCache.has(componentPath)) {
+    return chunkNameCache.get(componentPath);
+  } else {
+    const {
+      program
+    } = _redux.store.getState();
+    const directory = (program === null || program === void 0 ? void 0 : program.directory) || `/`;
+    let name = pathRelative(directory, componentPath);
+    if (name.includes(`__contentFilePath`)) {
+      name = name.replace(/__contentFilePath=([^&]*)/, (_match, contentFilePath) => `__contentFilePath=${pathRelative(directory, contentFilePath)}`);
+    }
+    name = replaceUnifiedRoutesKeys(kebabCase(name), name);
+
+    /**
+     * File names should not exceed 255 characters
+     * minus 12 for `component---`
+     * minus 7 for `.js.map`
+     * minus 20 for `-[hash].js`
+     */
+    const maxLength = 215;
+    const shouldTruncate = name.length > maxLength;
+
+    /**
+     * To prevent long file name errors, we truncate the name to a maximum of 60 characters.
+     */
+    if (shouldTruncate) {
+      const hash = murmurhash(name, 0);
+      name = `${hash}-${name.substring(name.length - 60)}`;
+    }
+    const chunkName = `${kind}---${name}`;
+    chunkNameCache.set(componentPath, chunkName);
+    return chunkName;
+  }
+}
+//# sourceMappingURL=js-chunk-names.js.map

package/dist/utils/js-chunk-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-chunk-names.js","names":["kebabCase","memoize","pathRelative","path","relative","murmurhash","_murmurhash","replaceUnifiedRoutesKeys","kebabedName","filePath","newString","split","sep","forEach","part","match","exec","replace","chunkNameCache","Map","generateComponentChunkName","componentPath","kind","has","get","program","store","getState","directory","name","includes","_match","contentFilePath","maxLength","shouldTruncate","length","hash","substring","chunkName","set"],"sources":["../../src/utils/js-chunk-names.ts"],"sourcesContent":["import memoize from \"memoizee\"\nimport { kebabCase as _kebabCase } from \"lodash\"\nimport { murmurhash as _murmurhash } from \"gatsby-core-utils/murmurhash\"\nimport path from \"path\"\nimport { store } from \"../redux\"\n\nconst kebabCase: (string?: string) => string = memoize(_kebabCase)\nconst pathRelative: (from: string, to: string) => string = memoize(\n  path.relative\n)\nconst murmurhash: (str: string, seed: number) => number = memoize(_murmurhash)\n\n// unified routes adds support for files with [] and {},\n// the problem with our generateComponentChunkName is that when you\n// call kebabCase, is strips off characters like that. This means\n// that when you have a app with this sort of setup, the resolutions fail\n//\n// src/pages/products/{id}.js (collection route)\n// src/pages/products/[...id].js (should render when a non-matched id is passed in)\n//\n// without this function, what happens is that all visits to /products/__ resolve to only one\n// of these because the componentChunkName ends up being duplicate. This function ensures that\n// the {} and [] are kept in the componentChunkName. Also there are tests for this.\nfunction replaceUnifiedRoutesKeys(\n  kebabedName: string,\n  filePath: string\n): string {\n  let newString = kebabedName\n\n  filePath.split(path.sep).forEach(part => {\n    if (part[0] === `[` || part[0] === `{`) {\n      const match = /(\\[(.*)\\]|\\{(.*)\\})/.exec(part)\n      newString = newString.replace(\n        `-${match![2] || match![3]}-`,\n        `-${match![0]}-`\n      )\n    }\n  })\n\n  return newString\n}\n\nconst chunkNameCache = new Map()\nexport function generateComponentChunkName(\n  componentPath: string,\n  kind: \"component\" | \"slice\" = `component`\n): string {\n  if (chunkNameCache.has(componentPath)) {\n    return chunkNameCache.get(componentPath)\n  } else {\n    const { program } = store.getState()\n    const directory = program?.directory || `/`\n    let name = pathRelative(directory, componentPath)\n    if (name.includes(`__contentFilePath`)) {\n      name = name.replace(\n        /__contentFilePath=([^&]*)/,\n        (_match, contentFilePath) =>\n          `__contentFilePath=${pathRelative(directory, contentFilePath)}`\n      )\n    }\n    name = replaceUnifiedRoutesKeys(kebabCase(name), name)\n\n    /**\n     * File names should not exceed 255 characters\n     * minus 12 for `component---`\n     * minus 7 for `.js.map`\n     * minus 20 for `-[hash].js`\n     */\n    const maxLength = 215\n    const shouldTruncate = name.length > maxLength\n\n    /**\n     * To prevent long file name errors, we truncate the name to a maximum of 60 characters.\n     */\n    if (shouldTruncate) {\n      const hash = murmurhash(name, 0)\n      name = `${hash}-${name.substring(name.length - 60)}`\n    }\n\n    const chunkName = `${kind}---${name}`\n\n    chunkNameCache.set(componentPath, chunkName)\n\n    return chunkName\n  }\n}\n"],"mappings":";;;;;;AAAA;AAEA;AACA;AACA;AAEA,MAAMA,SAAsC,GAAG,IAAAC,iBAAO,sBAAY;AAClE,MAAMC,YAAkD,GAAG,IAAAD,iBAAO,EAChEE,aAAI,CAACC,QAAQ,CACd;AACD,MAAMC,UAAiD,GAAG,IAAAJ,iBAAO,EAACK,uBAAW,CAAC;;AAE9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,wBAAwB,CAC/BC,WAAmB,EACnBC,QAAgB,EACR;EACR,IAAIC,SAAS,GAAGF,WAAW;EAE3BC,QAAQ,CAACE,KAAK,CAACR,aAAI,CAACS,GAAG,CAAC,CAACC,OAAO,CAACC,IAAI,IAAI;IACvC,IAAIA,IAAI,CAAC,CAAC,CAAC,KAAM,GAAE,IAAIA,IAAI,CAAC,CAAC,CAAC,KAAM,GAAE,EAAE;MACtC,MAAMC,KAAK,GAAG,qBAAqB,CAACC,IAAI,CAACF,IAAI,CAAC;MAC9CJ,SAAS,GAAGA,SAAS,CAACO,OAAO,CAC1B,IAAGF,KAAK,CAAE,CAAC,CAAC,IAAIA,KAAK,CAAE,CAAC,CAAE,GAAE,EAC5B,IAAGA,KAAK,CAAE,CAAC,CAAE,GAAE,CACjB;IACH;EACF,CAAC,CAAC;EAEF,OAAOL,SAAS;AAClB;AAEA,MAAMQ,cAAc,GAAG,IAAIC,GAAG,EAAE;AACzB,SAASC,0BAA0B,CACxCC,aAAqB,EACrBC,IAA2B,GAAI,WAAU,EACjC;EACR,IAAIJ,cAAc,CAACK,GAAG,CAACF,aAAa,CAAC,EAAE;IACrC,OAAOH,cAAc,CAACM,GAAG,CAACH,aAAa,CAAC;EAC1C,CAAC,MAAM;IACL,MAAM;MAAEI;IAAQ,CAAC,GAAGC,YAAK,CAACC,QAAQ,EAAE;IACpC,MAAMC,SAAS,GAAG,CAAAH,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEG,SAAS,KAAK,GAAE;IAC3C,IAAIC,IAAI,GAAG3B,YAAY,CAAC0B,SAAS,EAAEP,aAAa,CAAC;IACjD,IAAIQ,IAAI,CAACC,QAAQ,CAAE,mBAAkB,CAAC,EAAE;MACtCD,IAAI,GAAGA,IAAI,CAACZ,OAAO,CACjB,2BAA2B,EAC3B,CAACc,MAAM,EAAEC,eAAe,KACrB,qBAAoB9B,YAAY,CAAC0B,SAAS,EAAEI,eAAe,CAAE,EAAC,CAClE;IACH;IACAH,IAAI,GAAGtB,wBAAwB,CAACP,SAAS,CAAC6B,IAAI,CAAC,EAAEA,IAAI,CAAC;;IAEtD;AACJ;AACA;AACA;AACA;AACA;IACI,MAAMI,SAAS,GAAG,GAAG;IACrB,MAAMC,cAAc,GAAGL,IAAI,CAACM,MAAM,GAAGF,SAAS;;IAE9C;AACJ;AACA;IACI,IAAIC,cAAc,EAAE;MAClB,MAAME,IAAI,GAAG/B,UAAU,CAACwB,IAAI,EAAE,CAAC,CAAC;MAChCA,IAAI,GAAI,GAAEO,IAAK,IAAGP,IAAI,CAACQ,SAAS,CAACR,IAAI,CAACM,MAAM,GAAG,EAAE,CAAE,EAAC;IACtD;IAEA,MAAMG,SAAS,GAAI,GAAEhB,IAAK,MAAKO,IAAK,EAAC;IAErCX,cAAc,CAACqB,GAAG,CAAClB,aAAa,EAAEiB,SAAS,CAAC;IAE5C,OAAOA,SAAS;EAClB;AACF"}

package/dist/utils/loading-indicator.d.ts

@@ -0,0 +1,3 @@
+import { Express } from "express";
+export declare function writeVirtualLoadingIndicatorModule(): void;
+export declare function routeLoadingIndicatorRequests(app: Express): void;

package/dist/utils/loading-indicator.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.routeLoadingIndicatorRequests = routeLoadingIndicatorRequests;
+exports.writeVirtualLoadingIndicatorModule = writeVirtualLoadingIndicatorModule;
+var _gatsbyWebpackVirtualModules = require("./gatsby-webpack-virtual-modules");
+// set value to undefined first, because env vars needed to determine if indicator
+// should ever be enabled by default might not be set yet - we set it to "initial"
+// first time we write out module if loading indicator is allowed
+// "initial" means that browser will decide if it should show it
+// for now we do disable it by default when running in cypress
+// to not cause problems for users when they iterate on their E2E tests
+// this check could be expanded in the future to add support for more scenarios
+// like that.
+let indicatorEnabled = undefined;
+function writeVirtualLoadingIndicatorModule() {
+  if (indicatorEnabled === undefined) {
+    indicatorEnabled = process.env.GATSBY_QUERY_ON_DEMAND && process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true` ? `auto` : false;
+  }
+  (0, _gatsbyWebpackVirtualModules.writeModule)(`$virtual/loading-indicator.js`, `
+    export function isLoadingIndicatorEnabled() {
+    return ${indicatorEnabled === `auto` ? `\`Cypress\` in window
+          ? false
+          : true` : JSON.stringify(indicatorEnabled)}
+  }`);
+}
+function routeLoadingIndicatorRequests(app) {
+  app.get(`/___loading-indicator/:method?`, (req, res) => {
+    if (req.params.method === `enable` && indicatorEnabled !== true) {
+      indicatorEnabled = true;
+      writeVirtualLoadingIndicatorModule();
+    } else if (req.params.method === `disable` && indicatorEnabled !== false) {
+      indicatorEnabled = false;
+      writeVirtualLoadingIndicatorModule();
+    } else if (req.params.method === `auto` && indicatorEnabled !== `auto`) {
+      indicatorEnabled = `auto`;
+      writeVirtualLoadingIndicatorModule();
+    }
+    res.status(200).send({
+      status: indicatorEnabled === `auto` ? `auto` : indicatorEnabled ? `enabled` : `disabled`
+    });
+  });
+}
+//# sourceMappingURL=loading-indicator.js.map

package/dist/utils/loading-indicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-indicator.js","names":["indicatorEnabled","undefined","writeVirtualLoadingIndicatorModule","process","env","GATSBY_QUERY_ON_DEMAND","GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR","writeModule","JSON","stringify","routeLoadingIndicatorRequests","app","get","req","res","params","method","status","send"],"sources":["../../src/utils/loading-indicator.ts"],"sourcesContent":["import { Express } from \"express\"\nimport { writeModule } from \"./gatsby-webpack-virtual-modules\"\n\n// set value to undefined first, because env vars needed to determine if indicator\n// should ever be enabled by default might not be set yet - we set it to \"initial\"\n// first time we write out module if loading indicator is allowed\n// \"initial\" means that browser will decide if it should show it\n// for now we do disable it by default when running in cypress\n// to not cause problems for users when they iterate on their E2E tests\n// this check could be expanded in the future to add support for more scenarios\n// like that.\nlet indicatorEnabled: \"auto\" | true | false | undefined = undefined\n\nexport function writeVirtualLoadingIndicatorModule(): void {\n  if (indicatorEnabled === undefined) {\n    indicatorEnabled =\n      process.env.GATSBY_QUERY_ON_DEMAND &&\n      process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true`\n        ? `auto`\n        : false\n  }\n\n  writeModule(\n    `$virtual/loading-indicator.js`,\n    `\n    export function isLoadingIndicatorEnabled() {\n    return ${\n      indicatorEnabled === `auto`\n        ? `\\`Cypress\\` in window\n          ? false\n          : true`\n        : JSON.stringify(indicatorEnabled)\n    }\n  }`\n  )\n}\n\nexport function routeLoadingIndicatorRequests(app: Express): void {\n  app.get(`/___loading-indicator/:method?`, (req, res) => {\n    if (req.params.method === `enable` && indicatorEnabled !== true) {\n      indicatorEnabled = true\n      writeVirtualLoadingIndicatorModule()\n    } else if (req.params.method === `disable` && indicatorEnabled !== false) {\n      indicatorEnabled = false\n      writeVirtualLoadingIndicatorModule()\n    } else if (req.params.method === `auto` && indicatorEnabled !== `auto`) {\n      indicatorEnabled = `auto`\n      writeVirtualLoadingIndicatorModule()\n    }\n\n    res.status(200).send({\n      status:\n        indicatorEnabled === `auto`\n          ? `auto`\n          : indicatorEnabled\n          ? `enabled`\n          : `disabled`,\n    })\n  })\n}\n"],"mappings":";;;;;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAIA,gBAAmD,GAAGC,SAAS;AAE5D,SAASC,kCAAkC,GAAS;EACzD,IAAIF,gBAAgB,KAAKC,SAAS,EAAE;IAClCD,gBAAgB,GACdG,OAAO,CAACC,GAAG,CAACC,sBAAsB,IAClCF,OAAO,CAACC,GAAG,CAACE,wCAAwC,KAAM,MAAK,GAC1D,MAAK,GACN,KAAK;EACb;EAEA,IAAAC,wCAAW,EACR,+BAA8B,EAC9B;AACL;AACA,aACMP,gBAAgB,KAAM,MAAK,GACtB;AACX;AACA,iBAAiB,GACPQ,IAAI,CAACC,SAAS,CAACT,gBAAgB,CACpC;AACL,IAAI,CACD;AACH;AAEO,SAASU,6BAA6B,CAACC,GAAY,EAAQ;EAChEA,GAAG,CAACC,GAAG,CAAE,gCAA+B,EAAE,CAACC,GAAG,EAAEC,GAAG,KAAK;IACtD,IAAID,GAAG,CAACE,MAAM,CAACC,MAAM,KAAM,QAAO,IAAIhB,gBAAgB,KAAK,IAAI,EAAE;MAC/DA,gBAAgB,GAAG,IAAI;MACvBE,kCAAkC,EAAE;IACtC,CAAC,MAAM,IAAIW,GAAG,CAACE,MAAM,CAACC,MAAM,KAAM,SAAQ,IAAIhB,gBAAgB,KAAK,KAAK,EAAE;MACxEA,gBAAgB,GAAG,KAAK;MACxBE,kCAAkC,EAAE;IACtC,CAAC,MAAM,IAAIW,GAAG,CAACE,MAAM,CAACC,MAAM,KAAM,MAAK,IAAIhB,gBAAgB,KAAM,MAAK,EAAE;MACtEA,gBAAgB,GAAI,MAAK;MACzBE,kCAAkC,EAAE;IACtC;IAEAY,GAAG,CAACG,MAAM,CAAC,GAAG,CAAC,CAACC,IAAI,CAAC;MACnBD,MAAM,EACJjB,gBAAgB,KAAM,MAAK,GACtB,MAAK,GACNA,gBAAgB,GACf,SAAQ,GACR;IACT,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ"}

package/dist/utils/local-eslint-config-finder.d.ts

@@ -0,0 +1 @@
+export declare const hasLocalEslint: (directory: string) => boolean;

package/dist/utils/local-eslint-config-finder.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.hasLocalEslint = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _glob = _interopRequireDefault(require("glob"));
+var _debug = _interopRequireDefault(require("debug"));
+var _reporter = _interopRequireDefault(require("gatsby-cli/lib/reporter"));
+const log = (0, _debug.default)(`gatsby:webpack-eslint-config`);
+const hasLocalEslint = directory => {
+  try {
+    log(`Attempting to load package.json for eslint config check`);
+    const pkg = require(_path.default.resolve(directory, `package.json`));
+    if (pkg.eslintConfig) {
+      return true;
+    }
+  } catch (err) {
+    _reporter.default.error(`There was a problem processing the package.json file`, err);
+  }
+  log(`Checking for eslint config file`);
+  const eslintFiles = _glob.default.sync(`.eslintrc?(.js|.json|.yaml|.yml)`, {
+    cwd: directory
+  });
+  if (eslintFiles.length) {
+    return true;
+  }
+  return false;
+};
+exports.hasLocalEslint = hasLocalEslint;
+//# sourceMappingURL=local-eslint-config-finder.js.map

package/dist/utils/local-eslint-config-finder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-eslint-config-finder.js","names":["log","debug","hasLocalEslint","directory","pkg","require","path","resolve","eslintConfig","err","report","error","eslintFiles","glob","sync","cwd","length"],"sources":["../../src/utils/local-eslint-config-finder.ts"],"sourcesContent":["import path from \"path\"\nimport glob from \"glob\"\nimport debug from \"debug\"\nimport report from \"gatsby-cli/lib/reporter\"\n\nconst log = debug(`gatsby:webpack-eslint-config`)\n\nexport const hasLocalEslint = (directory: string): boolean => {\n  try {\n    log(`Attempting to load package.json for eslint config check`)\n\n    const pkg = require(path.resolve(directory, `package.json`))\n    if (pkg.eslintConfig) {\n      return true\n    }\n  } catch (err) {\n    report.error(`There was a problem processing the package.json file`, err)\n  }\n\n  log(`Checking for eslint config file`)\n  const eslintFiles = glob.sync(`.eslintrc?(.js|.json|.yaml|.yml)`, {\n    cwd: directory,\n  })\n\n  if (eslintFiles.length) {\n    return true\n  }\n\n  return false\n}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AAEA,MAAMA,GAAG,GAAG,IAAAC,cAAK,EAAE,8BAA6B,CAAC;AAE1C,MAAMC,cAAc,GAAIC,SAAiB,IAAc;EAC5D,IAAI;IACFH,GAAG,CAAE,yDAAwD,CAAC;IAE9D,MAAMI,GAAG,GAAGC,OAAO,CAACC,aAAI,CAACC,OAAO,CAACJ,SAAS,EAAG,cAAa,CAAC,CAAC;IAC5D,IAAIC,GAAG,CAACI,YAAY,EAAE;MACpB,OAAO,IAAI;IACb;EACF,CAAC,CAAC,OAAOC,GAAG,EAAE;IACZC,iBAAM,CAACC,KAAK,CAAE,sDAAqD,EAAEF,GAAG,CAAC;EAC3E;EAEAT,GAAG,CAAE,iCAAgC,CAAC;EACtC,MAAMY,WAAW,GAAGC,aAAI,CAACC,IAAI,CAAE,kCAAiC,EAAE;IAChEC,GAAG,EAAEZ;EACP,CAAC,CAAC;EAEF,IAAIS,WAAW,CAACI,MAAM,EAAE;IACtB,OAAO,IAAI;EACb;EAEA,OAAO,KAAK;AACd,CAAC;AAAA"}

package/dist/utils/merge-gatsby-config.d.ts

@@ -0,0 +1,28 @@
+import { Express } from "express";
+import type { TrailingSlash } from "gatsby-page-utils";
+export interface IPluginEntryWithParentDir {
+    resolve: string;
+    options?: Record<string, unknown>;
+    parentDir: string;
+}
+export type PluginEntry = string | IPluginEntryWithParentDir;
+export interface IGatsbyConfigInput {
+    siteMetadata?: Record<string, unknown>;
+    plugins?: Array<PluginEntry>;
+    pathPrefix?: string;
+    assetPrefix?: string;
+    polyfill?: boolean;
+    mapping?: Record<string, string>;
+    proxy?: {
+        prefix: string;
+        url: string;
+    };
+    developMiddleware?(app: Express): void;
+    jsxRuntime?: "classic" | "automatic";
+    jsxImportSource?: string;
+    trailingSlash?: TrailingSlash;
+}
+/**
+ * Defines how a theme object is merged with the user's config
+ */
+export declare const mergeGatsbyConfig: (a: IGatsbyConfigInput, b: IGatsbyConfigInput) => IGatsbyConfigInput;

package/dist/utils/merge-gatsby-config.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.mergeGatsbyConfig = void 0;
+var _uniq2 = _interopRequireDefault(require("lodash/uniq"));
+var _merge2 = _interopRequireDefault(require("lodash/merge"));
+const howToMerge = {
+  /**
+   * pick a truthy value by default.
+   * This makes sure that if a single value is defined, that one it used.
+   * We prefer the "right" value, because the user's config will be "on the right"
+   */
+  byDefault: (a, b) => b || a,
+  siteMetadata: (objA, objB) => (0, _merge2.default)({}, objA, objB),
+  // plugins are concatenated and uniq'd, so we don't get two of the same plugin value
+  plugins: (a = [], b = []) => a.concat(b),
+  mapping: (objA, objB) => (0, _merge2.default)({}, objA, objB)
+};
+
+/**
+ * Defines how a theme object is merged with the user's config
+ */
+const mergeGatsbyConfig = (a, b) => {
+  // a and b are gatsby configs, If they have keys, that means there are values to merge
+  const allGatsbyConfigKeysWithAValue = (0, _uniq2.default)(Object.keys(a).concat(Object.keys(b)));
+
+  // reduce the array of mergable keys into a single gatsby config object
+  const mergedConfig = allGatsbyConfigKeysWithAValue.reduce((config, gatsbyConfigKey) => {
+    // choose a merge function for the config key if there's one defined,
+    // otherwise use the default value merge function
+    const mergeFn = howToMerge[gatsbyConfigKey] || howToMerge.byDefault;
+    return {
+      ...config,
+      [gatsbyConfigKey]: mergeFn(a[gatsbyConfigKey], b[gatsbyConfigKey])
+    };
+  }, {});
+
+  // return the fully merged config
+  return mergedConfig;
+};
+exports.mergeGatsbyConfig = mergeGatsbyConfig;
+//# sourceMappingURL=merge-gatsby-config.js.map

package/dist/utils/merge-gatsby-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-gatsby-config.js","names":["howToMerge","byDefault","a","b","siteMetadata","objA","objB","plugins","concat","mapping","mergeGatsbyConfig","allGatsbyConfigKeysWithAValue","Object","keys","mergedConfig","reduce","config","gatsbyConfigKey","mergeFn"],"sources":["../../src/utils/merge-gatsby-config.ts"],"sourcesContent":["import _ from \"lodash\"\nimport { Express } from \"express\"\nimport type { TrailingSlash } from \"gatsby-page-utils\"\n\nexport interface IPluginEntryWithParentDir {\n  resolve: string\n  options?: Record<string, unknown>\n  parentDir: string\n}\n// TODO export it in index.d.ts\nexport type PluginEntry = string | IPluginEntryWithParentDir\n\nexport interface IGatsbyConfigInput {\n  siteMetadata?: Record<string, unknown>\n  plugins?: Array<PluginEntry>\n  pathPrefix?: string\n  assetPrefix?: string\n  polyfill?: boolean\n  mapping?: Record<string, string>\n  proxy?: {\n    prefix: string\n    url: string\n  }\n  developMiddleware?(app: Express): void\n  jsxRuntime?: \"classic\" | \"automatic\"\n  jsxImportSource?: string\n  trailingSlash?: TrailingSlash\n}\n\ntype ConfigKey = keyof IGatsbyConfigInput\ntype Metadata = IGatsbyConfigInput[\"siteMetadata\"]\ntype Mapping = IGatsbyConfigInput[\"mapping\"]\n\nconst howToMerge = {\n  /**\n   * pick a truthy value by default.\n   * This makes sure that if a single value is defined, that one it used.\n   * We prefer the \"right\" value, because the user's config will be \"on the right\"\n   */\n  byDefault: (a: ConfigKey, b: ConfigKey): ConfigKey => b || a,\n  siteMetadata: (objA: Metadata, objB: Metadata): Metadata =>\n    _.merge({}, objA, objB),\n  // plugins are concatenated and uniq'd, so we don't get two of the same plugin value\n  plugins: (\n    a: Array<PluginEntry> = [],\n    b: Array<PluginEntry> = []\n  ): Array<PluginEntry> => a.concat(b),\n  mapping: (objA: Mapping, objB: Mapping): Mapping => _.merge({}, objA, objB),\n} as const\n\n/**\n * Defines how a theme object is merged with the user's config\n */\nexport const mergeGatsbyConfig = (\n  a: IGatsbyConfigInput,\n  b: IGatsbyConfigInput\n): IGatsbyConfigInput => {\n  // a and b are gatsby configs, If they have keys, that means there are values to merge\n  const allGatsbyConfigKeysWithAValue = _.uniq(\n    Object.keys(a).concat(Object.keys(b))\n  ) as Array<ConfigKey>\n\n  // reduce the array of mergable keys into a single gatsby config object\n  const mergedConfig = allGatsbyConfigKeysWithAValue.reduce(\n    (config, gatsbyConfigKey) => {\n      // choose a merge function for the config key if there's one defined,\n      // otherwise use the default value merge function\n      const mergeFn = howToMerge[gatsbyConfigKey] || howToMerge.byDefault\n      return {\n        ...config,\n        [gatsbyConfigKey]: mergeFn(a[gatsbyConfigKey], b[gatsbyConfigKey]),\n      }\n    },\n    {} as IGatsbyConfigInput\n  )\n\n  // return the fully merged config\n  return mergedConfig\n}\n"],"mappings":";;;;;;;AAiCA,MAAMA,UAAU,GAAG;EACjB;AACF;AACA;AACA;AACA;EACEC,SAAS,EAAE,CAACC,CAAY,EAAEC,CAAY,KAAgBA,CAAC,IAAID,CAAC;EAC5DE,YAAY,EAAE,CAACC,IAAc,EAAEC,IAAc,KAC3C,qBAAQ,CAAC,CAAC,EAAED,IAAI,EAAEC,IAAI,CAAC;EACzB;EACAC,OAAO,EAAE,CACPL,CAAqB,GAAG,EAAE,EAC1BC,CAAqB,GAAG,EAAE,KACHD,CAAC,CAACM,MAAM,CAACL,CAAC,CAAC;EACpCM,OAAO,EAAE,CAACJ,IAAa,EAAEC,IAAa,KAAc,qBAAQ,CAAC,CAAC,EAAED,IAAI,EAAEC,IAAI;AAC5E,CAAU;;AAEV;AACA;AACA;AACO,MAAMI,iBAAiB,GAAG,CAC/BR,CAAqB,EACrBC,CAAqB,KACE;EACvB;EACA,MAAMQ,6BAA6B,GAAG,oBACpCC,MAAM,CAACC,IAAI,CAACX,CAAC,CAAC,CAACM,MAAM,CAACI,MAAM,CAACC,IAAI,CAACV,CAAC,CAAC,CAAC,CAClB;;EAErB;EACA,MAAMW,YAAY,GAAGH,6BAA6B,CAACI,MAAM,CACvD,CAACC,MAAM,EAAEC,eAAe,KAAK;IAC3B;IACA;IACA,MAAMC,OAAO,GAAGlB,UAAU,CAACiB,eAAe,CAAC,IAAIjB,UAAU,CAACC,SAAS;IACnE,OAAO;MACL,GAAGe,MAAM;MACT,CAACC,eAAe,GAAGC,OAAO,CAAChB,CAAC,CAACe,eAAe,CAAC,EAAEd,CAAC,CAACc,eAAe,CAAC;IACnE,CAAC;EACH,CAAC,EACD,CAAC,CAAC,CACH;;EAED;EACA,OAAOH,YAAY;AACrB,CAAC;AAAA"}

package/dist/utils/mett.d.ts

@@ -0,0 +1,10 @@
+type MettHandler<EventName, Payload> = (e: Payload, eventName: EventName) => void;
+export interface IMett {
+    on(eventName: EventName, callback: MettHandler<EventName, Payload>): void;
+    off(eventName: EventName, callback: MettHandler<EventName, Payload>): void;
+    emit(eventName: EventName, e?: Payload): void;
+}
+type EventName = string;
+type Payload = any;
+export declare function mett(): IMett;
+export {};

package/dist/utils/mett.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports.mett = mett;
+// This is a simple event emitter based on mitt.js
+// It mainly changes the data model to use a Map and Set, rather than a
+// regular object and an array.
+
+function mett() {
+  const mettEvents = new Map();
+  return {
+    on(eventName, callback) {
+      const set = mettEvents.get(eventName);
+      if (set) {
+        set.add(callback);
+      } else {
+        mettEvents.set(eventName, new Set([callback]));
+      }
+    },
+    off(eventName, callback) {
+      const set = mettEvents.get(eventName);
+      if (set) {
+        set.delete(callback);
+      }
+    },
+    emit(eventName, e) {
+      const setName = mettEvents.get(eventName);
+      if (setName) {
+        setName.forEach(function mettEmitEachC(callback) {
+          callback(e, eventName);
+        });
+      }
+      const setStar = mettEvents.get(`*`);
+      if (setStar) {
+        setStar.forEach(function mettEmitEachStar(callback) {
+          callback(e, eventName);
+        });
+      }
+    }
+  };
+}
+//# sourceMappingURL=mett.js.map

package/dist/utils/mett.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mett.js","names":["mett","mettEvents","Map","on","eventName","callback","set","get","add","Set","off","delete","emit","e","setName","forEach","mettEmitEachC","setStar","mettEmitEachStar"],"sources":["../../src/utils/mett.ts"],"sourcesContent":["// This is a simple event emitter based on mitt.js\n// It mainly changes the data model to use a Map and Set, rather than a\n// regular object and an array.\n\ntype MettHandler<EventName, Payload> = (\n  e: Payload,\n  eventName: EventName\n) => void\n\nexport interface IMett {\n  on(eventName: EventName, callback: MettHandler<EventName, Payload>): void\n  off(eventName: EventName, callback: MettHandler<EventName, Payload>): void\n  emit(eventName: EventName, e?: Payload): void\n}\n\ntype EventName = string\ntype Payload = any\n\nexport function mett(): IMett {\n  const mettEvents: Map<\n    EventName,\n    Set<MettHandler<EventName, Payload>>\n  > = new Map()\n\n  return {\n    on(eventName: EventName, callback: MettHandler<EventName, Payload>): void {\n      const set = mettEvents.get(eventName)\n      if (set) {\n        set.add(callback)\n      } else {\n        mettEvents.set(eventName, new Set([callback]))\n      }\n    },\n    off(eventName: EventName, callback: MettHandler<EventName, Payload>): void {\n      const set = mettEvents.get(eventName)\n      if (set) {\n        set.delete(callback)\n      }\n    },\n    emit(eventName: EventName, e: Payload): void {\n      const setName = mettEvents.get(eventName)\n      if (setName) {\n        setName.forEach(function mettEmitEachC(callback) {\n          callback(e, eventName)\n        })\n      }\n      const setStar = mettEvents.get(`*`)\n      if (setStar) {\n        setStar.forEach(function mettEmitEachStar(callback) {\n          callback(e, eventName)\n        })\n      }\n    },\n  }\n}\n"],"mappings":";;;;AAAA;AACA;AACA;;AAgBO,SAASA,IAAI,GAAU;EAC5B,MAAMC,UAGL,GAAG,IAAIC,GAAG,EAAE;EAEb,OAAO;IACLC,EAAE,CAACC,SAAoB,EAAEC,QAAyC,EAAQ;MACxE,MAAMC,GAAG,GAAGL,UAAU,CAACM,GAAG,CAACH,SAAS,CAAC;MACrC,IAAIE,GAAG,EAAE;QACPA,GAAG,CAACE,GAAG,CAACH,QAAQ,CAAC;MACnB,CAAC,MAAM;QACLJ,UAAU,CAACK,GAAG,CAACF,SAAS,EAAE,IAAIK,GAAG,CAAC,CAACJ,QAAQ,CAAC,CAAC,CAAC;MAChD;IACF,CAAC;IACDK,GAAG,CAACN,SAAoB,EAAEC,QAAyC,EAAQ;MACzE,MAAMC,GAAG,GAAGL,UAAU,CAACM,GAAG,CAACH,SAAS,CAAC;MACrC,IAAIE,GAAG,EAAE;QACPA,GAAG,CAACK,MAAM,CAACN,QAAQ,CAAC;MACtB;IACF,CAAC;IACDO,IAAI,CAACR,SAAoB,EAAES,CAAU,EAAQ;MAC3C,MAAMC,OAAO,GAAGb,UAAU,CAACM,GAAG,CAACH,SAAS,CAAC;MACzC,IAAIU,OAAO,EAAE;QACXA,OAAO,CAACC,OAAO,CAAC,SAASC,aAAa,CAACX,QAAQ,EAAE;UAC/CA,QAAQ,CAACQ,CAAC,EAAET,SAAS,CAAC;QACxB,CAAC,CAAC;MACJ;MACA,MAAMa,OAAO,GAAGhB,UAAU,CAACM,GAAG,CAAE,GAAE,CAAC;MACnC,IAAIU,OAAO,EAAE;QACXA,OAAO,CAACF,OAAO,CAAC,SAASG,gBAAgB,CAACb,QAAQ,EAAE;UAClDA,QAAQ,CAACQ,CAAC,EAAET,SAAS,CAAC;QACxB,CAAC,CAAC;MACJ;IACF;EACF,CAAC;AACH"}

package/dist/utils/module-resolver.d.ts

@@ -0,0 +1,2 @@
+export type ModuleResolver = (modulePath: string) => string | false;
+export declare const resolveModule: ModuleResolver;

package/dist/utils/module-resolver.js

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.__esModule = true;
+exports.resolveModule = void 0;
+var fs = _interopRequireWildcard(require("fs"));
+var _enhancedResolve = _interopRequireWildcard(require("enhanced-resolve"));
+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; }
+const resolveModule = modulePath => {
+  let resolve;
+  try {
+    resolve = _enhancedResolve.default.create.sync({
+      fileSystem: new _enhancedResolve.CachedInputFileSystem(fs, 5000),
+      extensions: [`.ts`, `.tsx`, `.js`, `.jsx`]
+    });
+  } catch (err) {
+    // ignore
+  }
+
+  // @ts-ignore - See https://github.com/microsoft/TypeScript/issues/9568
+  return resolve({}, modulePath, modulePath);
+};
+exports.resolveModule = resolveModule;
+//# sourceMappingURL=module-resolver.js.map

package/dist/utils/module-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-resolver.js","names":["resolveModule","modulePath","resolve","enhancedResolve","create","sync","fileSystem","CachedInputFileSystem","fs","extensions","err"],"sources":["../../src/utils/module-resolver.ts"],"sourcesContent":["import * as fs from \"fs\"\nimport enhancedResolve, { CachedInputFileSystem } from \"enhanced-resolve\"\n\nexport type ModuleResolver = (modulePath: string) => string | false\ntype ResolveType = (context?: any, path?: any, request?: any) => string | false\n\nexport const resolveModule: ModuleResolver = modulePath => {\n  let resolve: ResolveType\n\n  try {\n    resolve = enhancedResolve.create.sync({\n      fileSystem: new CachedInputFileSystem(fs, 5000),\n      extensions: [`.ts`, `.tsx`, `.js`, `.jsx`],\n    })\n  } catch (err) {\n    // ignore\n  }\n\n  // @ts-ignore - See https://github.com/microsoft/TypeScript/issues/9568\n  return resolve({}, modulePath, modulePath)\n}\n"],"mappings":";;;;AAAA;AACA;AAAyE;AAAA;AAKlE,MAAMA,aAA6B,GAAGC,UAAU,IAAI;EACzD,IAAIC,OAAoB;EAExB,IAAI;IACFA,OAAO,GAAGC,wBAAe,CAACC,MAAM,CAACC,IAAI,CAAC;MACpCC,UAAU,EAAE,IAAIC,sCAAqB,CAACC,EAAE,EAAE,IAAI,CAAC;MAC/CC,UAAU,EAAE,CAAE,KAAI,EAAG,MAAK,EAAG,KAAI,EAAG,MAAK;IAC3C,CAAC,CAAC;EACJ,CAAC,CAAC,OAAOC,GAAG,EAAE;IACZ;EAAA;;EAGF;EACA,OAAOR,OAAO,CAAC,CAAC,CAAC,EAAED,UAAU,EAAEA,UAAU,CAAC;AAC5C,CAAC;AAAA"}

package/dist/utils/node-manifest.d.ts

@@ -0,0 +1,46 @@
+import { INodeManifest } from "./../redux/types";
+interface INodeManifestPage {
+    path?: string;
+}
+/**
+ * This it the output after processing calls to the public unstable_createNodeManifest action
+ */
+interface INodeManifestOut {
+    page: INodeManifestPage;
+    node: {
+        id: string;
+    };
+    foundPageBy: FoundPageBy;
+}
+type FoundPageBy = `ownerNodeId` | `filesystem-route-api` | `context.id` | `context.slug` | `queryTracking` | `none`;
+type PreviouslyWrittenNodeManifests = Map<string, Promise<INodeManifestOut>>;
+export declare const foundPageByToLogIds: {
+    none: string;
+    "context.id": string;
+    "context.slug": string;
+    queryTracking: string;
+    "filesystem-route-api": string;
+    ownerNodeId: string;
+};
+/**
+ * Takes in some info about a node manifest and the page we did or didn't find for it, then warns and returns the warning string
+ */
+export declare function warnAboutNodeManifestMappingProblems({ inputManifest, pagePath, foundPageBy, verbose, }: {
+    inputManifest: INodeManifest;
+    pagePath?: string;
+    foundPageBy: FoundPageBy;
+    verbose: boolean;
+}): {
+    logId: string;
+};
+/**
+ * Prepares and then writes out an individual node manifest file to be used for routing to previews. Manifest files are added via the public unstable_createNodeManifest action
+ */
+export declare function processNodeManifest(inputManifest: INodeManifest, listOfUniqueErrorIds: Set<string>, nodeManifestPagePathMap: Map<string, string>, verboseLogs: boolean, previouslyWrittenNodeManifests: PreviouslyWrittenNodeManifests): Promise<null | INodeManifestOut>;
+/**
+ * Grabs all pending node manifests, processes them, writes them to disk,
+ * and then removes them from the store.
+ * Manifest files are added via the public unstable_createNodeManifest action in sourceNodes
+ */
+export declare function processNodeManifests(): Promise<Map<string, string> | null>;
+export {};