houdini-react 1.2.0-react.1

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

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { useHoudiniClient } from "./useHoudiniClient";
+import { useIsMountedRef } from "./useIsMounted";
+function useDocumentStore({
+  artifact,
+  ...observeParams
+}) {
+  const client = useHoudiniClient();
+  const isMountedRef = useIsMountedRef();
+  let [observer, setObserver] = React.useState(
+    () => client.observe({
+      artifact,
+      ...observeParams
+    })
+  );
+  const box = React.useRef(observer.state);
+  const subscribe = React.useCallback(
+    (fn) => {
+      return observer.subscribe((val) => {
+        box.current = val;
+        if (isMountedRef.current) {
+          fn();
+        }
+      });
+    },
+    [observer]
+  );
+  const storeValue = React.useSyncExternalStore(subscribe, () => box.current);
+  return [storeValue, observer, setObserver];
+}
+export {
+  useDocumentStore
+};

package/build/runtime-esm/hooks/useDocumentSubscription.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentArtifact, QueryResult } from '$houdini/lib/types';
+import type { DocumentStore, SendParams } from '$houdini/runtime/client';
+import { GraphQLObject } from 'houdini';
+import { type UseDocumentStoreParams } from './useDocumentStore';
+export declare function useDocumentSubscription<_Artifact extends DocumentArtifact = DocumentArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = {}>({ artifact, variables, send, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data> & {
+    variables: _Input;
+    send?: Partial<SendParams>;
+}): [
+    QueryResult<_Data, _Input> & {
+        parent?: string | null;
+    },
+    DocumentStore<_Data, _Input>,
+    (store: DocumentStore<_Data, _Input>) => void
+];

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

@@ -0,0 +1,35 @@
+import useDeepCompareEffect from "./useDeepCompareEffect";
+import { useDocumentStore } from "./useDocumentStore";
+function useDocumentSubscription({
+  artifact,
+  variables,
+  send,
+  ...observeParams
+}) {
+  const [storeValue, observer, setObserver] = useDocumentStore({
+    artifact,
+    ...observeParams
+  });
+  useDeepCompareEffect(() => {
+    observer.send({
+      variables,
+      session: {},
+      metadata: {},
+      ...send
+    });
+    return () => {
+      observer.cleanup();
+    };
+  }, [observer, variables ?? {}, send ?? {}]);
+  return [
+    {
+      parent: send?.stuff?.parentID,
+      ...storeValue
+    },
+    observer,
+    setObserver
+  ];
+}
+export {
+  useDocumentSubscription
+};

package/build/runtime-esm/hooks/useFragment.d.ts

@@ -0,0 +1,15 @@
+import { fragmentKey } from '$houdini/runtime/lib/types';
+import type { GraphQLObject, FragmentArtifact } from '$houdini/runtime/lib/types';
+export declare function useFragment<_Data extends GraphQLObject, _ReferenceType extends {}, _Input extends {} = {}>(reference: _Data | {
+    [fragmentKey]: _ReferenceType;
+} | null, document: {
+    artifact: FragmentArtifact;
+}): _Data | null;
+export declare function fragmentReference<_Data extends GraphQLObject, _Input, _ReferenceType extends {}>(reference: _Data | {
+    [fragmentKey]: _ReferenceType;
+} | null, document: {
+    artifact: FragmentArtifact;
+}): {
+    variables: _Input;
+    parent: string;
+};

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

@@ -0,0 +1,62 @@
+import cache from "$houdini/runtime/cache";
+import { deepEquals } from "$houdini/runtime/lib/deepEquals";
+import { fragmentKey } from "$houdini/runtime/lib/types";
+import * as React from "react";
+import { useDeepCompareMemoize } from "./useDeepCompareEffect";
+import { useDocumentSubscription } from "./useDocumentSubscription";
+function useFragment(reference, document) {
+  const { parent, variables } = fragmentReference(
+    reference,
+    document
+  );
+  let cachedValue = reference;
+  if (reference && parent) {
+    cachedValue = cache.read({
+      selection: document.artifact.selection,
+      parent,
+      variables
+    }).data;
+  }
+  const observeParams = {
+    artifact: document.artifact,
+    variables,
+    initialValue: cachedValue,
+    send: {
+      stuff: {
+        parentID: parent
+      }
+    }
+  };
+  const [storeValue] = useDocumentSubscription(observeParams);
+  const lastReference = React.useRef(null);
+  return React.useMemo(() => {
+    const parentChange = storeValue.parent !== parent || !deepEquals({ parent, variables }, lastReference.current);
+    if (parentChange) {
+      lastReference.current = { parent, variables: { ...variables } };
+      return cachedValue;
+    }
+    return storeValue.data;
+  }, [
+    useDeepCompareMemoize({
+      parent,
+      variables,
+      cachedValue,
+      storeValue: storeValue.data,
+      storeParent: storeValue.parent
+    })
+  ]);
+}
+function fragmentReference(reference, document) {
+  const { variables, parent } = reference?.[fragmentKey]?.[document.artifact.name] ?? {};
+  if (reference && fragmentKey in reference && (!variables || !parent)) {
+    console.warn(
+      `\u26A0\uFE0F Parent does not contain the information for this fragment. Something is wrong.
+Please ensure that you have passed a record that has ${document.artifact.name} mixed into it.`
+    );
+  }
+  return { variables, parent };
+}
+export {
+  fragmentReference,
+  useFragment
+};

package/build/runtime-esm/hooks/useFragmentHandle.d.ts

@@ -0,0 +1,9 @@
+import type { GraphQLObject, FragmentArtifact, QueryArtifact } from '$houdini/runtime/lib/types';
+import { fragmentKey } from '$houdini/runtime/lib/types';
+import { type DocumentHandle } from './useDocumentHandle';
+export declare function useFragmentHandle<_Artifact extends FragmentArtifact, _Data extends GraphQLObject, _ReferenceType extends {}, _PaginationArtifact extends QueryArtifact, _Input extends {} = {}>(reference: _Data | {
+    [fragmentKey]: _ReferenceType;
+} | null, document: {
+    artifact: FragmentArtifact;
+    refetchArtifact?: QueryArtifact;
+}): DocumentHandle<_PaginationArtifact, _Data, _Input>;

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

@@ -0,0 +1,23 @@
+import { useDocumentHandle } from "./useDocumentHandle";
+import { useDocumentStore } from "./useDocumentStore";
+import { fragmentReference, useFragment } from "./useFragment";
+function useFragmentHandle(reference, document) {
+  const data = useFragment(reference, document);
+  const { variables } = fragmentReference(reference, document);
+  const [handleValue, handleObserver] = useDocumentStore({
+    artifact: document.refetchArtifact ?? document.artifact
+  });
+  const handle = useDocumentHandle({
+    observer: handleObserver,
+    storeValue: handleValue,
+    artifact: document.refetchArtifact ?? document.artifact
+  });
+  return {
+    ...handle,
+    variables,
+    data
+  };
+}
+export {
+  useFragmentHandle
+};

package/build/runtime-esm/hooks/useHoudiniClient.d.ts

@@ -0,0 +1,2 @@
+import type { HoudiniClient } from '$houdini/runtime/client';
+export declare function useHoudiniClient(): HoudiniClient;

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

@@ -0,0 +1,12 @@
+import * as React from "react";
+import { HoudiniContext } from "../context";
+function useHoudiniClient() {
+  const client = React.useContext(HoudiniContext);
+  if (!client) {
+    throw new Error("Could not find client");
+  }
+  return client;
+}
+export {
+  useHoudiniClient
+};

package/build/runtime-esm/hooks/useIsMounted.d.ts

@@ -0,0 +1,3 @@
+export declare function useIsMountedRef(): {
+    current: boolean;
+};

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

@@ -0,0 +1,14 @@
+import { useRef, useEffect } from "react";
+function useIsMountedRef() {
+  const isMountedRef = useRef(true);
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return isMountedRef;
+}
+export {
+  useIsMountedRef
+};

package/build/runtime-esm/hooks/useMutation.d.ts

@@ -0,0 +1,10 @@
+import type { MutationArtifact, GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
+export type MutationHandler<_Result, _Input, _Optimistic extends GraphQLObject> = (args: {
+    variables: _Input;
+    metadata?: App.Metadata;
+    fetch?: typeof globalThis.fetch;
+    optimisticResponse?: _Optimistic;
+}) => Promise<QueryResult<_Result, _Input>>;
+export declare function useMutation<_Result extends GraphQLObject, _Input extends {}, _Optimistic extends GraphQLObject>({ artifact, }: {
+    artifact: MutationArtifact;
+}): [boolean, MutationHandler<_Result, _Input, _Optimistic>];

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

@@ -0,0 +1,24 @@
+import { useDocumentStore } from "./useDocumentStore";
+function useMutation({
+  artifact
+}) {
+  const [storeValue, observer] = useDocumentStore({ artifact });
+  const pending = storeValue.fetching;
+  const mutate = ({
+    metadata,
+    fetch,
+    variables,
+    ...mutationConfig
+  }) => observer.send({
+    variables,
+    metadata,
+    session: {},
+    stuff: {
+      ...mutationConfig
+    }
+  });
+  return [pending, mutate];
+}
+export {
+  useMutation
+};

package/build/runtime-esm/hooks/useQuery.d.ts

@@ -0,0 +1,5 @@
+import { type QueryArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
+import { UseQueryConfig } from './useQueryHandle';
+export declare function useQuery<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []>(document: {
+    artifact: QueryArtifact;
+}, variables?: any, config?: UseQueryConfig): _Data;

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

@@ -0,0 +1,8 @@
+import { useQueryHandle } from "./useQueryHandle";
+function useQuery(document, variables = null, config = {}) {
+  const { data } = useQueryHandle(document, variables, config);
+  return data;
+}
+export {
+  useQuery
+};

package/build/runtime-esm/hooks/useQueryHandle.d.ts

@@ -0,0 +1,10 @@
+import { type QueryArtifact, GraphQLObject, CachePolicies } from '$houdini/runtime/lib/types';
+import { DocumentHandle } from './useDocumentHandle';
+export declare function useQueryHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []>({ artifact }: {
+    artifact: QueryArtifact;
+}, variables?: any, config?: UseQueryConfig): DocumentHandle<_Artifact, _Data, _Input>;
+export type UseQueryConfig = {
+    policy?: CachePolicies;
+    metadata?: App.Metadata;
+    fetchKey?: any;
+};

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

@@ -0,0 +1,95 @@
+import React from "react";
+import { createCache } from "../lib/cache";
+import { useDocumentHandle } from "./useDocumentHandle";
+import { useHoudiniClient } from "./useHoudiniClient";
+import { useIsMountedRef } from "./useIsMounted";
+const promiseCache = createCache();
+function useQueryHandle({ artifact }, variables = null, config = {}) {
+  const identifier = queryIdentifier({ artifact, variables, config });
+  const suspenseValue = promiseCache.get(identifier);
+  const client = useHoudiniClient();
+  const isMountedRef = useIsMountedRef();
+  let [observer] = React.useState(
+    client.observe({
+      artifact,
+      initialValue: suspenseValue?.resolved?.data ?? {}
+    })
+  );
+  const suspenseTracker = React.useRef(false);
+  const box = React.useRef(observer.state);
+  const subscribe = React.useCallback(
+    (fn) => {
+      return observer.subscribe((val) => {
+        box.current = val;
+        if (isMountedRef.current && !suspenseTracker.current) {
+          fn();
+        }
+      });
+    },
+    [observer]
+  );
+  const storeValue = React.useSyncExternalStore(subscribe, () => box.current);
+  const handle = useDocumentHandle({
+    artifact,
+    observer,
+    storeValue
+  });
+  React.useEffect(() => {
+    return () => {
+      promiseCache.delete(identifier);
+    };
+  }, [identifier]);
+  React.useEffect(() => {
+    return () => {
+      observer.cleanup();
+    };
+  }, [observer]);
+  let result = storeValue.data;
+  if (!suspenseValue) {
+    let resolve = () => {
+    };
+    const loadPromise = new Promise((r) => resolve = r);
+    const suspenseUnit = {
+      then: loadPromise.then.bind(loadPromise),
+      resolve,
+      variables
+    };
+    promiseCache.set(identifier, suspenseUnit);
+    handle.fetch({
+      variables,
+      stuff: {
+        silenceLoading: true
+      }
+    }).then((value) => {
+      suspenseUnit.resolved = {
+        ...handle,
+        data: value.data,
+        partia: value.partial,
+        artifact
+      };
+      suspenseUnit.resolve();
+    });
+    suspenseTracker.current = true;
+    throw suspenseUnit;
+  }
+  if (!result && suspenseValue && !suspenseValue.resolved) {
+    suspenseTracker.current = true;
+    throw suspenseValue;
+  }
+  if (!result && suspenseValue?.resolved) {
+    return suspenseValue.resolved;
+  }
+  return {
+    ...handle,
+    variables: storeValue.variables,
+    data: result
+  };
+}
+function queryIdentifier(args) {
+  args.fetchKey ??= 0;
+  const { artifact, variables, fetchKey } = args;
+  return [artifact.name, JSON.stringify(variables), fetchKey].join("@@");
+}
+export {
+  useQueryHandle
+};

package/build/runtime-esm/hooks/useSubscription.d.ts

@@ -0,0 +1,4 @@
+import { SubscriptionArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
+export declare function useSubscription<_Result extends GraphQLObject, _Input extends {}>(document: {
+    artifact: SubscriptionArtifact;
+}, variables: _Input): import("houdini").GraphQLObject | null;

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

@@ -0,0 +1,8 @@
+import { useSubscriptionHandle } from "./useSubscriptionHandle";
+function useSubscription(document, variables) {
+  const { data } = useSubscriptionHandle(document, variables);
+  return data;
+}
+export {
+  useSubscription
+};

package/build/runtime-esm/hooks/useSubscriptionHandle.d.ts

@@ -0,0 +1,25 @@
+import { SubscriptionArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
+export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends {} | null> = {
+    data: _Result | null;
+    errors: {
+        message: string;
+    }[] | null;
+    variables: _Input;
+    listen: (args: {
+        variables?: _Input;
+    }) => void;
+    unlisten: () => void;
+    fetching: boolean;
+};
+export declare function useSubscriptionHandle<_Result extends GraphQLObject, _Input extends {}>({ artifact }: {
+    artifact: SubscriptionArtifact;
+}, variables: _Input): {
+    data: import("houdini").GraphQLObject | null;
+    errors: {
+        message: string;
+    }[] | null;
+    fetching: boolean;
+    variables: _Input;
+    unlisten: () => Promise<void>;
+    listen: ({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: import("$houdini/lib").SendParams) => Promise<import("$houdini/runtime/lib/types").QueryResult<import("houdini").GraphQLObject, _Input>>;
+};

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

@@ -0,0 +1,18 @@
+import { useDocumentSubscription } from "./useDocumentSubscription";
+function useSubscriptionHandle({ artifact }, variables) {
+  const [storeValue, observer] = useDocumentSubscription({
+    artifact,
+    variables
+  });
+  return {
+    data: storeValue.data,
+    errors: storeValue.errors,
+    fetching: storeValue.fetching,
+    variables,
+    unlisten: observer.cleanup,
+    listen: observer.send
+  };
+}
+export {
+  useSubscriptionHandle
+};

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

@@ -0,0 +1,2 @@
+export * from './hooks';
+export { HoudiniProvider } from './context';

package/build/runtime-esm/index.js

@@ -0,0 +1,5 @@
+export * from "./hooks";
+import { HoudiniProvider } from "./context";
+export {
+  HoudiniProvider
+};

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

@@ -0,0 +1,62 @@
+/**
+ * This file is a copy and paste of a very simple and effective LRU cache
+ * using javascript maps. It was copied under the MIT license found at the
+ * bottom of the page.
+ */
+export interface Cache<T> {
+    get(key: string): T | null;
+    set(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    size(): number;
+    capacity(): number;
+    clear(): void;
+}
+/**
+ * JS maps (both plain objects and Map) maintain key insertion
+ * order, which means there is an easy way to simulate LRU behavior
+ * that should also perform quite well:
+ *
+ * To insert a new value, first delete the key from the inner _map,
+ * then _map.set(k, v). By deleting and reinserting, you ensure that the
+ * map sees the key as the last inserted key.
+ *
+ * Get does the same: if the key is present, delete and reinsert it.
+ */
+declare class LRUCache<T> implements Cache<T> {
+    _capacity: number;
+    _map: Map<string, T>;
+    constructor(capacity?: number);
+    set(key: string, value: T): void;
+    get(key: string): T | null;
+    has(key: string): boolean;
+    delete(key: string): void;
+    size(): number;
+    capacity(): number;
+    clear(): void;
+}
+export declare function createCache<T>(capacity?: number): LRUCache<T>;
+export {};
+/**
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */

package/build/runtime-esm/lib/cache.js

@@ -0,0 +1,47 @@
+class LRUCache {
+  _capacity;
+  _map;
+  constructor(capacity = 1e3) {
+    this._capacity = capacity;
+    this._map = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this._map.delete(key);
+    this._map.set(key, value);
+    if (this._map.size > this._capacity) {
+      const firstKey = this._map.keys().next();
+      if (!firstKey.done) {
+        this._map.delete(firstKey.value);
+      }
+    }
+  }
+  get(key) {
+    const value = this._map.get(key);
+    if (value != null) {
+      this._map.delete(key);
+      this._map.set(key, value);
+    }
+    return value ?? null;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  delete(key) {
+    this._map.delete(key);
+  }
+  size() {
+    return this._map.size;
+  }
+  capacity() {
+    return this._capacity - this._map.size;
+  }
+  clear() {
+    this._map.clear();
+  }
+}
+function createCache(capacity = 1e3) {
+  return new LRUCache(capacity);
+}
+export {
+  createCache
+};

package/build/runtime-esm/package.json

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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "houdini-react",
+  "version": "1.2.0-react.1",
+  "description": "The React plugin for houdini",
+  "keywords": [
+    "typescript",
+    "react",
+    "graphql",
+    "graphql-client"
+  ],
+  "homepage": "https://github.com/HoudiniGraphql/houdini",
+  "funding": "https://github.com/sponsors/HoudiniGraphql",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HoudiniGraphql/houdini.git"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/estraverse": "^5.1.2",
+    "@types/next": "^9.0.0",
+    "next": "^13.0.1",
+    "scripts": "^1.0.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.19.3",
+    "@types/react": "^18.0.28",
+    "@types/rollup": "^0.54.0",
+    "estraverse": "^5.3.0",
+    "graphql": "^15.8.0",
+    "react": "^18.2.0",
+    "recast": "^0.23.1",
+    "rollup": "^3.7.4",
+    "use-deep-compare-effect": "^1.8.1",
+    "houdini": "^1.2.0-react.1"
+  },
+  "files": [
+    "build"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    "./next": {
+      "import": "./build/next-esm/index.js",
+      "require": "./build/next-cjs/index.js"
+    },
+    ".": {
+      "import": "./build/plugin-esm/index.js",
+      "require": "./build/plugin-cjs/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "next": [
+        "build/next/index.d.ts"
+      ]
+    }
+  },
+  "main": "./build/plugin-cjs/index.js",
+  "types": "./build/plugin/index.d.ts",
+  "scripts": {
+    "compile": "scripts build --plugin",
+    "typedefs": "scripts typedefs --plugin"
+  }
+}