gatsby 4.24.8-alpha-wordpress-image-err.6 → 4.24.8

package/dist/bootstrap/__mocks__/get-config/ts-dir/gatsby-config.d.ts

@@ -0,0 +1,3 @@
+import type { GatsbyConfig } from "gatsby";
+declare const config: GatsbyConfig;
+export default config;

package/dist/bootstrap/__mocks__/resolve-module-exports.d.ts

@@ -0,0 +1 @@
+export declare const resolveModuleExports: (input: unknown) => Array<string> | undefined;

package/dist/bootstrap/create-graphql-runner.d.ts

@@ -0,0 +1,10 @@
+import { Span } from "opentracing";
+import { ExecutionResult, Source } from "graphql";
+import { Store } from "redux";
+import { Reporter } from "../..";
+import { IGatsbyState } from "../redux/types";
+export declare type Runner = (query: string | Source, context: Record<string, any>) => Promise<ExecutionResult>;
+export declare const createGraphQLRunner: (store: Store<IGatsbyState>, reporter: Reporter, { parentSpan, graphqlTracing, }?: {
+    parentSpan: Span | undefined;
+    graphqlTracing?: boolean | undefined;
+}) => Runner;

package/dist/bootstrap/get-config-file.d.ts

@@ -0,0 +1,4 @@
+export declare function getConfigFile(siteDirectory: string, configName: string, distance?: number): Promise<{
+    configModule: any;
+    configFilePath: string;
+}>;

package/dist/bootstrap/index.d.ts

@@ -0,0 +1,10 @@
+import { IBuildContext } from "../services";
+import { Runner } from "./create-graphql-runner";
+import type { GatsbyWorkerPool } from "../utils/worker/pool";
+import { IProgram } from "../commands/types";
+export declare function bootstrap(initialContext: Partial<IBuildContext> & {
+    program: IProgram;
+}): Promise<{
+    gatsbyNodeGraphQLFunction: Runner;
+    workerPool: GatsbyWorkerPool;
+}>;

package/dist/bootstrap/load-config/index.d.ts

@@ -0,0 +1,7 @@
+import { IProgram } from "../../commands/types";
+import { IGatsbyConfig } from "../../internal";
+export declare function loadConfig({ siteDirectory, processFlags, }: {
+    siteDirectory: string;
+    processFlags?: boolean;
+    program?: IProgram;
+}): Promise<IGatsbyConfig>;

package/dist/bootstrap/load-plugins/index.d.ts

@@ -0,0 +1,3 @@
+import { IFlattenedPlugin } from "./types";
+import { IGatsbyConfig } from "../../internal";
+export declare function loadPlugins(rawConfig: IGatsbyConfig, rootDir: string): Promise<Array<IFlattenedPlugin>>;

package/dist/bootstrap/load-plugins/load-internal-plugins.d.ts

@@ -0,0 +1,2 @@
+import { IPluginInfo, ISiteConfig } from "./types";
+export declare function loadInternalPlugins(config: ISiteConfig | undefined, rootDir: string): Array<IPluginInfo>;

package/dist/bootstrap/load-plugins/process-plugin.d.ts

@@ -0,0 +1,2 @@
+import { IPluginInfo, PluginRef } from "./types";
+export declare function processPlugin(plugin: PluginRef, rootDir: string): IPluginInfo;

package/dist/bootstrap/load-plugins/resolve-plugin.d.ts

@@ -0,0 +1,13 @@
+import { IPluginInfo, PluginRef } from "./types";
+/**
+ * @param plugin
+ * This should be a plugin spec object where possible but can also be the
+ * name of a plugin.
+ *
+ * When it is a name, it can be a name of a local plugin, the name of a plugin
+ * located in node_modules, or a Gatsby internal plugin. In the last case the
+ * plugin will be an absolute path.
+ * @param rootDir
+ * This is the project location, from which are found the plugins
+ */
+export declare function resolvePlugin(plugin: PluginRef, rootDir: string): IPluginInfo;

package/dist/bootstrap/load-plugins/types.d.ts

@@ -0,0 +1,48 @@
+export interface IRawSiteConfig {
+    plugins?: Array<PluginRef>;
+}
+export interface ISiteConfig extends IRawSiteConfig {
+    plugins?: Array<IPluginRefObject>;
+}
+export interface IPluginInfo {
+    /** Unique ID describing a plugin */
+    id: string;
+    /** The absolute path to the plugin */
+    resolve: string;
+    /** The absolute path to the compiled plugin's gatsby-node module, if there is one */
+    resolvedCompiledGatsbyNode?: string;
+    /** The plugin name */
+    name: string;
+    /** The plugin version (can be content hash) */
+    version: string;
+    /** Options passed to the plugin */
+    pluginOptions?: IPluginInfoOptions;
+    subPluginPaths?: Array<string>;
+    module?: any;
+    modulePath?: string;
+}
+export interface IPluginInfoOptions {
+    plugins?: Array<IPluginInfo>;
+    path?: string;
+    [option: string]: unknown;
+}
+export interface IFlattenedPlugin extends IPluginInfo {
+    skipSSR?: boolean;
+    ssrAPIs: Array<string>;
+    nodeAPIs: Array<string>;
+    browserAPIs: Array<string>;
+}
+export interface IPluginRefObject {
+    resolve: string;
+    options?: IPluginRefOptions;
+    parentDir?: string;
+    subPluginPaths?: Array<string>;
+    module?: any;
+    modulePath?: string;
+}
+export declare type PluginRef = string | IPluginRefObject;
+export interface IPluginRefOptions {
+    plugins?: Array<PluginRef>;
+    path?: string;
+    [option: string]: unknown;
+}

package/dist/bootstrap/load-plugins/utils/check-local-plugin.d.ts

@@ -0,0 +1,8 @@
+import { PluginRef } from "../types";
+/**
+ * Checks if a plugin is a valid local plugin and returns the resolved path if it is.
+ */
+export declare function checkLocalPlugin(plugin: PluginRef, rootDir: string): {
+    validLocalPlugin: boolean;
+    localPluginPath?: string;
+};

package/dist/bootstrap/load-plugins/utils/create-hash.d.ts

@@ -0,0 +1 @@
+export declare function createFileContentHash(root: string, globPattern: string): string;

package/dist/bootstrap/load-plugins/utils/create-id.d.ts

@@ -0,0 +1,10 @@
+import { IPluginRefObject } from "../types";
+/**
+ * Make sure key is unique to plugin options. E.g. there could
+ * be multiple source-filesystem plugins, with different names
+ * (docs, blogs).
+ *
+ * @param name Name of the plugin
+ * @param pluginObject Object of the plugin
+ */
+export declare const createPluginId: (name: string, pluginObject?: IPluginRefObject | null) => string;

package/dist/bootstrap/load-plugins/utils/flatten-plugins.d.ts

@@ -0,0 +1,2 @@
+import { IPluginInfo } from "../types";
+export declare const flattenPlugins: (plugins: Array<IPluginInfo>) => Array<IPluginInfo>;

package/dist/bootstrap/load-plugins/utils/get-api.d.ts

@@ -0,0 +1,12 @@
+import { ExportType, ICurrentAPIs } from "../validate";
+export declare const getAPI: (api: {
+    node: {
+        [api: string]: boolean;
+    };
+    browser: {
+        [api: string]: boolean;
+    };
+    ssr: {
+        [api: string]: boolean;
+    };
+}) => ICurrentAPIs;

package/dist/bootstrap/load-plugins/utils/handle-gatsby-cloud.d.ts

@@ -0,0 +1,6 @@
+import { IPluginInfo } from "../types";
+export declare const GATSBY_CLOUD_PLUGIN_NAME = "gatsby-plugin-gatsby-cloud";
+export declare const GATSBY_PLUGIN_PREVIEW_NAME = "@gatsby-cloud-pkg/gatsby-plugin-preview";
+export declare function addGatsbyPluginPreviewWhenInstalled(plugins: Array<IPluginInfo>, rootDir: string): void;
+export declare function addGatsbyPluginCloudPluginWhenInstalled(plugins: Array<IPluginInfo>, rootDir: string): void;
+export declare function incompatibleGatsbyCloudPlugin(plugins: Array<IPluginInfo>): boolean;

package/dist/bootstrap/load-plugins/utils/normalize.d.ts

@@ -0,0 +1,5 @@
+import { ISiteConfig, IRawSiteConfig } from "../types";
+import { IPluginRefObject, PluginRef } from "gatsby-plugin-utils/dist/types";
+export declare function normalizePlugin(plugin: IPluginRefObject | string): IPluginRefObject;
+export declare function normalizePlugins(plugins?: Array<PluginRef>): Array<IPluginRefObject>;
+export declare const normalizeConfig: (config?: IRawSiteConfig) => ISiteConfig;

package/dist/bootstrap/load-plugins/validate.d.ts

@@ -0,0 +1,40 @@
+import { PackageJson } from "../../../";
+import { IPluginInfo, IFlattenedPlugin, ISiteConfig } from "./types";
+interface IApi {
+    version?: string;
+}
+export interface IEntry {
+    exportName: string;
+    pluginName: string;
+    pluginVersion: string;
+    api?: IApi;
+}
+export declare type ExportType = "node" | "browser" | "ssr";
+declare type IEntryMap = {
+    [exportType in ExportType]: Array<IEntry>;
+};
+export declare type ICurrentAPIs = {
+    [exportType in ExportType]: Array<string>;
+};
+export declare function handleBadExports({ currentAPIs, badExports, }: {
+    currentAPIs: ICurrentAPIs;
+    badExports: {
+        [api in ExportType]: Array<IEntry>;
+    };
+}): Promise<void>;
+export declare function validateConfigPluginsOptions(config: ISiteConfig | undefined, rootDir: string): Promise<void>;
+/**
+ * Identify which APIs each plugin exports
+ */
+export declare function collatePluginAPIs({ currentAPIs, flattenedPlugins, }: {
+    currentAPIs: ICurrentAPIs;
+    flattenedPlugins: Array<IPluginInfo & Partial<IFlattenedPlugin>>;
+}): {
+    flattenedPlugins: Array<IFlattenedPlugin>;
+    badExports: IEntryMap;
+};
+export declare const handleMultipleReplaceRenderers: ({ flattenedPlugins, }: {
+    flattenedPlugins: Array<IFlattenedPlugin>;
+}) => Array<IFlattenedPlugin>;
+export declare function warnOnIncompatiblePeerDependency(name: string, packageJSON: PackageJson): void;
+export {};

package/dist/bootstrap/prefer-default.d.ts

@@ -0,0 +1 @@
+export declare const preferDefault: (m: any) => any;

package/dist/bootstrap/redirects-writer.d.ts

@@ -0,0 +1,2 @@
+export declare const writeRedirects: () => Promise<void>;
+export declare const startRedirectListener: () => void;

package/dist/bootstrap/remove-stale-jobs.d.ts

@@ -0,0 +1,2 @@
+import { IGatsbyState, IRemoveStaleJobV2Action, ICreateJobV2FromInternalAction } from "../redux/types";
+export declare const removeStaleJobs: (jobs: IGatsbyState["jobsV2"]) => Array<IRemoveStaleJobV2Action | ICreateJobV2FromInternalAction>;

package/dist/bootstrap/requires-writer.d.ts

@@ -0,0 +1,10 @@
+import { IGatsbyState, IGatsbyPage } from "../redux/types";
+interface IGatsbyPageComponent {
+    component: string;
+    componentChunkName: string;
+}
+export declare const resetLastHash: () => void;
+export declare const getComponents: (pages: Array<IGatsbyPage>) => Array<IGatsbyPageComponent>;
+export declare const writeAll: (state: IGatsbyState) => Promise<boolean>;
+export declare const startListener: () => void;
+export {};

package/dist/bootstrap/resolve-module-exports.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Given a `require.resolve()` compatible path pointing to a JS module,
+ * return an array listing the names of the module's exports.
+ *
+ * Returns [] for invalid paths and modules without exports.
+ *
+ * @param modulePath
+ * @param mode
+ * @param resolver
+ */
+export declare const resolveModuleExports: (modulePath: string, { mode, resolver }?: {
+    mode?: string | undefined;
+    resolver?: ((modulePath: string) => string | false) | undefined;
+}) => Array<string>;

package/dist/bootstrap/schema-hot-reloader.d.ts

@@ -0,0 +1,3 @@
+export declare function bootstrapSchemaHotReloader(): void;
+export declare function startSchemaHotReloader(): void;
+export declare function stopSchemaHotReloader(): void;

package/dist/cache/cache-fs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cache/json-file-store.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+declare const promisify: any;
+declare const fs: any;
+declare const zlib: any;
+interface IExternalBuffer {
+    index: number;
+    buffer: Buffer;
+}

package/dist/commands/build-html.d.ts

@@ -0,0 +1,53 @@
+import { watch } from "../utils/webpack/bundle";
+import webpack from "webpack";
+import { Span } from "opentracing";
+import { IProgram, Stage } from "./types";
+import { PackageJson } from "../..";
+import type { GatsbyWorkerPool } from "../utils/worker/pool";
+declare type IActivity = any;
+export interface IBuildArgs extends IProgram {
+    directory: string;
+    sitePackageJson: PackageJson;
+    prefixPaths: boolean;
+    noUglify: boolean;
+    logPages: boolean;
+    writeToFile: boolean;
+    profile: boolean;
+    graphqlTracing: boolean;
+    openTracingConfigFile: string;
+    keepPageRenderer: boolean;
+}
+interface IBuildRendererResult {
+    rendererPath: string;
+    stats: webpack.Stats;
+    close: ReturnType<typeof watch>["close"];
+}
+export declare function devSSRWillInvalidate(): void;
+export declare const getDevSSRWebpack: () => {
+    recompileAndResumeWatching: (allowTimedFallback: boolean) => Promise<() => void>;
+    needToRecompileSSRBundle: boolean;
+};
+export declare const buildRenderer: (program: IProgram, stage: Stage, parentSpan?: IActivity) => Promise<IBuildRendererResult>;
+export declare const buildPartialHydrationRenderer: (program: IProgram, stage: Stage, parentSpan?: IActivity) => Promise<IBuildRendererResult>;
+export declare const deleteRenderer: (rendererPath: string) => Promise<void>;
+export interface IRenderHtmlResult {
+    unsafeBuiltinsUsageByPagePath: Record<string, Array<string>>;
+    previewErrors: Record<string, any>;
+}
+export declare const doBuildPages: (rendererPath: string, pagePaths: Array<string>, activity: IActivity, workerPool: GatsbyWorkerPool, stage: Stage) => Promise<void>;
+export declare const buildHTML: ({ program, stage, pagePaths, activity, workerPool, }: {
+    program: IProgram;
+    stage: Stage;
+    pagePaths: Array<string>;
+    activity: IActivity;
+    workerPool: GatsbyWorkerPool;
+}) => Promise<void>;
+export declare function buildHTMLPagesAndDeleteStaleArtifacts({ workerPool, parentSpan, program, }: {
+    workerPool: GatsbyWorkerPool;
+    parentSpan?: Span;
+    program: IBuildArgs;
+}): Promise<{
+    toRegenerate: Array<string>;
+    toDelete: Array<string>;
+}>;
+export {};

package/dist/commands/build-javascript.d.ts

@@ -0,0 +1,4 @@
+import { Span } from "opentracing";
+import { build } from "../utils/webpack/bundle";
+import type { IProgram } from "./types";
+export declare const buildProductionBundle: (program: IProgram, parentSpan: Span) => Promise<ReturnType<typeof build>>;

package/dist/commands/build-utils.d.ts

@@ -0,0 +1,8 @@
+import { IGatsbyState } from "../redux/types";
+export declare const removePageFiles: (publicDir: string, pageKeys: Array<string>) => Promise<void>;
+export declare function calcDirtyHtmlFiles(state: IGatsbyState): {
+    toRegenerate: Array<string>;
+    toDelete: Array<string>;
+    toCleanupFromTrackedState: Set<string>;
+};
+export declare function markHtmlDirtyIfResultOfUsedStaticQueryChanged(): void;

package/dist/commands/build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/clean.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/develop-process.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/develop-static.d.ts

@@ -0,0 +1,3 @@
+import express from "express";
+import { ServeStaticOptions } from "serve-static";
+export declare function developStatic(root: string, options: ServeStaticOptions): express.Handler;

package/dist/commands/develop.d.ts

@@ -0,0 +1,2 @@
+import { IProgram, IDebugInfo } from "./types";
+export declare const getDebugInfo: (program: IProgram) => IDebugInfo | null;

package/dist/commands/feedback.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/repl.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/serve.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/types.d.ts

@@ -0,0 +1,48 @@
+import { PackageJson, Reporter } from "gatsby";
+import { Store, AnyAction } from "redux";
+import { IGatsbyState } from "../redux/types";
+export interface ICert {
+    key: string;
+    cert: string;
+}
+export interface IDebugInfo {
+    port: number;
+    break: boolean;
+}
+export interface IProgram {
+    _: `develop` | `build` | `clean` | `feedback` | `repl` | `serve`;
+    status?: string;
+    useYarn: boolean;
+    open: boolean;
+    openTracingConfigFile: string;
+    port: number;
+    proxyPort: number;
+    host: string;
+    report: Reporter;
+    [`cert-file`]?: string;
+    [`key-file`]?: string;
+    directory: string;
+    https?: boolean;
+    sitePackageJson: PackageJson;
+    ssl?: ICert;
+    inspect?: number;
+    inspectBrk?: number;
+    graphqlTracing?: boolean;
+    verbose?: boolean;
+    prefixPaths?: boolean;
+    setStore?: (store: Store<IGatsbyState, AnyAction>) => void;
+}
+/**
+ * @deprecated
+ * Use `Stage` instead
+ */
+export declare enum BuildHTMLStage {
+    DevelopHTML = "develop-html",
+    BuildHTML = "build-html"
+}
+export declare enum Stage {
+    Develop = "develop",
+    DevelopHTML = "develop-html",
+    BuildJavascript = "build-javascript",
+    BuildHTML = "build-html"
+}

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const ROUTES_DIRECTORY = ".cache/page-ssr/routes/";

package/dist/datastore/common/iterable.d.ts

@@ -0,0 +1,51 @@
+declare module "lmdb" {
+    function clearKeptObjects(): void;
+}
+/**
+ * Wrapper for any iterable providing chainable interface and convenience methods
+ * similar to array.
+ *
+ * Additionally provides convenience methods for sorted iterables.
+ *
+ * Note: avoiding async iterables because of perf reasons, see https://github.com/nodejs/node/issues/31979
+ * (fortunately lmdb can traverse stuff in sync manner very fast)
+ */
+export declare class GatsbyIterable<T> {
+    private source;
+    constructor(source: Iterable<T> | (() => Iterable<T>));
+    [Symbol.iterator](): Iterator<T>;
+    concat<U>(other: Iterable<U>): GatsbyIterable<T | U>;
+    map<U>(fn: (entry: T, index: number) => U): GatsbyIterable<U>;
+    filter(predicate: (entry: T) => unknown): GatsbyIterable<T>;
+    slice(start: number, end?: number): GatsbyIterable<T>;
+    deduplicate(keyFn?: (entry: T) => unknown): GatsbyIterable<T>;
+    forEach(callback: (entry: T, index: number) => unknown): void;
+    /**
+     * Assuming both this and the other iterable are sorted
+     * produces the new sorted iterable with interleaved values.
+     *
+     * Note: this method is not removing duplicates
+     */
+    mergeSorted<U = T>(other: Iterable<U>, comparator?: (a: T | U, b: T | U) => number): GatsbyIterable<T | U>;
+    /**
+     * Assuming both this and the other iterable are sorted
+     * produces the new sorted iterable with values from this iterable
+     * that also exist in the other iterable.
+     */
+    intersectSorted<U = T>(other: Iterable<U>, comparator?: (a: T | U, b: T | U) => number): GatsbyIterable<T | U>;
+    /**
+     * Assuming this iterable is sorted, removes duplicates from it
+     * by applying comparator(prev, current) to sibling iterable values.
+     *
+     * Comparator function is expected to return 0 when items are equal,
+     * similar to Array.prototype.sort() argument.
+     *
+     * If comparator is not set, uses strict === comparison
+     */
+    deduplicateSorted(comparator?: (a: T, b: T) => number): GatsbyIterable<T>;
+}
+/**
+ * Returns true when passed value is iterable
+ */
+export declare function isIterable(obj: unknown): obj is Iterable<any>;
+export declare function isNonArrayIterable<T>(value: unknown): value is Iterable<T>;

package/dist/datastore/common/query.d.ts

@@ -0,0 +1,69 @@
+export interface IDbQueryQuery {
+    type: "query";
+    path: Array<string>;
+    query: IDbFilterStatement;
+}
+export interface IDbQueryElemMatch {
+    type: "elemMatch";
+    path: Array<string>;
+    nestedQuery: DbQuery;
+}
+export declare type DbQuery = IDbQueryQuery | IDbQueryElemMatch;
+export declare enum DbComparator {
+    EQ = "$eq",
+    NE = "$ne",
+    GT = "$gt",
+    GTE = "$gte",
+    LT = "$lt",
+    LTE = "$lte",
+    IN = "$in",
+    NIN = "$nin",
+    REGEX = "$regex",
+    GLOB = "$glob"
+}
+export declare type FilterValueNullable = string | number | boolean | null | undefined | RegExp | Array<string | number | boolean | null | undefined>;
+export declare type FilterValue = string | number | boolean | RegExp | Array<string | number | boolean>;
+export interface IInputQuery {
+    [key: string]: FilterValueNullable | IInputQuery;
+}
+export interface IPreparedQueryArg {
+    [key: string]: FilterValueNullable | IPreparedQueryArg;
+}
+export declare type DbComparatorValue = string | number | boolean | RegExp | null;
+export interface IDbFilterStatement {
+    comparator: DbComparator;
+    value: DbComparatorValue | Array<DbComparatorValue>;
+}
+/**
+ * Converts a nested mongo args object into array of DbQuery objects,
+ * structured representation of each distinct path of the query. We convert
+ * nested objects with multiple keys to separate instances.
+ */
+export declare function createDbQueriesFromObject(filter: Record<string, any>): Array<DbQuery>;
+/**
+ * Takes a DbQuery structure and returns a dotted representation of a field referenced in this query.
+ *
+ * Example:
+ * ```js
+ *   const query = createDbQueriesFromObject({
+ *     foo: { $elemMatch: { id: { $eq: 5 }, test: { $gt: 42 } } },
+ *     bar: { $in: [`bar`] }
+ *   })
+ *   const result = query.map(dbQueryToDottedField)
+ * ```
+ * Returns:
+ *   [`foo.id`, `foo.test`, `bar`]
+ */
+export declare function dbQueryToDottedField(query: DbQuery): string;
+export declare function getFilterStatement(dbQuery: DbQuery): IDbFilterStatement;
+export declare function prefixResolvedFields(queries: Array<DbQuery>, resolvedFields: Record<string, unknown>): Array<DbQuery>;
+/**
+ * Transforms filters coming from input GraphQL query to mongodb-compatible format
+ * (by prefixing comparators with "$").
+ *
+ * Example:
+ *   { foo: { eq: 5 } } -> { foo: { $eq: 5 }}
+ */
+export declare function prepareQueryArgs(filterFields?: Array<IInputQuery> | IInputQuery): IPreparedQueryArg;
+export declare function objectToDottedField(obj: Record<string, unknown>, path?: Array<string>): Record<string, unknown>;
+export declare function sortBySpecificity(all: Array<DbQuery>): Array<DbQuery>;

package/dist/datastore/datastore.d.ts

@@ -0,0 +1,4 @@
+import { IDataStore } from "./types";
+export declare function getDataStore(): IDataStore;
+export declare function isLmdbStore(): boolean;
+export declare function detectLmdbStore(): boolean;

package/dist/datastore/in-memory/in-memory-datastore.d.ts

@@ -0,0 +1,2 @@
+import { IDataStore } from "../types";
+export declare function setupInMemoryStore(): IDataStore;