houdini 2.0.0-next.9 → 2.0.0

package/build/runtime-esm/cache/subscription.d.ts

@@ -1,52 +0,0 @@
-import type { GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
-import { type Cache } from './cache';
-export type FieldSelection = [
-    SubscriptionSpec,
-    Required<SubscriptionSelection>['fields'] | undefined
-];
-export declare class InMemorySubscriptions {
-    private cache;
-    constructor(cache: Cache);
-    private subscribers;
-    private keyVersions;
-    activeFields(parent: string): string[];
-    copySubscribers(from: string, to: string): void;
-    add({ parent, spec, selection, variables, parentType, }: {
-        parent: string;
-        parentType?: string;
-        spec: SubscriptionSpec;
-        selection: SubscriptionSelection;
-        variables: {
-            [key: string]: GraphQLValue;
-        };
-    }): void;
-    addFieldSubscription({ id, key, selection, type, }: {
-        id: string;
-        key: string;
-        selection: FieldSelection;
-        type: string;
-    }): void;
-    registerList({ list, id, key, parentType, selection, filters, variables, }: {
-        list: Required<Required<SubscriptionSelection>['fields'][string]>['list'];
-        selection: SubscriptionSelection;
-        id: string;
-        parentType: string;
-        key: string;
-        filters: Required<SubscriptionSelection>['fields'][string]['filters'];
-        variables: Record<string, any>;
-    }): void;
-    addMany({ parent, variables, subscribers, parentType, }: {
-        parent: string;
-        variables: {};
-        subscribers: FieldSelection[];
-        parentType: string;
-    }): void;
-    get(id: string, field: string): FieldSelection[];
-    getAll(id: string): FieldSelection[];
-    remove(id: string, selection: SubscriptionSelection, targets: SubscriptionSpec[], variables: {}, visited?: string[]): void;
-    reset(): SubscriptionSpec[];
-    private removeSubscribers;
-    removeAllSubscribers(id: string, targets?: SubscriptionSpec[]): void;
-    get size(): number;
-    findSubSelections(parentID: string, selection: SubscriptionSelection, variables: {}, searchTarget: string, selections?: SubscriptionSelection[]): Array<SubscriptionSelection>;
-}

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

@@ -1,107 +0,0 @@
-import type { HoudiniClient } from '.';
-import type { Cache } from '../cache/cache';
-import type { Layer } from '../cache/storage';
-import type { ConfigFile } from '../lib/config';
-import { Writable } from '../lib/store';
-import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies, GraphQLVariables } from '../lib/types';
-export declare class DocumentStore<_Data extends GraphQLObject, _Input extends GraphQLVariables> extends Writable<QueryResult<_Data, _Input>> {
-    #private;
-    readonly artifact: DocumentArtifact;
-    pendingPromise: {
-        then: (val: any) => void;
-    } | null;
-    serverSideFallback?: boolean;
-    controllerKey(variables: any): string;
-    constructor({ artifact, plugins, pipeline, client, cache, enableCache, initialValue, initialVariables, fetching, }: {
-        artifact: DocumentArtifact;
-        plugins?: ClientHooks[];
-        pipeline?: ClientHooks[];
-        client: HoudiniClient | null;
-        cache?: Cache;
-        enableCache?: boolean;
-        initialValue?: _Data | null;
-        fetching?: boolean;
-        serverSideFallback?: boolean;
-        initialVariables?: _Input;
-    });
-    send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, abortController, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
-    cleanup(): Promise<void>;
-    getFetch(getSession: () => App.Session | null | undefined): (input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>;
-}
-declare function marshalVariables<_Data extends GraphQLObject, _Input extends GraphQLVariables>(ctx: ClientPluginContext): Record<string, any>;
-export type ClientPlugin = () => ClientHooks | null | (ClientHooks | ClientPlugin | null)[];
-export type ClientHooks = {
-    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;
-    name: string;
-    text: string;
-    hash: string;
-    artifact: DocumentArtifact;
-    policy?: CachePolicies;
-    fetch?: Fetch;
-    variables?: Record<string, any> | null;
-    metadata?: App.Metadata | null;
-    session?: App.Session | null;
-    fetchParams?: RequestInit;
-    abortController: AbortController;
-    cacheParams?: {
-        layer?: Layer;
-        notifySubscribers?: SubscriptionSpec[];
-        forceNotify?: boolean;
-        disableWrite?: boolean;
-        disableRead?: boolean;
-        disableSubscriptions?: boolean;
-        applyUpdates?: string[];
-        serverSideFallback?: 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 handlers 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 handlers but don't need to resolve with a specific value */
-export type ClientPluginErrorHandlers = ClientPluginEnterHandlers & {
-    error: unknown;
-};
-export type SendParams = {
-    fetch?: Fetch;
-    variables?: Record<string, any> | null;
-    metadata?: App.Metadata | null;
-    session?: App.Session | null;
-    policy?: CachePolicies;
-    stuff?: Partial<App.Stuff>;
-    cacheParams?: ClientPluginContext['cacheParams'];
-    setup?: boolean;
-    silenceEcho?: boolean;
-    abortController?: AbortController;
-};
-export {};

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

@@ -1,50 +0,0 @@
-/// <reference path="../../../../../houdini.d.ts" />
-import type { Cache } from '../cache/cache';
-import type { DocumentArtifact, GraphQLVariables, GraphQLObject, NestedList } from '../lib/types';
-import type { ClientHooks, ClientPlugin } from './documentStore';
-import { DocumentStore } from './documentStore';
-import type { FetchParamFn, ThrowOnErrorOperations, ThrowOnErrorParams } from './plugins';
-export { DocumentStore, type ClientPlugin, type SendParams } from './documentStore';
-export { fetch, mutation, query, subscription } from './plugins';
-export type HoudiniClientConstructorArgs = {
-    url?: string;
-    fetchParams?: FetchParamFn;
-    plugins?: NestedList<ClientPlugin>;
-    pipeline?: NestedList<ClientPlugin>;
-    throwOnError?: ThrowOnErrorParams;
-};
-export type ObserveParams<_Data extends GraphQLObject, _Artifact extends DocumentArtifact = DocumentArtifact, _Input extends GraphQLVariables = GraphQLVariables> = {
-    artifact: _Artifact;
-    enableCache?: boolean;
-    cache?: Cache;
-    initialValue?: _Data | null;
-    initialVariables?: _Input;
-    fetching?: boolean;
-};
-export declare class HoudiniClient {
-    url: string;
-    readonly throwOnError_operations: ThrowOnErrorOperations[];
-    private cache;
-    private throwOnError;
-    private fetchParams;
-    private pipeline;
-    private extraPlugins;
-    proxies: Record<string, (operation: {
-        query: string;
-        variables: any;
-        operationName: string;
-        session: App.Session | null | undefined;
-    }) => Promise<any>>;
-    componentCache: Record<string, any>;
-    setCache(cache: Cache): void;
-    constructor({ url, fetchParams, plugins, pipeline, throwOnError, }?: HoudiniClientConstructorArgs);
-    get plugins(): ClientPlugin[];
-    observe<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ enableCache, fetching, ...rest }: ObserveParams<_Data, DocumentArtifact, _Input>): DocumentStore<_Data, _Input>;
-    registerProxy(url: string, handler: (operation: {
-        query: string;
-        variables: any;
-        operationName: string;
-        session: App.Session | null | undefined;
-    }) => Promise<any>): void;
-}
-export declare function createPluginHooks(plugins: ClientPlugin[]): ClientHooks[];

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

@@ -1,130 +0,0 @@
-import cacheRef from "../cache";
-import { getCurrentConfig, localApiEndpoint } from "../lib";
-import { flatten } from "../lib/flatten";
-import { DocumentStore } from "./documentStore";
-import {
-  fetch as fetchPlugin,
-  fetchParams as fetchParamsPlugin,
-  fragment as fragmentPlugin,
-  mutation as mutationPlugin,
-  query as queryPlugin,
-  throwOnError as throwOnErrorPlugin,
-  optimisticKeys
-} from "./plugins";
-import pluginsFromPlugins from "./plugins/injectedPlugins";
-import { DocumentStore as DocumentStore2 } from "./documentStore";
-import { fetch, mutation, query, subscription } from "./plugins";
-class HoudiniClient {
-  // the URL of the api
-  url;
-  // expose operations settings
-  throwOnError_operations;
-  cache = null;
-  throwOnError;
-  fetchParams;
-  pipeline;
-  extraPlugins;
-  proxies = {};
-  // this is modified by page entries when they load in order to register the components source
-  componentCache = {};
-  // we need the ability to link the client up with an external cache
-  setCache(cache) {
-    this.cache = cache;
-  }
-  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.throwOnError_operations = throwOnError?.operations ?? [];
-    let serverPort = globalThis.process?.env?.HOUDINI_PORT ?? "5173";
-    this.url = url ?? (globalThis.window ? "" : `http://localhost:${serverPort}`) + localApiEndpoint(getCurrentConfig());
-    this.throwOnError = throwOnError;
-    this.fetchParams = fetchParams;
-    this.pipeline = pipeline;
-    this.extraPlugins = plugins;
-  }
-  get plugins() {
-    return flatten(
-      [].concat(
-        // if they specified a throw behavior
-        this.throwOnError ? [throwOnErrorPlugin(this.throwOnError)] : [],
-        fetchParamsPlugin(this.fetchParams),
-        // if the user wants to specify the entire pipeline, let them do so
-        this.pipeline ?? // the user doesn't have a specific pipeline so we should just add their desired plugins
-        // to the standard set
-        [
-          optimisticKeys(this.cache ?? cacheRef),
-          // make sure that documents always work
-          queryPlugin(this.cache ?? cacheRef),
-          mutationPlugin(this.cache ?? cacheRef),
-          fragmentPlugin(this.cache ?? cacheRef)
-        ].concat(
-          // add the specified middlewares
-          this.extraPlugins ?? [],
-          // and any middlewares we got from plugins
-          pluginsFromPlugins,
-          // if they provided a fetch function, use it as the body for the fetch middleware
-          fetchPlugin()
-        )
-      )
-    );
-  }
-  observe({
-    enableCache = true,
-    fetching = false,
-    ...rest
-  }) {
-    return new DocumentStore({
-      client: this,
-      plugins: createPluginHooks(this.plugins),
-      fetching,
-      enableCache,
-      cache: this.cache ?? void 0,
-      ...rest
-    });
-  }
-  registerProxy(url, handler) {
-    this.proxies[url] = handler;
-  }
-}
-function createPluginHooks(plugins) {
-  return plugins.reduce((hooks, plugin) => {
-    if (typeof plugin !== "function") {
-      throw new Error("Encountered client plugin that's not a function");
-    }
-    const result = plugin();
-    if (!result) {
-      return hooks;
-    }
-    if (!Array.isArray(result)) {
-      return hooks.concat(result);
-    }
-    for (const value of result) {
-      if (!value) {
-        continue;
-      }
-      if (typeof value === "function") {
-        return hooks.concat(createPluginHooks([value]));
-      }
-      hooks.push(value);
-    }
-    return hooks;
-  }, []);
-}
-export {
-  DocumentStore2 as DocumentStore,
-  HoudiniClient,
-  createPluginHooks,
-  fetch,
-  mutation,
-  query,
-  subscription
-};

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

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

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

@@ -1,104 +0,0 @@
-import cache from "../../cache";
-import { Cache } from "../../cache/cache";
-import { ArtifactKind, CachePolicy, DataSource } from "../../lib/types";
-const serverSide = typeof globalThis.window === "undefined";
-const cachePolicy = ({
-  enabled,
-  setFetching,
-  cache: localCache = cache,
-  serverSideFallback = true
-}) => () => {
-  return {
-    beforeNetwork(ctx, { initialValue, next, resolve, marshalVariables }) {
-      const { policy, artifact } = ctx;
-      let useCache = false;
-      if (enabled && (artifact.kind === ArtifactKind.Query || artifact.kind === ArtifactKind.Fragment) && !ctx.cacheParams?.disableRead) {
-        const policyAllowsCache = policy !== CachePolicy.NetworkOnly && policy !== CachePolicy.NoCache;
-        if (policyAllowsCache) {
-          const value = localCache.read({
-            selection: artifact.selection,
-            variables: marshalVariables(ctx),
-            fullCheck: true
-          });
-          const allowed = !value.partial || // or the artifact allows for partial responses
-          artifact.kind === ArtifactKind.Query && artifact.partial;
-          if (policy === CachePolicy.CacheOnly) {
-            return resolve(ctx, {
-              fetching: false,
-              variables: ctx.variables ?? null,
-              data: allowed ? value.data : initialValue.data,
-              errors: null,
-              source: DataSource.Cache,
-              partial: allowed ? value.partial : false,
-              stale: value.stale
-            });
-          }
-          useCache = !!(value.data !== null && allowed);
-          if (useCache) {
-            resolve(ctx, {
-              fetching: false,
-              variables: ctx.variables ?? null,
-              data: value.data,
-              errors: null,
-              source: DataSource.Cache,
-              partial: value.partial,
-              stale: value.stale
-            });
-          }
-          if (useCache && !value.partial && !value.stale && // if the policy is CacheAndNetwork then we don't want to stop here regardless
-          ctx.policy !== "CacheAndNetwork") {
-            return;
-          }
-        }
-      }
-      if (enabled) {
-        setTimeout(() => {
-          localCache._internal_unstable.collectGarbage();
-        }, 0);
-      }
-      if (!ctx.stuff?.silenceLoading) {
-        let fetchingState = null;
-        if (!useCache && "enableLoadingState" in artifact && artifact.enableLoadingState) {
-          fetchingState = localCache.read({
-            selection: artifact.selection,
-            variables: marshalVariables(ctx),
-            loading: true
-          }).data;
-        }
-        setFetching(!useCache, fetchingState);
-      }
-      return next(ctx);
-    },
-    afterNetwork(ctx, { resolve, value, marshalVariables }) {
-      if (ctx.policy !== CachePolicy.NoCache && value.source !== DataSource.Cache && enabled && value.data && !ctx.cacheParams?.disableWrite) {
-        if (ctx.cacheParams && "serverSideFallback" in ctx.cacheParams) {
-          serverSideFallback = ctx.cacheParams?.serverSideFallback ?? serverSideFallback;
-        }
-        const targetCache = serverSide && serverSideFallback ? new Cache({ disabled: false }) : localCache;
-        let layer;
-        if (!serverSide && ctx.cacheParams?.layer) {
-          layer = ctx.cacheParams.layer.id;
-        }
-        targetCache.write({
-          ...ctx.cacheParams,
-          layer,
-          selection: ctx.artifact.selection,
-          data: value.data,
-          variables: marshalVariables(ctx)
-        });
-        value = {
-          ...value,
-          data: targetCache.read({
-            selection: ctx.artifact.selection,
-            variables: marshalVariables(ctx),
-            ignoreMasking: serverSide
-          }).data
-        };
-      }
-      resolve(ctx, value);
-    }
-  };
-};
-export {
-  cachePolicy
-};

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

@@ -1,38 +0,0 @@
-import type { RequestPayload } from '../../lib/types';
-import type { ClientPlugin } from '../documentStore';
-export declare const fetch: (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 = {
-    name: string;
-    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 {};

package/build/runtime-esm/client/plugins/fetch.js

@@ -1,184 +0,0 @@
-import { ArtifactKind, DataSource } from "../../lib/types";
-const fetch = (target) => {
-  return () => {
-    return {
-      async network(ctx, { client, initialValue, resolve, marshalVariables }) {
-        if (ctx.artifact.kind === ArtifactKind.Fragment) {
-          return resolve(ctx, initialValue);
-        }
-        const fetch2 = ctx.fetch ?? globalThis.fetch;
-        const fetchParams = {
-          name: ctx.name,
-          text: ctx.text,
-          hash: ctx.hash,
-          variables: { ...marshalVariables(ctx) }
-        };
-        for (const variable of ctx.artifact.stripVariables) {
-          delete fetchParams.variables[variable];
-        }
-        let fetchFn = defaultFetch(client.url, ctx.fetchParams);
-        if (target) {
-          if (typeof target === "string") {
-            fetchFn = defaultFetch(target, ctx.fetchParams);
-          } else {
-            fetchFn = target;
-          }
-        }
-        const result = await fetchFn({
-          // wrap the user's fetch function so we can identify SSR by checking
-          // the response.url
-          fetch: (url, args) => {
-            const newArgs = handleMultipart(fetchParams, args) ?? args;
-            return fetch2(url, {
-              ...newArgs,
-              signal: ctx.abortController.signal
-            });
-          },
-          metadata: ctx.metadata,
-          session: ctx.session || {},
-          ...fetchParams
-        });
-        resolve(ctx, {
-          fetching: false,
-          variables: ctx.variables ?? {},
-          data: result.data,
-          errors: !result.errors || result.errors.length === 0 ? null : result.errors,
-          partial: false,
-          stale: false,
-          source: DataSource.Network
-        });
-      }
-    };
-  };
-};
-const defaultFetch = (url, params) => {
-  if (!url) {
-    throw new Error(
-      "Could not find configured client url. Please specify one in your HoudiniClient constructor."
-    );
-  }
-  return async ({ fetch: fetch2, name, text, variables }) => {
-    const result = await fetch2(url, {
-      method: "POST",
-      body: JSON.stringify({ operationName: name, query: text, variables }),
-      ...params,
-      headers: {
-        Accept: "application/graphql+json, application/json",
-        "Content-Type": "application/json",
-        ...params?.headers
-      }
-    });
-    if (!result.ok && !result.headers.get("content-type")?.startsWith("application/json") && !result.headers.get("content-type")?.startsWith("application/graphql+json")) {
-      throw new Error(
-        `Failed to fetch: server returned invalid response with error ${result.status}: ${result.statusText}`
-      );
-    }
-    return await result.json();
-  };
-};
-function handleMultipart(params, args) {
-  const { files } = extractFiles({
-    variables: params.variables
-  });
-  if (files.size) {
-    const req = args;
-    let headers = {};
-    if (req?.headers) {
-      const filtered = Object.entries(req?.headers).filter(([key, value]) => {
-        return !(key.toLowerCase() == "content-type" && value.toLowerCase() == "application/json");
-      });
-      headers = Object.fromEntries(filtered);
-    }
-    const form = new FormData();
-    if (args && args?.body) {
-      form.set("operations", args?.body);
-    } else {
-      form.set(
-        "operations",
-        JSON.stringify({
-          operationName: params.name,
-          query: params.text,
-          variables: params.variables
-        })
-      );
-    }
-    const map = {};
-    let i = 0;
-    files.forEach((paths) => {
-      map[++i] = paths;
-    });
-    form.set("map", JSON.stringify(map));
-    i = 0;
-    files.forEach((paths, file) => {
-      form.set(`${++i}`, file, file.name);
-    });
-    return { ...req, headers, body: form };
-  }
-}
-function isExtractableFile(value) {
-  return typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob;
-}
-function extractFiles(value) {
-  if (!arguments.length) throw new TypeError("Argument 1 `value` is required.");
-  const clones = /* @__PURE__ */ new Map();
-  const files = /* @__PURE__ */ new Map();
-  function recurse(value2, path, recursed) {
-    if (isExtractableFile(value2)) {
-      const filePaths = files.get(value2);
-      filePaths ? filePaths.push(path) : files.set(value2, [path]);
-      return null;
-    }
-    const valueIsList = Array.isArray(value2) || typeof FileList !== "undefined" && value2 instanceof FileList;
-    const valueIsPlainObject = isPlainObject(value2);
-    if (valueIsList || valueIsPlainObject) {
-      let clone = clones.get(value2);
-      const uncloned = !clone;
-      if (uncloned) {
-        clone = valueIsList ? [] : (
-          // Replicate if the plain object is an `Object` instance.
-          value2 instanceof /** @type {any} */
-          Object ? {} : /* @__PURE__ */ Object.create(null)
-        );
-        clones.set(
-          value2,
-          /** @type {Clone} */
-          clone
-        );
-      }
-      if (!recursed.has(value2)) {
-        const pathPrefix = path ? `${path}.` : "";
-        const recursedDeeper = new Set(recursed).add(value2);
-        if (valueIsList) {
-          let index = 0;
-          for (const item of value2) {
-            const itemClone = recurse(item, pathPrefix + index++, recursedDeeper);
-            if (uncloned) clone.push(itemClone);
-          }
-        } else
-          for (const key in value2) {
-            const propertyClone = recurse(value2[key], pathPrefix + key, recursedDeeper);
-            if (uncloned)
-              clone[key] = propertyClone;
-          }
-      }
-      return clone;
-    }
-    return value2;
-  }
-  return {
-    clone: recurse(value, "", /* @__PURE__ */ new Set()),
-    files
-  };
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-}
-export {
-  extractFiles,
-  fetch,
-  isExtractableFile
-};

package/build/runtime-esm/client/plugins/fetchParams.d.ts

@@ -1,9 +0,0 @@
-import type { DocumentArtifact } from '../../lib/types';
-import type { ClientPlugin, ClientPluginContext } from '../documentStore';
-export type FetchParamFn = (ctx: FetchParamsInput) => Required<ClientPluginContext>['fetchParams'];
-export declare const fetchParams: (fn?: FetchParamFn) => ClientPlugin;
-export type FetchParamsInput = Pick<ClientPluginContext, 'config' | 'policy' | 'variables' | 'metadata' | 'session' | 'stuff'> & {
-    text: string;
-    hash: string;
-    document: DocumentArtifact;
-};