@isograph/react 0.0.0-main-2f494978 → 0.0.0-main-3779371d

package/dist/cache.d.ts

@@ -15,7 +15,7 @@ declare global {
  */
 export declare function stableCopy<T>(value: T): T;
 type IsoResolver = IsographEntrypoint<any, any>;
-export declare function getOrCreateCacheForArtifact<T>(environment: IsographEnvironment, artifact: IsographEntrypoint<any, T>, variables: object): ParentCache<PromiseWrapper<T>>;
+export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: object): ParentCache<PromiseWrapper<TClientFieldValue>>;
 export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
 export declare function subscribe(environment: IsographEnvironment, callback: () => void): () => void;
 export declare function onNextChange(environment: IsographEnvironment): Promise<void>;

package/dist/useImperativeReference.d.ts

@@ -1,8 +1,8 @@
 import { UnassignedState } from '@isograph/react-disposable-state';
-import { ExtractReadFromStore, ExtractResolverResult, IsographEntrypoint } from './entrypoint';
+import { IsographEntrypoint } from './entrypoint';
 import { FragmentReference } from './FragmentReference';
-export declare function useImperativeReference<TEntrypoint extends IsographEntrypoint<any, any>>(entrypoint: TEntrypoint): {
-    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>> | UnassignedState;
+export declare function useImperativeReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>): {
+    queryReference: FragmentReference<TReadFromStore, TClientFieldValue> | UnassignedState;
     loadQueryReference: (variables: {
         [index: string]: string;
     }) => void;

package/dist/useLazyReference.d.ts

@@ -1,7 +1,7 @@
 import { FragmentReference, Variable } from './FragmentReference';
-import { ExtractReadFromStore, ExtractResolverResult } from './entrypoint';
-export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: {
+import { IsographEntrypoint } from './entrypoint';
+export declare function useLazyReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: {
     [key: string]: Variable;
 }): {
-    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
+    queryReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 };

package/dist/useLazyReference.js

@@ -3,20 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLazyReference = void 0;
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
 const IsographEnvironment_1 = require("./IsographEnvironment");
-const entrypoint_1 = require("./entrypoint");
 const cache_1 = require("./cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
-// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
-// if we do not explicitly pass a type, the read out type will be any.
-// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
-// any actual Entrypoint we pass will not be valid.
 function useLazyReference(entrypoint, variables) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    (0, entrypoint_1.assertIsEntrypoint)(entrypoint);
     const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
     // TODO add comment explaining why we never use this value
-    // @ts-ignore
-    const data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
+    // @ts-ignore(6133)
+    const _data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
     return {
         queryReference: {
             kind: 'FragmentReference',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-2f494978",
+  "version": "0.0.0-main-3779371d",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-2f494978",
-    "@isograph/react-disposable-state": "0.0.0-main-2f494978",
+    "@isograph/disposable-types": "0.0.0-main-3779371d",
+    "@isograph/react-disposable-state": "0.0.0-main-3779371d",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/cache.ts

@@ -76,15 +76,22 @@ export function stableCopy<T>(value: T): T {
 
 type IsoResolver = IsographEntrypoint<any, any>;
 
-export function getOrCreateCacheForArtifact<T>(
+export function getOrCreateCacheForArtifact<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+>(
   environment: IsographEnvironment,
-  artifact: IsographEntrypoint<any, T>,
+  artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
   variables: object,
-): ParentCache<PromiseWrapper<T>> {
+): ParentCache<PromiseWrapper<TClientFieldValue>> {
   const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
-  const factory: Factory<PromiseWrapper<T>> = () =>
-    makeNetworkRequest<T>(environment, artifact, variables);
-  return getOrCreateCache<PromiseWrapper<T>>(environment, cacheKey, factory);
+  const factory: Factory<PromiseWrapper<TClientFieldValue>> = () =>
+    makeNetworkRequest<TClientFieldValue>(environment, artifact, variables);
+  return getOrCreateCache<PromiseWrapper<TClientFieldValue>>(
+    environment,
+    cacheKey,
+    factory,
+  );
 }
 
 type NetworkRequestStatus =

package/src/useImperativeReference.ts

@@ -2,35 +2,26 @@ import {
   UnassignedState,
   useUpdatableDisposableState,
 } from '@isograph/react-disposable-state';
-import {
-  ExtractReadFromStore,
-  ExtractResolverResult,
-  IsographEntrypoint,
-} from './entrypoint';
+import { IsographEntrypoint } from './entrypoint';
 import { FragmentReference } from './FragmentReference';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 import { makeNetworkRequest } from './cache';
 import { ROOT_ID } from './IsographEnvironment';
 
 export function useImperativeReference<
-  TEntrypoint extends IsographEntrypoint<any, any>,
+  TReadFromStore extends Object,
+  TClientFieldValue,
 >(
-  entrypoint: TEntrypoint,
+  entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
 ): {
   queryReference:
-    | FragmentReference<
-        ExtractReadFromStore<TEntrypoint>,
-        ExtractResolverResult<TEntrypoint>
-      >
+    | FragmentReference<TReadFromStore, TClientFieldValue>
     | UnassignedState;
   loadQueryReference: (variables: { [index: string]: string }) => void;
 } {
   const { state, setState } =
     useUpdatableDisposableState<
-      FragmentReference<
-        ExtractReadFromStore<TEntrypoint>,
-        ExtractResolverResult<TEntrypoint>
-      >
+      FragmentReference<TReadFromStore, TClientFieldValue>
     >();
   const environment = useIsographEnvironment();
   return {

package/src/useLazyReference.ts

@@ -1,50 +1,25 @@
 import { FragmentReference, Variable } from './FragmentReference';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 import { ROOT_ID } from './IsographEnvironment';
-import {
-  ExtractReadFromStore,
-  ExtractResolverResult,
-  assertIsEntrypoint,
-} from './entrypoint';
+import { IsographEntrypoint } from './entrypoint';
 import { getOrCreateCacheForArtifact } from './cache';
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
-import { type PromiseWrapper } from './PromiseWrapper';
 
-// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
-// if we do not explicitly pass a type, the read out type will be any.
-// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
-// any actual Entrypoint we pass will not be valid.
-export function useLazyReference<TEntrypoint>(
-  entrypoint:
-    | TEntrypoint
-    // Temporarily, we need to allow useLazyReference to take the result of calling
-    // iso(`...`). At runtime, we confirm that the passed-in `iso` literal is actually
-    // an entrypoint.
-    | ((_: any) => any),
+export function useLazyReference<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+>(
+  entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
   variables: { [key: string]: Variable },
 ): {
-  queryReference: FragmentReference<
-    ExtractReadFromStore<TEntrypoint>,
-    ExtractResolverResult<TEntrypoint>
-  >;
+  queryReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 } {
   const environment = useIsographEnvironment();
-  assertIsEntrypoint<
-    ExtractReadFromStore<TEntrypoint>,
-    ExtractResolverResult<TEntrypoint>
-  >(entrypoint);
-  const cache = getOrCreateCacheForArtifact<ExtractResolverResult<TEntrypoint>>(
-    environment,
-    entrypoint,
-    variables,
-  );
+  const cache = getOrCreateCacheForArtifact(environment, entrypoint, variables);
 
   // TODO add comment explaining why we never use this value
-  // @ts-ignore
-  const data =
-    useLazyDisposableState<PromiseWrapper<ExtractResolverResult<TEntrypoint>>>(
-      cache,
-    ).state;
+  // @ts-ignore(6133)
+  const _data = useLazyDisposableState(cache).state;
 
   return {
     queryReference: {