@isograph/react 0.1.1 → 0.3.0

package/src/core/PromiseWrapper.ts

@@ -0,0 +1,86 @@
+export type AnyError = any;
+
+const NOT_SET: Symbol = Symbol('NOT_SET');
+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 function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T, any> {
+  // TODO confirm suspense works if the promise is already resolved.
+  const wrapper: PromiseWrapper<T, any> = { promise, result: NOT_SET };
+  promise
+    .then((v) => {
+      // v is assignable to Exclude<T, Symbol> | Symbol
+      wrapper.result = { kind: 'Ok', value: v as any };
+    })
+    .catch((e) => {
+      // e is assignable to Exclude<T, Symbol> | Symbol
+      wrapper.result = { kind: 'Err', error: e as any };
+    });
+  return wrapper;
+}
+
+export function wrapResolvedValue<T>(value: T): PromiseWrapper<T, never> {
+  return {
+    promise: Promise.resolve(value),
+    result: {
+      kind: 'Ok',
+      // @ts-expect-error one should not call wrapResolvedValue with NOT_SET
+      value,
+    },
+  };
+}
+
+export function readPromise<T, E>(p: PromiseWrapper<T, E>): T {
+  const { result } = p;
+  if (result !== NOT_SET) {
+    // Safety: p.result is either NOT_SET or an actual value.
+    const resultKind = result as Result<T, any>;
+    if (resultKind.kind === 'Ok') {
+      return resultKind.value;
+    } else {
+      throw resultKind.error;
+    }
+  }
+
+  throw p.promise;
+}
+
+export type PromiseState<T, E> =
+  | {
+      kind: 'Pending';
+      promise: Promise<T>;
+    }
+  | Result<T, E>;
+
+export function getPromiseState<T, E>(
+  p: PromiseWrapper<T, E>,
+): PromiseState<T, E> {
+  const { result } = p;
+  if (result !== NOT_SET) {
+    // Safety: p.result is either NOT_SET or an actual value.
+    const resultKind = result as Result<T, any>;
+    return resultKind;
+  }
+  return {
+    kind: 'Pending',
+    promise: p.promise,
+  };
+}

package/src/core/areEqualWithDeepComparison.ts

@@ -0,0 +1,112 @@
+import type { ReaderAst, ReaderLinkedField, ReaderScalarField } from './reader';
+export function mergeUsingReaderAst(
+  field: ReaderScalarField | ReaderLinkedField,
+  oldItem: unknown,
+  newItem: unknown,
+): unknown {
+  if (newItem === null) {
+    return oldItem === null ? oldItem : newItem;
+  }
+
+  if (newItem === undefined) {
+    return oldItem === undefined ? oldItem : newItem;
+  }
+
+  if (Array.isArray(newItem)) {
+    if (!Array.isArray(oldItem)) {
+      return newItem;
+    }
+
+    return mergeArraysUsingReaderAst(field, oldItem, newItem);
+  }
+
+  switch (field.kind) {
+    case 'Scalar':
+      return oldItem === newItem ? oldItem : newItem;
+    case 'Linked':
+      if (oldItem == null) {
+        return newItem;
+      }
+
+      return mergeObjectsUsingReaderAst(field.selections, oldItem, newItem);
+    default: {
+      // Ensure we have covered all variants
+      let _: never = field;
+      _;
+      throw new Error('Unexpected case.');
+    }
+  }
+}
+
+export function mergeArraysUsingReaderAst(
+  field: ReaderScalarField | ReaderLinkedField,
+  oldItems: ReadonlyArray<unknown>,
+  newItems: Array<unknown>,
+): ReadonlyArray<unknown> {
+  if (newItems.length !== oldItems.length) {
+    return newItems;
+  }
+
+  let canRecycle = true;
+  for (let i = 0; i < newItems.length; i++) {
+    const mergedItem = mergeUsingReaderAst(field, oldItems[i], newItems[i]);
+    if (mergedItem !== oldItems[i]) {
+      canRecycle = false;
+    } else {
+      newItems[i] = mergedItem;
+    }
+  }
+
+  return canRecycle ? oldItems : newItems;
+}
+
+export function mergeObjectsUsingReaderAst(
+  ast: ReaderAst<object>,
+  oldItemObject: object,
+  newItemObject: object,
+): object {
+  let canRecycle = true;
+  for (const field of ast) {
+    switch (field.kind) {
+      case 'Scalar':
+      case 'Linked':
+        const key = field.alias ?? field.fieldName;
+        // @ts-expect-error
+        const oldValue = oldItemObject[key];
+        // @ts-expect-error
+        const newValue = newItemObject[key];
+
+        const mergedValue = mergeUsingReaderAst(field, oldValue, newValue);
+        if (mergedValue !== oldValue) {
+          canRecycle = false;
+        } else {
+          // @ts-expect-error
+          newItemObject[key] = mergedValue;
+        }
+        break;
+      case 'Resolver': {
+        const key = field.alias;
+        // @ts-expect-error
+        const oldValue = oldItemObject[key];
+        // @ts-expect-error
+        const newValue = newItemObject[key];
+
+        if (oldValue !== newValue) {
+          canRecycle = false;
+        }
+        break;
+      }
+      case 'ImperativelyLoadedField':
+      case 'LoadablySelectedField':
+        break;
+      default: {
+        // Ensure we have covered all variants
+        let _: never = field;
+        _;
+        throw new Error('Unexpected case.');
+      }
+    }
+  }
+
+  return canRecycle ? oldItemObject : newItemObject;
+}