houdini 1.0.0-next.1 → 1.0.0-next.3

package/build/runtime-cjs/client/documentStore.d.ts

@@ -0,0 +1,87 @@
+import type { HoudiniClient } from '.';
+import type { Layer } from '../cache/storage';
+import type { ConfigFile } from '../lib/config';
+import { Writable } from '../lib/store';
+import type { CachePolicy, DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec } from '../lib/types';
+export declare class DocumentStore<_Data extends GraphQLObject, _Input extends Record<string, any>> extends Writable<QueryResult<_Data, _Input>> {
+    #private;
+    constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
+        artifact: DocumentArtifact;
+        plugins?: ClientPlugin[];
+        pipeline?: ClientPlugin[];
+        client: HoudiniClient;
+        cache?: boolean;
+        initialValue?: _Data | null;
+        fetching?: boolean;
+    });
+    send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, }?: {
+        fetch?: Fetch;
+        variables?: Record<string, any> | null;
+        metadata?: App.Metadata | null;
+        session?: App.Session | null;
+        policy?: CachePolicy;
+        stuff?: Partial<App.Stuff>;
+        cacheParams?: ClientPluginContext['cacheParams'];
+        setup?: boolean;
+    }): Promise<QueryResult<_Data, _Input>>;
+}
+declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
+export type ClientPlugin = () => {
+    start?: ClientPluginEnterPhase;
+    beforeNetwork?: ClientPluginEnterPhase;
+    network?: ClientPluginEnterPhase;
+    afterNetwork?: ClientPluginExitPhase;
+    end?: ClientPluginExitPhase;
+    cleanup?(ctx: ClientPluginContext): void | Promise<void>;
+    catch?(ctx: ClientPluginContext, args: ClientPluginErrorHandlers): void | Promise<void>;
+};
+export type Fetch = typeof globalThis.fetch;
+export type ClientPluginContext = {
+    config: ConfigFile;
+    text: string;
+    hash: string;
+    artifact: DocumentArtifact;
+    policy?: CachePolicy;
+    fetch?: Fetch;
+    variables?: Record<string, any>;
+    metadata?: App.Metadata | null;
+    session?: App.Session | null;
+    fetchParams?: RequestInit;
+    cacheParams?: {
+        layer?: Layer;
+        notifySubscribers?: SubscriptionSpec[];
+        forceNotify?: boolean;
+        disableWrite?: boolean;
+        disableRead?: boolean;
+        applyUpdates?: boolean;
+    };
+    stuff: App.Stuff;
+};
+type ClientPluginPhase<Handlers> = (ctx: ClientPluginContext, handlers: Handlers) => void | Promise<void>;
+export type ClientPluginEnterPhase = ClientPluginPhase<ClientPluginEnterHandlers>;
+export type ClientPluginExitPhase = ClientPluginPhase<ClientPluginExitHandlers>;
+export type ClientPluginEnterHandlers = {
+    initialValue: QueryResult;
+    /** A reference to the houdini client to access any configuration values */
+    client: HoudiniClient;
+    /** Move onto the next step using the provided context.  */
+    next(ctx: ClientPluginContext): void;
+    /** Terminate the current chain  */
+    resolve(ctx: ClientPluginContext, data: QueryResult): void;
+    /** Update the stores state without resolving the promise */
+    updateState(updater: (old: QueryResult) => QueryResult): void;
+    /** Return true if the variables have changed */
+    variablesChanged: (ctx: ClientPluginContext) => boolean;
+    /** Returns the marshaled variables for the operation */
+    marshalVariables: typeof marshalVariables;
+};
+/** Exit handlers are the same as enter handles but don't need to resolve with a specific value */
+export type ClientPluginExitHandlers = Omit<ClientPluginEnterHandlers, 'resolve'> & {
+    resolve: (ctx: ClientPluginContext, data?: QueryResult) => void;
+    value: QueryResult;
+};
+/** Exit handlers are the same as enter handles but don't need to resolve with a specific value */
+export type ClientPluginErrorHandlers = ClientPluginEnterHandlers & {
+    error: unknown;
+};
+export {};

package/build/runtime-cjs/client/documentStore.js

@@ -0,0 +1,360 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var documentStore_exports = {};
+__export(documentStore_exports, {
+  DocumentStore: () => DocumentStore
+});
+module.exports = __toCommonJS(documentStore_exports);
+var import_config = require("../lib/config");
+var import_deepEquals = require("../lib/deepEquals");
+var import_scalars = require("../lib/scalars");
+var import_store = require("../lib/store");
+var import_types = require("../lib/types");
+var import_plugins = require("./plugins");
+const steps = {
+  forward: ["start", "beforeNetwork", "network"],
+  backwards: ["end", "afterNetwork"]
+};
+class DocumentStore extends import_store.Writable {
+  #artifact;
+  #client;
+  #configFile;
+  #plugins;
+  #lastVariables;
+  #lastContext = null;
+  constructor({
+    artifact,
+    plugins,
+    pipeline,
+    client,
+    cache = true,
+    initialValue,
+    fetching
+  }) {
+    if (fetching === void 0) {
+      fetching = artifact.kind === import_types.ArtifactKind.Query;
+    }
+    const initialState = {
+      data: initialValue ?? null,
+      errors: null,
+      partial: false,
+      source: null,
+      fetching,
+      variables: null
+    };
+    super(initialState, () => {
+      return () => {
+        this.#lastVariables = null;
+        for (const plugin of this.#plugins) {
+          plugin.cleanup?.(this.#lastContext);
+        }
+      };
+    });
+    this.#artifact = artifact;
+    this.#client = client;
+    this.#lastVariables = null;
+    this.#configFile = (0, import_config.getCurrentConfig)();
+    this.#plugins = (pipeline ?? [
+      (0, import_plugins.cachePolicyPlugin)({
+        enabled: cache,
+        setFetching: (fetching2) => this.update((state) => ({ ...state, fetching: fetching2 }))
+      }),
+      ...plugins ?? []
+    ]).map((factory) => factory());
+  }
+  async send({
+    metadata,
+    session,
+    fetch = globalThis.fetch,
+    variables,
+    policy,
+    stuff,
+    cacheParams,
+    setup = false
+  } = {}) {
+    let context = new ClientPluginContextWrapper({
+      config: this.#configFile,
+      text: this.#artifact.raw,
+      hash: this.#artifact.hash,
+      policy: policy ?? this.#artifact.policy,
+      variables: {},
+      metadata,
+      session,
+      fetch,
+      stuff: {
+        inputs: {
+          changed: false,
+          init: false,
+          marshaled: {}
+        },
+        ...stuff
+      },
+      artifact: this.#artifact,
+      lastVariables: this.#lastVariables,
+      cacheParams
+    });
+    const draft = context.draft();
+    draft.variables = variables ?? {};
+    context = context.apply(draft, false);
+    return await new Promise((resolve, reject) => {
+      const state = {
+        setup,
+        currentStep: 0,
+        index: 0,
+        promise: {
+          resolved: false,
+          resolve,
+          reject
+        },
+        context
+      };
+      this.#step("forward", state);
+    });
+  }
+  #step(direction, ctx, value) {
+    const hook = direction === "error" ? "catch" : steps[direction][ctx.currentStep];
+    let valid = (i) => i <= this.#plugins.length;
+    let step = (i) => i + 1;
+    if (["backwards", "error"].includes(direction)) {
+      valid = (i) => i >= 0;
+      step = (i) => i - 1;
+    }
+    for (let index = ctx.index; valid(index); index = step(index)) {
+      let target = this.#plugins[index]?.[hook];
+      if (!target) {
+        continue;
+      }
+      const draft = ctx.context.draft();
+      let variablesRefChanged = (newContext) => newContext.variables !== draft.variables;
+      const common = {
+        initialValue: this.state,
+        client: this.#client,
+        variablesChanged,
+        marshalVariables,
+        updateState: this.update.bind(this),
+        next: (newContext) => {
+          const nextIndex = ["forward", "error"].includes(direction) ? index + 1 : index;
+          const nextStep = ["backwards", "error"].includes(direction) ? 0 : ctx.currentStep;
+          this.#step("forward", {
+            ...ctx,
+            index: nextIndex,
+            currentStep: nextStep,
+            context: ctx.context.apply(newContext, variablesRefChanged(newContext))
+          });
+        },
+        resolve: (newContext, value2) => {
+          const nextIndex = direction === "backwards" ? index - 1 : index;
+          this.#step(
+            "backwards",
+            {
+              ...ctx,
+              index: nextIndex,
+              context: ctx.context.apply(newContext, variablesRefChanged(newContext))
+            },
+            value2
+          );
+        }
+      };
+      let handlers;
+      if (direction === "forward") {
+        handlers = common;
+      } else if (direction === "backwards") {
+        handlers = {
+          ...common,
+          value,
+          resolve: (ctx2, data2) => {
+            return common.resolve(ctx2, data2 ?? value);
+          }
+        };
+      } else if (direction === "error") {
+        handlers = {
+          ...common,
+          error: value
+        };
+      }
+      try {
+        const result = target(draft, handlers);
+        result?.catch((err) => {
+          this.#step("error", { ...ctx, index: index - 1 }, err);
+        });
+      } catch (err) {
+        this.#step("error", { ...ctx, index: index - 1 }, err);
+      }
+      return;
+    }
+    if (direction === "forward") {
+      if (ctx.setup) {
+        return this.#step(
+          "backwards",
+          {
+            ...ctx,
+            currentStep: 0,
+            index: this.#plugins.length
+          },
+          this.state
+        );
+      }
+      if (ctx.currentStep <= steps.forward.length - 2) {
+        return this.#step("forward", {
+          ...ctx,
+          currentStep: ctx.currentStep + 1,
+          index: 0
+        });
+      }
+      throw new Error(
+        "Called next() on last possible plugin. Your chain is missing a plugin that calls resolve()."
+      );
+    }
+    if (direction === "error") {
+      if (!ctx.promise.resolved) {
+        ctx.promise.reject(value);
+        ctx.promise.resolved = true;
+      }
+      return;
+    }
+    if (ctx.currentStep > 0) {
+      return this.#step(
+        "backwards",
+        {
+          ...ctx,
+          currentStep: ctx.currentStep - 1,
+          index: this.#plugins.length - 1
+        },
+        value
+      );
+    }
+    let data = value.data;
+    try {
+      data = (0, import_scalars.unmarshalSelection)(this.#configFile, this.#artifact.selection, data) ?? null;
+    } catch {
+    }
+    const finalValue = {
+      ...value,
+      data
+    };
+    if (!ctx.promise.resolved) {
+      ctx.promise.resolve(finalValue);
+      ctx.promise.resolved = true;
+    }
+    this.#lastContext = ctx.context.draft();
+    this.#lastVariables = this.#lastContext.stuff.inputs.marshaled;
+    this.set(finalValue);
+  }
+}
+class ClientPluginContextWrapper {
+  #context;
+  #lastVariables;
+  constructor({
+    lastVariables,
+    ...values
+  }) {
+    this.#context = values;
+    this.#lastVariables = lastVariables;
+  }
+  get variables() {
+    return this.#context.variables;
+  }
+  draft() {
+    const ctx = {
+      ...this.#context
+    };
+    const applyVariables = this.applyVariables.bind(this);
+    return {
+      ...ctx,
+      get stuff() {
+        return ctx.stuff;
+      },
+      set stuff(val) {
+        ctx.stuff = val;
+      },
+      get variables() {
+        return ctx.variables ?? {};
+      },
+      set variables(val) {
+        Object.assign(ctx, applyVariables(ctx, { variables: val }));
+      }
+    };
+  }
+  applyVariables(source, values) {
+    const artifact = source.artifact;
+    const ctx = {
+      ...source,
+      ...values
+    };
+    const val = values.variables;
+    let changed = {};
+    for (const [name, value] of Object.entries(val ?? {})) {
+      if (value !== source.variables?.[name]) {
+        changed[name] = value;
+      }
+    }
+    ctx.stuff = {
+      ...ctx.stuff,
+      inputs: {
+        ...ctx.stuff.inputs
+      }
+    };
+    const firstInit = !ctx.stuff.inputs || !ctx.stuff.inputs.init;
+    const hasChanged = Object.keys(changed).length > 0 || firstInit;
+    if (artifact.kind !== import_types.ArtifactKind.Fragment && hasChanged) {
+      const newVariables = {
+        ...ctx.stuff.inputs?.marshaled,
+        ...(0, import_scalars.marshalInputs)({
+          artifact,
+          input: changed,
+          config: source.config
+        })
+      };
+      ctx.stuff.inputs = {
+        init: true,
+        marshaled: newVariables,
+        changed: true
+      };
+      ctx.variables = val;
+    }
+    ctx.stuff = {
+      ...ctx.stuff,
+      inputs: {
+        ...ctx.stuff.inputs,
+        changed: !(0, import_deepEquals.deepEquals)(ctx.stuff.inputs.marshaled, this.#lastVariables)
+      }
+    };
+    return ctx;
+  }
+  apply(values, newVariables) {
+    if (newVariables) {
+      values = this.applyVariables(this.#context, values);
+    }
+    const wrapper = new ClientPluginContextWrapper({
+      ...values,
+      lastVariables: this.#lastVariables
+    });
+    return wrapper;
+  }
+}
+function marshalVariables(ctx) {
+  return ctx.stuff.inputs?.marshaled ?? {};
+}
+function variablesChanged(ctx) {
+  return ctx.stuff.inputs?.changed;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocumentStore
+});

package/build/runtime-cjs/client/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference path="../../../../../houdini.d.ts" />
+import type { DocumentArtifact, GraphQLObject } from '../lib/types';
+import type { ClientPlugin } from './documentStore';
+import { DocumentStore } from './documentStore';
+import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
+export { DocumentStore, type ClientPlugin } from './documentStore';
+export { fetchPlugin, mutationPlugin, queryPlugin, subscriptionPlugin } from './plugins';
+type ConstructorArgs = {
+    url: string;
+    fetchParams?: FetchParamFn;
+    plugins?: ClientPlugin[];
+    pipeline?: ClientPlugin[];
+    throwOnError?: ThrowOnErrorParams;
+};
+export declare class HoudiniClient {
+    #private;
+    url: string;
+    constructor({ url, fetchParams, plugins, pipeline, throwOnError }: ConstructorArgs);
+    observe<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, cache, initialValue, fetching, }: {
+        artifact: DocumentArtifact;
+        cache?: boolean;
+        initialValue?: _Data | null;
+        fetching?: boolean;
+    }): DocumentStore<_Data, _Input>;
+}

package/build/runtime-cjs/client/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  DocumentStore: () => import_documentStore2.DocumentStore,
+  HoudiniClient: () => HoudiniClient,
+  fetchPlugin: () => import_plugins2.fetchPlugin,
+  mutationPlugin: () => import_plugins2.mutationPlugin,
+  queryPlugin: () => import_plugins2.queryPlugin,
+  subscriptionPlugin: () => import_plugins2.subscriptionPlugin
+});
+module.exports = __toCommonJS(client_exports);
+var import_documentStore = require("./documentStore");
+var import_plugins = require("./plugins");
+var import_injectedPlugins = __toESM(require("./plugins/injectedPlugins"), 1);
+var import_documentStore2 = require("./documentStore");
+var import_plugins2 = require("./plugins");
+class HoudiniClient {
+  url;
+  #plugins;
+  constructor({ url, fetchParams, plugins, pipeline, throwOnError }) {
+    if (plugins && pipeline) {
+      throw new Error(
+        "A client cannot be given a pipeline and a list of plugins at the same time."
+      );
+    }
+    this.#plugins = [].concat(
+      throwOnError ? [(0, import_plugins.throwOnErrorPlugin)(throwOnError)] : [],
+      (0, import_plugins.fetchParamsPlugin)(fetchParams),
+      pipeline ?? [
+        import_plugins.queryPlugin,
+        import_plugins.mutationPlugin
+      ].concat(
+        plugins ?? [],
+        import_injectedPlugins.default,
+        (0, import_plugins.fetchPlugin)()
+      )
+    );
+    this.url = url;
+  }
+  observe({
+    artifact,
+    cache = true,
+    initialValue,
+    fetching = false
+  }) {
+    return new import_documentStore.DocumentStore({
+      client: this,
+      artifact,
+      plugins: this.#plugins,
+      cache,
+      initialValue,
+      fetching
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocumentStore,
+  HoudiniClient,
+  fetchPlugin,
+  mutationPlugin,
+  queryPlugin,
+  subscriptionPlugin
+});

package/build/runtime-cjs/client/plugins/cache.d.ts

@@ -0,0 +1,8 @@
+import cache from '../../cache';
+import type { Cache } from '../../cache/cache';
+import type { ClientPlugin } from '../documentStore';
+export declare const cachePolicyPlugin: ({ enabled, setFetching, cache: localCache, }: {
+    enabled: boolean;
+    setFetching: (val: boolean) => void;
+    cache?: Cache | undefined;
+}) => ClientPlugin;

package/build/runtime-cjs/client/plugins/cache.js

@@ -0,0 +1,99 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  cachePolicyPlugin: () => cachePolicyPlugin
+});
+module.exports = __toCommonJS(cache_exports);
+var import_cache = __toESM(require("../../cache"), 1);
+var import_types = require("../../lib/types");
+const cachePolicyPlugin = ({
+  enabled,
+  setFetching,
+  cache: localCache = import_cache.default
+}) => () => {
+  return {
+    network(ctx, { next, resolve, marshalVariables }) {
+      const { policy, artifact } = ctx;
+      let useCache = false;
+      if (enabled && artifact.kind === import_types.ArtifactKind.Query && !ctx.cacheParams?.disableRead) {
+        if (policy !== import_types.CachePolicy.NetworkOnly) {
+          const value = localCache.read({
+            selection: artifact.selection,
+            variables: marshalVariables(ctx)
+          });
+          const allowed = !value.partial || artifact.kind === import_types.ArtifactKind.Query && artifact.partial;
+          if (policy === import_types.CachePolicy.CacheOnly) {
+            return resolve(ctx, {
+              fetching: false,
+              variables: ctx.variables ?? null,
+              data: value.data,
+              errors: null,
+              source: import_types.DataSource.Cache,
+              partial: value.partial
+            });
+          }
+          useCache = !!(value.data !== null && allowed);
+          if (useCache) {
+            resolve(ctx, {
+              fetching: false,
+              variables: ctx.variables ?? null,
+              data: value.data,
+              errors: null,
+              source: import_types.DataSource.Cache,
+              partial: value.partial
+            });
+          }
+          if (useCache && !value.partial) {
+            return;
+          }
+        }
+      }
+      if (enabled) {
+        setTimeout(() => {
+          localCache._internal_unstable.collectGarbage();
+        }, 0);
+      }
+      setFetching(!useCache);
+      return next(ctx);
+    },
+    afterNetwork(ctx, { resolve, value, marshalVariables }) {
+      if (value.source !== import_types.DataSource.Cache && enabled && value.data && !ctx.cacheParams?.disableWrite) {
+        localCache.write({
+          ...ctx.cacheParams,
+          layer: ctx.cacheParams?.layer?.id,
+          selection: ctx.artifact.selection,
+          data: value.data,
+          variables: marshalVariables(ctx)
+        });
+      }
+      resolve(ctx, value);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cachePolicyPlugin
+});

package/build/runtime-cjs/client/plugins/fetch.d.ts

@@ -0,0 +1,37 @@
+import type { RequestPayload } from '../../lib/types';
+import type { ClientPlugin } from '../documentStore';
+export declare const fetchPlugin: (target?: RequestHandler | string) => ClientPlugin;
+export type FetchContext = {
+    fetch: typeof globalThis.fetch;
+    metadata?: App.Metadata | null;
+    session: App.Session | null;
+};
+/**
+ * ## Tip 👇
+ *
+ * To define types for your metadata, create a file `src/app.d.ts` containing the followingI:
+ *
+ * ```ts
+ * declare namespace App { *
+ * 	interface Metadata {}
+ * }
+ * ```
+ *
+ */
+export type RequestHandlerArgs = FetchContext & FetchParams;
+export type RequestHandler<_Data = any> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
+export type FetchParams = {
+    text: string;
+    hash: string;
+    variables: {
+        [key: string]: any;
+    };
+};
+export declare function isExtractableFile(value: any): value is ExtractableFile;
+type ExtractableFile = File | Blob;
+/** @typedef {import("./isExtractableFile.mjs").default} isExtractableFile */
+export declare function extractFiles(value: any): {
+    clone: any;
+    files: Map<any, any>;
+};
+export {};