@isograph/react 0.0.0-main-54ebe831 → 0.0.0-main-6d83b6a2

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { DataId, StoreRecord, Link } from './cache';
 export { setNetwork, makeNetworkRequest, subscribe, DataId, Link, StoreRecord, clearStore, } from './cache';
+export { iso } from './iso';
 export type IsographEntrypoint<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
     kind: 'Entrypoint';
     queryText: string;
@@ -95,7 +96,6 @@ export type FragmentReference<TReadFromStore extends Object, TResolverProps, TRe
     } | null;
     nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
-export declare function iso<TResolverParameter>(_queryText: TemplateStringsArray): <TResolverReturn>(x: (param: TResolverParameter) => TResolverReturn) => (param: TResolverParameter) => TResolverReturn;
 type ExtractTReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any, any> ? X : never;
 type ExtractResolverProps<Type> = Type extends IsographEntrypoint<any, infer X, any> ? X : never;
 type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, any, infer X> ? X : never;

package/dist/index.js

@@ -9,23 +9,12 @@ Object.defineProperty(exports, "setNetwork", { enumerable: true, get: function (
 Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_2.makeNetworkRequest; } });
 Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_2.subscribe; } });
 Object.defineProperty(exports, "clearStore", { enumerable: true, get: function () { return cache_2.clearStore; } });
+var iso_1 = require("./iso");
+Object.defineProperty(exports, "iso", { enumerable: true, get: function () { return iso_1.iso; } });
 function assertIsEntrypoint(value) {
     if (typeof value === 'function')
         throw new Error('Not a string');
 }
-function iso(_queryText) {
-    // The name `identity` here is a bit of a double entendre.
-    // First, it is the identity function, constrained to operate
-    // on a very specific type. Thus, the value of b Declare`...`(
-    // someFunction) is someFunction. But furthermore, if one
-    // write b Declare`...` and passes no function, the resolver itself
-    // is the identity function. At that point, the types
-    // TResolverParameter and TResolverReturn must be identical.
-    return function identity(x) {
-        return x;
-    };
-}
-exports.iso = iso;
 // 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

package/dist/iso.d.ts

@@ -0,0 +1 @@
+export declare function iso<TResolverParameter>(_queryText: TemplateStringsArray): <TResolverReturn>(x: (param: TResolverParameter) => TResolverReturn) => (param: TResolverParameter) => TResolverReturn;

package/dist/iso.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iso = void 0;
+function iso(_queryText) {
+    // The name `identity` here is a bit of a double entendre.
+    // First, it is the identity function, constrained to operate
+    // on a very specific type. Thus, the value of b Declare`...`(
+    // someFunction) is someFunction. But furthermore, if one
+    // write b Declare`...` and passes no function, the resolver itself
+    // is the identity function. At that point, the types
+    // TResolverParameter and TResolverReturn must be identical.
+    return function identity(x) {
+        return x;
+    };
+}
+exports.iso = iso;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-54ebe831",
+  "version": "0.0.0-main-6d83b6a2",
   "description": "Use Isograph with React",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-54ebe831",
-    "@isograph/react-disposable-state": "0.0.0-main-54ebe831",
+    "@isograph/disposable-types": "0.0.0-main-6d83b6a2",
+    "@isograph/react-disposable-state": "0.0.0-main-6d83b6a2",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/index.tsx

@@ -23,6 +23,8 @@ export {
   clearStore,
 } from './cache';
 
+export { iso } from './iso';
+
 // This type should be treated as an opaque type.
 export type IsographEntrypoint<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
   kind: 'Entrypoint';
@@ -152,26 +154,6 @@ function assertIsEntrypoint<TReadFromStore extends Object, TResolverProps, TReso
   if (typeof value === 'function') throw new Error('Not a string');
 }
 
-export function iso<TResolverParameter>(
-  _queryText: TemplateStringsArray,
-): <TResolverReturn>(
-  x: (param: TResolverParameter) => TResolverReturn,
-) => (param: TResolverParameter) => TResolverReturn {
-  // The name `identity` here is a bit of a double entendre.
-  // First, it is the identity function, constrained to operate
-  // on a very specific type. Thus, the value of b Declare`...`(
-  // someFunction) is someFunction. But furthermore, if one
-  // write b Declare`...` and passes no function, the resolver itself
-  // is the identity function. At that point, the types
-  // TResolverParameter and TResolverReturn must be identical.
-
-  return function identity<TResolverReturn>(
-    x: (param: TResolverParameter) => TResolverReturn,
-  ): (param: TResolverParameter) => TResolverReturn {
-    return x;
-  };
-}
-
 type ExtractTReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any, any> ? X : never;
 type ExtractResolverProps<Type> = Type extends IsographEntrypoint<any, infer X, any> ? X : never;
 type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, any, infer X> ? X : never;

package/src/iso.tsx

@@ -0,0 +1,19 @@
+export function iso<TResolverParameter>(
+  _queryText: TemplateStringsArray,
+): <TResolverReturn>(
+  x: (param: TResolverParameter) => TResolverReturn,
+) => (param: TResolverParameter) => TResolverReturn {
+  // The name `identity` here is a bit of a double entendre.
+  // First, it is the identity function, constrained to operate
+  // on a very specific type. Thus, the value of b Declare`...`(
+  // someFunction) is someFunction. But furthermore, if one
+  // write b Declare`...` and passes no function, the resolver itself
+  // is the identity function. At that point, the types
+  // TResolverParameter and TResolverReturn must be identical.
+
+  return function identity<TResolverReturn>(
+    x: (param: TResolverParameter) => TResolverReturn,
+  ): (param: TResolverParameter) => TResolverReturn {
+    return x;
+  };
+}