@isograph/react 0.1.1 → 0.2.0

package/dist/core/FragmentReference.d.ts

@@ -0,0 +1,15 @@
+import { DataId } from './IsographEnvironment';
+import { ReaderWithRefetchQueries } from '../core/entrypoint';
+import { PromiseWrapper } from './PromiseWrapper';
+export type VariableValue = string | number | boolean | null | object;
+export type Variables = {
+    readonly [index: string]: VariableValue;
+};
+export type FragmentReference<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'FragmentReference';
+    readonly readerWithRefetchQueries: PromiseWrapper<ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>>;
+    readonly root: DataId;
+    readonly variables: Variables | null;
+    readonly networkRequest: PromiseWrapper<void, any>;
+};
+export declare function stableIdForFragmentReference(fragmentReference: FragmentReference<any, any>): string;

package/dist/core/FragmentReference.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableIdForFragmentReference = void 0;
+function stableIdForFragmentReference(fragmentReference) {
+    var _a;
+    return `${fragmentReference.root}/TODO_FRAGMENT_NAME/${serializeVariables((_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {})}`;
+}
+exports.stableIdForFragmentReference = stableIdForFragmentReference;
+function serializeVariables(variables) {
+    let s = '';
+    const keys = Object.keys(variables);
+    keys.sort();
+    for (const key of keys) {
+        s += `${key}:${variables[key]},`;
+    }
+    return s;
+}

package/dist/core/IsographEnvironment.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="react" />
+import { ParentCache } from '@isograph/react-disposable-state';
+import { RetainedQuery } from './garbageCollection';
+import { WithEncounteredRecords } from './read';
+import { FragmentReference, Variables } from './FragmentReference';
+import { PromiseWrapper } from './PromiseWrapper';
+import { IsographEntrypoint } from './entrypoint';
+export type ComponentOrFieldName = string;
+export type StringifiedArgs = string;
+type ComponentCache = {
+    [key: DataId]: {
+        [key: ComponentOrFieldName]: {
+            [key: StringifiedArgs]: React.FC<any>;
+        };
+    };
+};
+export type FragmentSubscription<TReadFromStore extends Object> = {
+    readonly kind: 'FragmentSubscription';
+    readonly callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void;
+    /** The value read out from the previous call to readButDoNotEvaluate */
+    readonly encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>;
+    readonly fragmentReference: FragmentReference<TReadFromStore, any>;
+};
+type AnyRecordSubscription = {
+    readonly kind: 'AnyRecords';
+    readonly callback: () => void;
+};
+type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
+type Subscriptions = Set<Subscription>;
+type CacheMap<T> = {
+    [index: string]: ParentCache<T>;
+};
+export type IsographEnvironment = {
+    readonly store: IsographStore;
+    readonly networkFunction: IsographNetworkFunction;
+    readonly missingFieldHandler: MissingFieldHandler | null;
+    readonly componentCache: ComponentCache;
+    readonly subscriptions: Subscriptions;
+    readonly fragmentCache: CacheMap<FragmentReference<any, any>>;
+    readonly entrypointArtifactCache: Map<string, PromiseWrapper<IsographEntrypoint<any, any>>>;
+    readonly retainedQueries: Set<RetainedQuery>;
+    readonly gcBuffer: Array<RetainedQuery>;
+    readonly gcBufferSize: number;
+};
+export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
+    [index: string]: any;
+} | null, variables: Variables | null) => Link | undefined;
+export type IsographNetworkFunction = (queryText: string, variables: Variables) => Promise<any>;
+export type Link = {
+    readonly __link: DataId;
+};
+export type DataTypeValue = undefined | number | boolean | string | null | Link | DataTypeValue[];
+export type StoreRecord = {
+    [index: DataId | string]: DataTypeValue;
+    readonly id?: DataId;
+};
+export type DataId = string;
+export declare const ROOT_ID: DataId & '__ROOT';
+export type IsographStore = {
+    [index: DataId]: StoreRecord | null;
+    readonly __ROOT: StoreRecord;
+};
+export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
+export declare function createIsographStore(): IsographStore;
+export declare function defaultMissingFieldHandler(_storeRecord: StoreRecord, _root: DataId, fieldName: string, arguments_: {
+    [index: string]: any;
+} | null, variables: Variables | null): Link | undefined;
+export declare function assertLink(link: DataTypeValue): Link | null | undefined;
+export declare function getLink(maybeLink: DataTypeValue): Link | null;
+export declare function getOrLoadIsographArtifact(environment: IsographEnvironment, key: string, loader: () => Promise<IsographEntrypoint<any, any>>): PromiseWrapper<IsographEntrypoint<any, any>>;
+export {};

package/dist/core/IsographEnvironment.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrLoadIsographArtifact = exports.getLink = exports.assertLink = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
+const PromiseWrapper_1 = require("./PromiseWrapper");
+exports.ROOT_ID = '__ROOT';
+const DEFAULT_GC_BUFFER_SIZE = 10;
+function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
+    return {
+        store,
+        networkFunction,
+        missingFieldHandler: missingFieldHandler !== null && missingFieldHandler !== void 0 ? missingFieldHandler : null,
+        componentCache: {},
+        subscriptions: new Set(),
+        fragmentCache: {},
+        entrypointArtifactCache: new Map(),
+        retainedQueries: new Set(),
+        gcBuffer: [],
+        gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
+    };
+}
+exports.createIsographEnvironment = createIsographEnvironment;
+function createIsographStore() {
+    return {
+        [exports.ROOT_ID]: {},
+    };
+}
+exports.createIsographStore = createIsographStore;
+function defaultMissingFieldHandler(_storeRecord, _root, fieldName, arguments_, variables) {
+    if (fieldName === 'node' || fieldName === 'user') {
+        const variable = arguments_ === null || arguments_ === void 0 ? void 0 : arguments_['id'];
+        const value = variables === null || variables === void 0 ? void 0 : variables[variable];
+        // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
+        if (value != null) {
+            // @ts-expect-error
+            return { __link: value };
+        }
+    }
+}
+exports.defaultMissingFieldHandler = defaultMissingFieldHandler;
+function assertLink(link) {
+    if (Array.isArray(link)) {
+        throw new Error('Unexpected array');
+    }
+    if (link == null) {
+        return link;
+    }
+    if (typeof link === 'object') {
+        return link;
+    }
+    throw new Error('Invalid link');
+}
+exports.assertLink = assertLink;
+function getLink(maybeLink) {
+    if (maybeLink != null &&
+        typeof maybeLink === 'object' &&
+        // @ts-expect-error this is safe
+        maybeLink.__link != null) {
+        return maybeLink;
+    }
+    return null;
+}
+exports.getLink = getLink;
+function getOrLoadIsographArtifact(environment, key, loader) {
+    const value = environment.entrypointArtifactCache.get(key);
+    if (value != null) {
+        return value;
+    }
+    const wrapped = (0, PromiseWrapper_1.wrapPromise)(loader());
+    environment.entrypointArtifactCache.set(key, wrapped);
+    return wrapped;
+}
+exports.getOrLoadIsographArtifact = getOrLoadIsographArtifact;

package/dist/core/PromiseWrapper.d.ts

@@ -0,0 +1,27 @@
+export type AnyError = any;
+declare const NOT_SET: Symbol;
+type NotSet = typeof NOT_SET;
+type Result<T, E> = {
+    kind: 'Ok';
+    value: T;
+} | {
+    kind: 'Err';
+    error: E;
+};
+/**
+ * Invariant:
+ * Before the promise is resolved, value becomes non-null.
+ */
+export type PromiseWrapper<T, E = any> = {
+    readonly promise: Promise<T>;
+    result: Result<Exclude<T, NotSet>, E> | NotSet;
+};
+export declare function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T, any>;
+export declare function wrapResolvedValue<T>(value: T): PromiseWrapper<T, never>;
+export declare function readPromise<T, E>(p: PromiseWrapper<T, E>): T;
+export type PromiseState<T, E> = {
+    kind: 'Pending';
+    promise: Promise<T>;
+} | Result<T, E>;
+export declare function getPromiseState<T, E>(p: PromiseWrapper<T, E>): PromiseState<T, E>;
+export {};

package/dist/core/PromiseWrapper.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPromiseState = exports.readPromise = exports.wrapResolvedValue = exports.wrapPromise = void 0;
+const NOT_SET = Symbol('NOT_SET');
+function wrapPromise(promise) {
+    // TODO confirm suspense works if the promise is already resolved.
+    const wrapper = { promise, result: NOT_SET };
+    promise
+        .then((v) => {
+        // v is assignable to Exclude<T, Symbol> | Symbol
+        wrapper.result = { kind: 'Ok', value: v };
+    })
+        .catch((e) => {
+        // e is assignable to Exclude<T, Symbol> | Symbol
+        wrapper.result = { kind: 'Err', error: e };
+    });
+    return wrapper;
+}
+exports.wrapPromise = wrapPromise;
+function wrapResolvedValue(value) {
+    return {
+        promise: Promise.resolve(value),
+        result: {
+            kind: 'Ok',
+            // @ts-expect-error one should not call wrapResolvedValue with NOT_SET
+            value,
+        },
+    };
+}
+exports.wrapResolvedValue = wrapResolvedValue;
+function readPromise(p) {
+    const { result } = p;
+    if (result !== NOT_SET) {
+        // Safety: p.result is either NOT_SET or an actual value.
+        const resultKind = result;
+        if (resultKind.kind === 'Ok') {
+            return resultKind.value;
+        }
+        else {
+            throw resultKind.error;
+        }
+    }
+    throw p.promise;
+}
+exports.readPromise = readPromise;
+function getPromiseState(p) {
+    const { result } = p;
+    if (result !== NOT_SET) {
+        // Safety: p.result is either NOT_SET or an actual value.
+        const resultKind = result;
+        return resultKind;
+    }
+    return {
+        kind: 'Pending',
+        promise: p.promise,
+    };
+}
+exports.getPromiseState = getPromiseState;

package/dist/core/areEqualWithDeepComparison.d.ts

@@ -0,0 +1,3 @@
+export declare function areEqualWithDeepComparison(oldItem: unknown, newItem: unknown): boolean;
+export declare function areEqualArraysWithDeepComparison(oldItems: ReadonlyArray<unknown>, newItems: ReadonlyArray<unknown>): boolean;
+export declare function areEqualObjectsWithDeepComparison(oldItemObject: object, newItemObject: object): boolean;

package/dist/core/areEqualWithDeepComparison.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEqualObjectsWithDeepComparison = exports.areEqualArraysWithDeepComparison = exports.areEqualWithDeepComparison = void 0;
+function areEqualWithDeepComparison(oldItem, newItem) {
+    if (newItem === null) {
+        return oldItem === null;
+    }
+    if (newItem === undefined) {
+        return oldItem === undefined;
+    }
+    if (Array.isArray(newItem)) {
+        if (!Array.isArray(oldItem)) {
+            return false;
+        }
+        return areEqualArraysWithDeepComparison(oldItem, newItem);
+    }
+    if (typeof newItem === 'object') {
+        if (typeof oldItem !== 'object') {
+            return false;
+        }
+        if (oldItem === null) {
+            return false;
+        }
+        return areEqualObjectsWithDeepComparison(oldItem, newItem);
+    }
+    return newItem === oldItem;
+}
+exports.areEqualWithDeepComparison = areEqualWithDeepComparison;
+function areEqualArraysWithDeepComparison(oldItems, newItems) {
+    if (newItems.length !== oldItems.length) {
+        return false;
+    }
+    for (let i = 0; i < newItems.length; i++) {
+        if (!areEqualWithDeepComparison(oldItems[i], newItems[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.areEqualArraysWithDeepComparison = areEqualArraysWithDeepComparison;
+function areEqualObjectsWithDeepComparison(oldItemObject, newItemObject) {
+    const oldKeys = Object.keys(oldItemObject);
+    const newKeys = Object.keys(newItemObject);
+    if (oldKeys.length !== newKeys.length) {
+        return false;
+    }
+    for (const oldKey of oldKeys) {
+        if (!(oldKey in newItemObject)) {
+            return false;
+        }
+        // @ts-expect-error
+        const oldValue = oldItemObject[oldKey];
+        // @ts-expect-error
+        const newValue = newItemObject[oldKey];
+        if (!areEqualWithDeepComparison(oldValue, newValue)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.areEqualObjectsWithDeepComparison = areEqualObjectsWithDeepComparison;

package/dist/core/cache.d.ts

@@ -0,0 +1,28 @@
+import { Factory, ParentCache } from '@isograph/react-disposable-state';
+import { DataId, type IsographEnvironment } from './IsographEnvironment';
+import { IsographEntrypoint, NormalizationAst, NormalizationLinkedField, NormalizationScalarField, RefetchQueryNormalizationArtifactWrapper } from '../core/entrypoint';
+import { ReaderLinkedField, ReaderScalarField } from './reader';
+import { WithEncounteredRecords } from './read';
+import { FragmentReference, Variables } from './FragmentReference';
+export declare function getOrCreateItemInSuspenseCache<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, index: string, factory: Factory<FragmentReference<TReadFromStore, TClientFieldValue>>): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
+/**
+ * Creates a copy of the provided value, ensuring any nested objects have their
+ * keys sorted such that equivalent values would have identical JSON.stringify
+ * results.
+ */
+export declare function stableCopy<T>(value: T): T;
+export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
+type NetworkResponseScalarValue = string | number | boolean;
+type NetworkResponseValue = NetworkResponseScalarValue | null | NetworkResponseObject | NetworkResponseObject[] | NetworkResponseScalarValue[];
+type NetworkResponseObject = {
+    [index: string]: undefined | NetworkResponseValue;
+    id?: DataId;
+};
+export declare function normalizeData(environment: IsographEnvironment, normalizationAst: NormalizationAst, networkResponse: NetworkResponseObject, variables: Variables, nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[]): Set<DataId>;
+export declare function subscribeToAnyChange(environment: IsographEnvironment, callback: () => void): () => void;
+export declare function subscribe<TReadFromStore extends Object>(environment: IsographEnvironment, encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<TReadFromStore, any>, callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void): () => void;
+export declare function onNextChange(environment: IsographEnvironment): Promise<void>;
+export declare function getParentRecordKey(astNode: NormalizationLinkedField | NormalizationScalarField | ReaderLinkedField | ReaderScalarField, variables: Variables): string;
+export declare const FIRST_SPLIT_KEY = "____";
+export declare const SECOND_SPLIT_KEY = "___";
+export {};