houdini-react 2.0.0-next.3 → 2.0.0-next.31

package/build/runtime-cjs/routing/Router.js

@@ -1,540 +0,0 @@
-"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(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Router_exports = {};
-__export(Router_exports, {
-  PageContextProvider: () => PageContextProvider,
-  Router: () => Router,
-  RouterContextProvider: () => RouterContextProvider,
-  router_cache: () => router_cache,
-  updateLocalSession: () => updateLocalSession,
-  useCurrentVariables: () => useCurrentVariables,
-  useQueryResult: () => useQueryResult,
-  useRoute: () => useRoute
-});
-module.exports = __toCommonJS(Router_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_config = __toESM(require("$houdini/runtime/imports/config"));
-var import_deepEquals = require("$houdini/runtime/lib/deepEquals");
-var import_scalars = require("$houdini/runtime/lib/scalars");
-var import_match = require("$houdini/runtime/router/match");
-var import_react = __toESM(require("react"));
-var import_react2 = require("react");
-var import_cache = require("./cache");
-var import_useDocumentHandle = require("../hooks/useDocumentHandle");
-var import_useDocumentStore = require("../hooks/useDocumentStore");
-var import_hooks = require("./hooks");
-const PreloadWhich = {
-  component: "component",
-  data: "data",
-  page: "page"
-};
-function Router({
-  manifest,
-  initialURL,
-  assetPrefix,
-  injectToStream
-}) {
-  const [currentURL, setCurrentURL] = import_react.default.useState(() => {
-    return initialURL || window.location.pathname;
-  });
-  const [page, variables] = (0, import_match.find_match)(import_config.default, manifest, currentURL);
-  if (!page) {
-    throw new Error("404");
-  }
-  const { loadData, loadComponent } = usePageData({
-    page,
-    variables,
-    assetPrefix,
-    injectToStream
-  });
-  const { component_cache, data_cache } = (0, import_hooks.useRouterContext)();
-  const PageComponent = component_cache.get(page.id);
-  import_react.default.useEffect(() => {
-    if (globalThis.window && window.location.pathname !== currentURL) {
-      window.history.pushState({}, "", currentURL);
-    }
-  }, [currentURL]);
-  import_react.default.useEffect(() => {
-    if (!globalThis.window) {
-      return;
-    }
-    const onChange = (evt) => {
-      setCurrentURL(window.location.pathname);
-    };
-    window.addEventListener("popstate", onChange);
-    return () => {
-      window.removeEventListener("popstate", onChange);
-    };
-  }, []);
-  const goto = (url) => {
-    data_cache.clear();
-    setCurrentURL(url);
-  };
-  useLinkBehavior({
-    goto,
-    preload(url, which) {
-      const [page2, variables2] = (0, import_match.find_match)(import_config.default, manifest, url);
-      if (!page2) {
-        return;
-      }
-      if (["page", "component"].includes(which)) {
-        loadComponent(page2);
-      }
-      if (["page", "data"].includes(which)) {
-        loadData(page2, variables2);
-      }
-    }
-  });
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(VariableContext.Provider, { value: variables, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_hooks.LocationContext.Provider,
-    {
-      value: {
-        pathname: currentURL,
-        goto,
-        params: variables ?? {}
-      },
-      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PageComponent, { url: currentURL }, page.id)
-    }
-  ) });
-}
-function usePageData({
-  page,
-  variables,
-  assetPrefix,
-  injectToStream
-}) {
-  const {
-    client,
-    cache,
-    data_cache,
-    component_cache,
-    artifact_cache,
-    ssr_signals,
-    last_variables
-  } = (0, import_hooks.useRouterContext)();
-  const [session] = (0, import_hooks.useSession)();
-  function load_query({
-    id,
-    artifact,
-    variables: variables2
-  }) {
-    for (const artifact2 of Object.keys(page.documents)) {
-      last_variables.set(artifact2, variables2);
-    }
-    if (ssr_signals.has(id)) {
-      return ssr_signals.get(id);
-    }
-    const observer = data_cache.has(artifact.name) ? data_cache.get(artifact.name) : client.observe({ artifact, cache });
-    let resolve = () => {
-    };
-    let reject = () => {
-    };
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-      observer.send({
-        variables: variables2,
-        session
-      }).then(async () => {
-        data_cache.set(id, observer);
-        if (observer.state.errors && observer.state.errors.length > 0) {
-          reject(observer.state.errors.map((e) => e.message).join("\n"));
-          return;
-        }
-        injectToStream?.(`
-						<script>
-						{
-								window.__houdini__cache__?.hydrate(${cache.serialize()}, window.__houdini__hydration__layer)
-
-								const artifactName = "${artifact.name}"
-								const value = ${JSON.stringify(
-          (0, import_scalars.marshalSelection)({
-            selection: observer.artifact.selection,
-            data: observer.state.data
-          })
-        )}
-
-								// if the data is pending, we need to resolve it
-								if (window.__houdini__nav_caches__?.data_cache.has(artifactName)) {
-									// before we resolve the pending signals,
-									// fill the data cache with values we got on the server
-									const new_store = window.__houdini__client__.observe({
-										artifact: window.__houdini__nav_caches__.artifact_cache.get(artifactName),
-										cache: window.__houdini__cache__,
-									})
-
-									// we're pushing this store onto the client, it should be initialized
-									window.__houdini__nav_caches__.data_cache.get(artifactName).send({
-										setup: true,
-										variables: ${JSON.stringify(
-          (0, import_scalars.marshalInputs)({
-            artifact: observer.artifact,
-            input: variables2,
-            config: import_config.default
-          })
-        )}
-									}).then(() => {
-										window.__houdini__nav_caches__?.data_cache.set(artifactName, new_store)
-									})
-
-								}
-
-
-								// if there are no data caches available we need to populate the pending one instead
-								if (!window.__houdini__nav_caches__) {
-									if (!window.__houdini__pending_data__) {
-										window.__houdini__pending_data__ = {}
-									}
-
-									if (!window.__houdini__pending_variables__) {
-										window.__houdini__pending_variables__ = {}
-									}
-
-									if (!window.__houdini__pending_artifacts__) {
-										window.__houdini__pending_artifacts__ = {}
-									}
-								}
-
-								window.__houdini__pending_variables__[artifactName] = ${JSON.stringify(observer.state.variables)}
-								window.__houdini__pending_data__[artifactName] = value
-								window.__houdini__pending_artifacts__[artifactName] = ${JSON.stringify(artifact)}
-
-								// if this payload finishes off an ssr request, we need to resolve the signal
-								if (window.__houdini__nav_caches__?.ssr_signals.has(artifactName)) {
-
-									// if the data showed up on the client before
-									if (window.__houdini__nav_caches__.data_cache.has(artifactName)) {
-										// we're pushing this store onto the client, it should be initialized
-										window.__houdini__nav_caches__.data_cache.get(artifactName).send({
-											setup: true,
-											variables: ${JSON.stringify(
-          (0, import_scalars.marshalInputs)({
-            artifact: observer.artifact,
-            input: variables2,
-            config: import_config.default
-          })
-        )}
-										})
-									}
-
-
-									// trigger the signal
-									window.__houdini__nav_caches__.ssr_signals.get(artifactName).resolve()
-									window.__houdini__nav_caches__.ssr_signals.delete(artifactName)
-								}
-							}
-						</script>
-					`);
-        resolve();
-      }).catch(reject);
-    });
-    const resolvable = { ...promise, resolve, reject };
-    if (!globalThis.window) {
-      ssr_signals.set(id, resolvable);
-    }
-    return resolvable;
-  }
-  function loadData(targetPage, variables2) {
-    if (!targetPage) {
-      return;
-    }
-    for (const [artifact, { variables: pageVariables }] of Object.entries(
-      targetPage.documents
-    )) {
-      if (!last_variables.has(artifact)) {
-        continue;
-      }
-      let last = {};
-      let usedVariables = {};
-      for (const variable of Object.keys(pageVariables)) {
-        last[variable] = last_variables.get(artifact)[variable];
-        usedVariables[variable] = (variables2 ?? {})[variable];
-      }
-      if (Object.keys(usedVariables ?? {}).length > 0 && !(0, import_deepEquals.deepEquals)(last, usedVariables)) {
-        data_cache.delete(artifact);
-      }
-    }
-    const missing_artifacts = [];
-    const found_artifacts = {};
-    for (const key of Object.keys(targetPage.documents)) {
-      if (artifact_cache.has(key)) {
-        found_artifacts[key] = artifact_cache.get(key);
-      } else {
-        missing_artifacts.push(key);
-      }
-    }
-    for (const artifact_id of missing_artifacts) {
-      targetPage.documents[artifact_id].artifact().then((mod) => {
-        const artifact = mod.default;
-        artifact_cache.set(artifact_id, artifact);
-        injectToStream?.(`
-						<script type="module" src="${assetPrefix}/artifacts/${artifact.name}.js" async=""></script>
-					`);
-        load_query({ id: artifact.name, artifact, variables: variables2 });
-      }).catch((err) => {
-        console.log(err);
-      });
-    }
-    for (const artifact of Object.values(found_artifacts)) {
-      if (!data_cache.has(artifact.name)) {
-        load_query({ id: artifact.name, artifact, variables: variables2 });
-      }
-    }
-  }
-  async function loadComponent(targetPage) {
-    if (component_cache.has(targetPage.id)) {
-      return;
-    }
-    const mod = await targetPage.component();
-    component_cache.set(targetPage.id, mod.default);
-  }
-  loadData(page, variables);
-  if (!component_cache.has(page.id)) {
-    throw loadComponent(page);
-  }
-  return {
-    loadData,
-    loadComponent
-  };
-}
-function RouterContextProvider({
-  children,
-  client,
-  cache,
-  artifact_cache,
-  component_cache,
-  data_cache,
-  ssr_signals,
-  last_variables,
-  session: ssrSession = {}
-}) {
-  const [session, setSession] = import_react.default.useState(ssrSession);
-  const handleNewSession = import_react.default.useCallback((event) => {
-    setSession(event.detail);
-  }, []);
-  import_react.default.useEffect(() => {
-    window.addEventListener("_houdini_session_", handleNewSession);
-    return () => {
-      window.removeEventListener("_houdini_session_", handleNewSession);
-    };
-  }, []);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_hooks.Context.Provider,
-    {
-      value: {
-        client,
-        cache,
-        artifact_cache,
-        component_cache,
-        data_cache,
-        ssr_signals,
-        last_variables,
-        session,
-        setSession: (newSession) => setSession((old) => ({ ...old, ...newSession }))
-      },
-      children
-    }
-  );
-}
-function updateLocalSession(session) {
-  window.dispatchEvent(
-    new CustomEvent("_houdini_session_", {
-      bubbles: true,
-      detail: session
-    })
-  );
-}
-function useCurrentVariables() {
-  return import_react.default.useContext(VariableContext);
-}
-const VariableContext = import_react.default.createContext(null);
-function useQueryResult(name) {
-  const { data_cache, artifact_cache } = (0, import_hooks.useRouterContext)();
-  const store_ref = data_cache.get(name);
-  const [storeValue, observer] = (0, import_useDocumentStore.useDocumentStore)({
-    artifact: store_ref.artifact,
-    observer: store_ref
-  });
-  const { data, errors } = storeValue;
-  if (errors && errors.length > 0) {
-    throw new Error(JSON.stringify(errors));
-  }
-  const handle = (0, import_useDocumentHandle.useDocumentHandle)({
-    artifact: artifact_cache.get(name),
-    observer,
-    storeValue
-  });
-  return [data, handle];
-}
-function useLinkBehavior({
-  goto,
-  preload
-}) {
-  useLinkNavigation({ goto });
-  if (!globalThis.navigator?.connection?.saveData) {
-    usePreload({ preload });
-  }
-}
-function useLinkNavigation({ goto }) {
-  const [pending, startTransition] = import_react.default.useTransition();
-  import_react.default.useEffect(() => {
-    const onClick = (e) => {
-      if (!e.target) {
-        return;
-      }
-      const link = e.target?.closest("a");
-      if (!(link && link instanceof HTMLAnchorElement && link.href && (!link.target || link.target === "_self") && link.origin === location.origin && !link.hasAttribute("download") && e.button === 0 && // left clicks only
-      !e.metaKey && // open in new tab (mac)
-      !e.ctrlKey && // open in new tab (windows)
-      !e.altKey && // download
-      !e.shiftKey && !e.defaultPrevented)) {
-        return;
-      }
-      const target = link.attributes.getNamedItem("href")?.value;
-      if (!target || !target.startsWith("/")) {
-        return;
-      }
-      e.preventDefault();
-      e.stopPropagation();
-      startTransition(() => {
-        goto(target);
-      });
-    };
-    window.addEventListener("click", onClick);
-    return () => {
-      window.removeEventListener("click", onClick);
-    };
-  }, []);
-}
-function usePreload({ preload }) {
-  const timeoutRef = import_react.default.useRef(null);
-  import_react.default.useEffect(() => {
-    const mouseMove = (e) => {
-      const target = e.target;
-      if (!(target instanceof HTMLElement)) {
-        return;
-      }
-      const anchor = target.closest("a");
-      if (!anchor) {
-        return;
-      }
-      let preloadWhichRaw = anchor.attributes.getNamedItem("data-houdini-preload")?.value;
-      let preloadWhich = !preloadWhichRaw || preloadWhichRaw === "true" ? "page" : preloadWhichRaw;
-      if (!PreloadWhich[preloadWhich]) {
-        console.log(
-          `invalid preload value "${preloadWhich}" must be "${PreloadWhich.component}", "${PreloadWhich.data}", or "${PreloadWhich.page}"`
-        );
-        return;
-      }
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
-      timeoutRef.current = setTimeout(() => {
-        const url = anchor.attributes.getNamedItem("href")?.value;
-        if (!url) {
-          return;
-        }
-        preload(url, preloadWhich);
-      }, 20);
-    };
-    document.addEventListener("mousemove", mouseMove);
-    return () => {
-      document.removeEventListener("mousemove", mouseMove);
-    };
-  }, []);
-}
-function router_cache({
-  pending_queries = [],
-  artifacts = {},
-  components = {},
-  initialData = {},
-  initialVariables = {},
-  initialArtifacts = {}
-} = {}) {
-  const result = {
-    artifact_cache: (0, import_cache.suspense_cache)(initialArtifacts),
-    component_cache: (0, import_cache.suspense_cache)(),
-    data_cache: (0, import_cache.suspense_cache)(initialData),
-    ssr_signals: (0, import_cache.suspense_cache)(),
-    last_variables: (0, import_cache.suspense_cache)()
-  };
-  for (const query of pending_queries) {
-    result.ssr_signals.set(query, signal_promise());
-  }
-  for (const [name, artifact] of Object.entries(artifacts)) {
-    result.artifact_cache.set(name, artifact);
-  }
-  for (const [name, component] of Object.entries(components)) {
-    result.component_cache.set(name, component);
-  }
-  for (const [name, variables] of Object.entries(initialVariables)) {
-    result.last_variables.set(name, variables);
-  }
-  return result;
-}
-const PageContext = import_react.default.createContext({ params: {} });
-function PageContextProvider({
-  keys,
-  children
-}) {
-  const location2 = (0, import_hooks.useLocation)();
-  const params = Object.fromEntries(
-    Object.entries(location2.params).filter(([key]) => keys.includes(key))
-  );
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PageContext.Provider, { value: { params }, children });
-}
-function useRoute() {
-  return (0, import_react2.useContext)(PageContext);
-}
-function signal_promise() {
-  let resolve = () => {
-  };
-  let reject = () => {
-  };
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    ...promise,
-    resolve,
-    reject
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PageContextProvider,
-  Router,
-  RouterContextProvider,
-  router_cache,
-  updateLocalSession,
-  useCurrentVariables,
-  useQueryResult,
-  useRoute
-});

package/build/runtime-cjs/routing/cache.d.ts

@@ -1,7 +0,0 @@
-import { LRUCache } from '$houdini/runtime/lib/lru';
-export declare function suspense_cache<T>(initialData?: Record<string, T>): SuspenseCache<T>;
-export declare class SuspenseCache<_Data> extends LRUCache<_Data> {
-    #private;
-    get(key: string): _Data;
-    set(key: string, value: _Data): void;
-}

package/build/runtime-cjs/routing/cache.js

@@ -1,61 +0,0 @@
-"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 cache_exports = {};
-__export(cache_exports, {
-  SuspenseCache: () => SuspenseCache,
-  suspense_cache: () => suspense_cache
-});
-module.exports = __toCommonJS(cache_exports);
-var import_lru = require("$houdini/runtime/lib/lru");
-function suspense_cache(initialData) {
-  const cache = new SuspenseCache();
-  for (const [key, value] of Object.entries(initialData ?? {})) {
-    cache.set(key, value);
-  }
-  return cache;
-}
-class SuspenseCache extends import_lru.LRUCache {
-  // if get is called before set, we need to invoke a callback.
-  // that means we need a place to put our callbacks
-  #callbacks = /* @__PURE__ */ new Map();
-  get(key) {
-    if (super.has(key)) {
-      return super.get(key);
-    }
-    throw new Promise((resolve, reject) => {
-      this.#subscribe(key, resolve, reject);
-    });
-  }
-  // TODO: reject?
-  set(key, value) {
-    super.set(key, value);
-    if (this.#callbacks.has(key)) {
-      this.#callbacks.get(key)?.forEach(({ resolve }) => resolve());
-      this.#callbacks.delete(key);
-    }
-  }
-  #subscribe(key, resolve, reject) {
-    this.#callbacks.set(key, [...this.#callbacks.get(key) || [], { resolve, reject }]);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SuspenseCache,
-  suspense_cache
-});

package/build/runtime-cjs/routing/hooks.d.ts

@@ -1,40 +0,0 @@
-import type { Cache } from '$houdini/runtime/cache/cache';
-import type { DocumentStore, HoudiniClient } from '$houdini/runtime/client';
-import type { LRUCache } from '$houdini/runtime/lib/lru';
-import type { GraphQLObject, GraphQLVariables, QueryArtifact } from '$houdini/runtime/lib/types';
-import { default as React } from 'react';
-import type { SuspenseCache } from './cache';
-export type PageComponent = React.ComponentType<{
-    url: string;
-}>;
-export type PendingCache = SuspenseCache<Promise<void> & {
-    resolve: () => void;
-    reject: (message: string) => void;
-}>;
-type RouterContext = {
-    client: HoudiniClient;
-    cache: Cache;
-    artifact_cache: SuspenseCache<QueryArtifact>;
-    component_cache: SuspenseCache<PageComponent>;
-    data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>;
-    ssr_signals: PendingCache;
-    last_variables: LRUCache<GraphQLVariables>;
-    session: App.Session;
-    setSession: (newSession: Partial<App.Session>) => void;
-};
-export declare const Context: React.Context<RouterContext | null>;
-export declare const LocationContext: React.Context<{
-    pathname: string;
-    params: Record<string, any>;
-    goto: (url: string) => void;
-}>;
-export declare const useLocation: () => {
-    pathname: string;
-    params: Record<string, any>;
-    goto: (url: string) => void;
-};
-export declare const useRouterContext: () => RouterContext;
-export declare function useClient(): HoudiniClient;
-export declare function useCache(): Cache;
-export declare function useSession(): [App.Session, (newSession: Partial<App.Session>) => void];
-export {};