houdini-react 1.3.14 → 2.0.0-go.1

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

@@ -1,495 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import configFile from "$houdini/runtime/imports/config";
-import { deepEquals } from "$houdini/runtime/lib/deepEquals";
-import { marshalSelection, marshalInputs } from "$houdini/runtime/lib/scalars";
-import { find_match } from "$houdini/runtime/router/match";
-import React from "react";
-import { useContext } from "react";
-import { suspense_cache } from "./cache";
-import { useDocumentHandle } from "../hooks/useDocumentHandle";
-import { useDocumentStore } from "../hooks/useDocumentStore";
-import { Context, useRouterContext, useSession, useLocation, LocationContext } from "./hooks";
-const PreloadWhich = {
-  component: "component",
-  data: "data",
-  page: "page"
-};
-function Router({
-  manifest,
-  initialURL,
-  assetPrefix,
-  injectToStream
-}) {
-  const [currentURL, setCurrentURL] = React.useState(() => {
-    return initialURL || window.location.pathname;
-  });
-  const [page, variables] = find_match(configFile, manifest, currentURL);
-  if (!page) {
-    throw new Error("404");
-  }
-  const { loadData, loadComponent } = usePageData({
-    page,
-    variables,
-    assetPrefix,
-    injectToStream
-  });
-  const { component_cache, data_cache } = useRouterContext();
-  const PageComponent = component_cache.get(page.id);
-  React.useEffect(() => {
-    if (globalThis.window && window.location.pathname !== currentURL) {
-      window.history.pushState({}, "", currentURL);
-    }
-  }, [currentURL]);
-  React.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] = find_match(configFile, manifest, url);
-      if (!page2) {
-        return;
-      }
-      if (["page", "component"].includes(which)) {
-        loadComponent(page2);
-      }
-      if (["page", "data"].includes(which)) {
-        loadData(page2, variables2);
-      }
-    }
-  });
-  return /* @__PURE__ */ jsx(VariableContext.Provider, { value: variables, children: /* @__PURE__ */ jsx(
-    LocationContext.Provider,
-    {
-      value: {
-        pathname: currentURL,
-        goto,
-        params: variables ?? {}
-      },
-      children: /* @__PURE__ */ 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
-  } = useRouterContext();
-  const [session] = 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(
-          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(
-          marshalInputs({
-            artifact: observer.artifact,
-            input: variables2,
-            config: configFile
-          })
-        )}
-									}).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(
-          marshalInputs({
-            artifact: observer.artifact,
-            input: variables2,
-            config: configFile
-          })
-        )}
-										})
-									}
-
-
-									// 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 && !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] = React.useState(ssrSession);
-  const handleNewSession = React.useCallback((event) => {
-    setSession(event.detail);
-  }, []);
-  React.useEffect(() => {
-    window.addEventListener("_houdini_session_", handleNewSession);
-    return () => {
-      window.removeEventListener("_houdini_session_", handleNewSession);
-    };
-  }, []);
-  return /* @__PURE__ */ jsx(
-    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 React.useContext(VariableContext);
-}
-const VariableContext = React.createContext(null);
-function useQueryResult(name) {
-  const { data_cache, artifact_cache } = useRouterContext();
-  const store_ref = data_cache.get(name);
-  const [storeValue, observer] = 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 = 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] = React.useTransition();
-  React.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 && !e.metaKey && !e.ctrlKey && !e.altKey && !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 = React.useRef(null);
-  React.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: suspense_cache(initialArtifacts),
-    component_cache: suspense_cache(),
-    data_cache: suspense_cache(initialData),
-    ssr_signals: suspense_cache(),
-    last_variables: 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 = React.createContext({ params: {} });
-function PageContextProvider({
-  keys,
-  children
-}) {
-  const location2 = useLocation();
-  const params = Object.fromEntries(
-    Object.entries(location2.params).filter(([key]) => keys.includes(key))
-  );
-  return /* @__PURE__ */ jsx(PageContext.Provider, { value: { params }, children });
-}
-function useRoute() {
-  return useContext(PageContext);
-}
-function signal_promise() {
-  let resolve = () => {
-  };
-  let reject = () => {
-  };
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    ...promise,
-    resolve,
-    reject
-  };
-}
-export {
-  PageContextProvider,
-  Router,
-  RouterContextProvider,
-  router_cache,
-  updateLocalSession,
-  useCurrentVariables,
-  useQueryResult,
-  useRoute
-};

package/build/runtime-esm/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-esm/routing/cache.js

@@ -1,33 +0,0 @@
-import { LRUCache } from "$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 LRUCache {
-  #callbacks = /* @__PURE__ */ new Map();
-  get(key) {
-    if (super.has(key)) {
-      return super.get(key);
-    }
-    throw new Promise((resolve, reject) => {
-      this.#subscribe(key, resolve, 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 }]);
-  }
-}
-export {
-  SuspenseCache,
-  suspense_cache
-};

package/build/runtime-esm/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 {};

package/build/runtime-esm/routing/hooks.js

@@ -1,53 +0,0 @@
-import configFile from "$houdini/runtime/imports/config";
-import { useContext, default as React } from "react";
-const Context = React.createContext(null);
-const LocationContext = React.createContext({
-  pathname: "",
-  params: {},
-  goto: () => {
-  }
-});
-const useLocation = () => useContext(LocationContext);
-const useRouterContext = () => {
-  const ctx = React.useContext(Context);
-  if (!ctx) {
-    throw new Error("Could not find router context");
-  }
-  return ctx;
-};
-function useClient() {
-  return useRouterContext().client;
-}
-function useCache() {
-  return useRouterContext().cache;
-}
-function useSession() {
-  const ctx = useRouterContext();
-  const updateSession = (newSession) => {
-    ctx.data_cache.clear();
-    ctx.setSession(newSession);
-    const auth = configFile.router?.auth;
-    if (!auth) {
-      return;
-    }
-    const url = "redirect" in auth ? auth.redirect : auth.url;
-    fetch(url, {
-      method: "POST",
-      body: JSON.stringify(newSession),
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      }
-    });
-  };
-  return [ctx.session, updateSession];
-}
-export {
-  Context,
-  LocationContext,
-  useCache,
-  useClient,
-  useLocation,
-  useRouterContext,
-  useSession
-};

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

@@ -1,3 +0,0 @@
-export * from './Router';
-export * from './hooks';
-export { type SuspenseCache, suspense_cache } from './cache';

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

@@ -1,6 +0,0 @@
-export * from "./Router";
-export * from "./hooks";
-import { suspense_cache } from "./cache";
-export {
-  suspense_cache
-};

package/build/server/index.d.ts

@@ -1 +0,0 @@
-export { renderToStream } from 'react-streaming-compat/server';

package/build/server-cjs/index.js

@@ -1,28 +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 server_exports = {};
-__export(server_exports, {
-  renderToStream: () => import_server.renderToStream
-});
-module.exports = __toCommonJS(server_exports);
-var import_server = require("react-streaming-compat/server");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  renderToStream
-});

package/build/server-cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}

package/build/server-esm/index.js

@@ -1,4 +0,0 @@
-import { renderToStream } from "react-streaming-compat/server";
-export {
-  renderToStream
-};

package/build/server-esm/package.json

@@ -1 +0,0 @@
-{"type":"module"}