@indietabletop/appkit 6.1.6 → 7.0.0-0

package/lib/store/index.tsx

@@ -1,241 +0,0 @@
-import type { UserGameData } from "@indietabletop/types";
-import { createActorContext } from "@xstate/react";
-import { createContext, useContext, useMemo, type ReactNode } from "react";
-import { fromCallback, fromPromise } from "xstate";
-import { Failure, Success } from "../async-op.ts";
-import type { GameCode, IndieTabletopClient } from "../client.ts";
-import type { ModernIDB } from "../ModernIDB/ModernIDB.ts";
-import type { ModernIDBIndexes, ModernIDBSchema } from "../ModernIDB/types.ts";
-import type { CurrentUser } from "../types.ts";
-import {
-  machine,
-  type PullChangesInput,
-  type PushChangesInput,
-} from "./store.ts";
-import type { MachineEvent, PullResult, PushResult } from "./types.ts";
-import { toSyncedItems } from "./utils.ts";
-
-export type AppActions = {
-  clientLogout: (params: { serverUser: CurrentUser }) => Promise<void>;
-  serverLogout: () => Promise<void>;
-  logout: () => Promise<void>;
-  push: () => void;
-  pull: () => void;
-};
-
-export const AppActionsContext = createContext<null | AppActions>(null);
-
-const {
-  Provider: InternalMachineProvider,
-  useSelector,
-  useActorRef,
-} = createActorContext(machine);
-
-export { useActorRef, useSelector };
-
-export function useCurrentUser() {
-  return useSelector((s) => s.context.currentUser);
-}
-
-export function useSessionInfo() {
-  return useSelector((s) => s.context.sessionInfo);
-}
-
-export function useAppActions() {
-  const actions = useContext(AppActionsContext);
-
-  if (!actions) {
-    throw new Error(`Missing context value for app actions.`);
-  }
-
-  return actions;
-}
-
-export type DatabaseAppMachineMethods = {
-  upsertGameData(data: UserGameData): Promise<Success<string[]>>;
-
-  getUpdatedGameDataSince(props: {
-    sinceTs: number | null;
-    exclude: Set<string>;
-  }): Promise<Success<UserGameData>>;
-
-  clearAll(): Promise<Success<string> | Failure<string>>;
-};
-
-export function createAppMachineProvider<
-  Schema extends ModernIDBSchema,
-  Indexes extends ModernIDBIndexes<Schema>,
->(options: {
-  database: ModernIDB<Schema, Indexes> & DatabaseAppMachineMethods;
-  client: IndieTabletopClient;
-
-  /**
-   * Which games should the machine pull game data for?
-   *
-   * If null is provided, no data will be pulled.
-   *
-   * @remarks Honestly this is a bit hacky and we should have a better way to
-   * disable sync entirely for apps that don't need it (e.g. the Creators App).
-   */
-  pullGameDataFor: GameCode | GameCode[] | null;
-}) {
-  const { client, database } = options;
-
-  // Concrete implementations of actors that our machine requires.
-
-  const auth = fromCallback<MachineEvent>(({ sendBack }) => {
-    const controller = new AbortController();
-
-    client.addEventListener(
-      "currentUser",
-      ({ detail }) => void sendBack({ type: "currentUser", ...detail }),
-      controller,
-    );
-
-    client.addEventListener(
-      "sessionInfo",
-      ({ detail }) => void sendBack({ type: "sessionInfo", ...detail }),
-      controller,
-    );
-
-    client.addEventListener(
-      "sessionExpired",
-      () => void sendBack({ type: "sessionExpired" }),
-      controller,
-    );
-
-    return () => {
-      controller.abort();
-    };
-  });
-
-  const sync = fromCallback<MachineEvent>(({ sendBack }) => {
-    const controller = new AbortController();
-
-    // As long as sync is active, make sure to `pull` after every window focus.
-    window.addEventListener(
-      "focus",
-      () => void sendBack({ type: "pull" }),
-      controller,
-    );
-
-    // If there is a `readwrite` transaction in IndexedDB trigger a `push`.
-    database.addEventListener(
-      "readwrite",
-      () => void sendBack({ type: "push" }),
-      controller,
-    );
-
-    return () => {
-      controller.abort();
-    };
-  });
-
-  const pullChanges = fromPromise<PullResult, PullChangesInput>(
-    async ({ input }) => {
-      if (!options.pullGameDataFor) {
-        return new Success({ pulled: [] });
-      }
-
-      const result = await client.pullUserData({
-        include: options.pullGameDataFor,
-        sinceTs: input.sinceTs,
-        expectCurrentUserId: input.currentUser.id,
-      });
-
-      const userGameData = result.valueOrThrow();
-      await database.upsertGameData(userGameData);
-
-      return new Success({ pulled: toSyncedItems(userGameData) });
-    },
-  );
-
-  const pushChanges = fromPromise<PushResult, PushChangesInput>(
-    async ({ input }) => {
-      const { value: changedData } = await database.getUpdatedGameDataSince({
-        sinceTs: input.sinceTs,
-        exclude: new Set(input.ignoredItems.map((i) => i.id)),
-      });
-
-      const changed = toSyncedItems(changedData);
-
-      if (changed.length === 0) {
-        return new Success({ pushed: [], pulled: [] });
-      }
-
-      const result = await client.pushUserData({
-        data: changedData,
-        pullSinceTs: input.currentSyncTs,
-        currentSyncTs: input.currentSyncTs,
-        expectCurrentUserId: input.currentUser.id,
-      });
-
-      const userGameData = result.valueOrThrow();
-      await database.upsertGameData(userGameData);
-
-      return new Success({
-        pushed: changed,
-        pulled: toSyncedItems(userGameData),
-      });
-    },
-  );
-
-  // Bound provider components
-
-  function AppActionsProvider(props: { children: ReactNode }) {
-    const { children } = props;
-    const app = useActorRef();
-
-    const actions: AppActions = useMemo(() => {
-      async function clientLogout(params: { serverUser: CurrentUser }) {
-        await database.clearAll();
-        app.send({ type: "serverUser", ...params });
-
-        // Get new session info
-        await client.refreshTokens();
-      }
-
-      async function serverLogout() {
-        await client.logout();
-      }
-
-      async function logout() {
-        await client.logout();
-        await database.clearAll();
-        app.send({ type: "reset" });
-      }
-
-      function push() {
-        app.send({ type: "push" });
-      }
-
-      function pull() {
-        app.send({ type: "pull" });
-      }
-
-      return {
-        pull,
-        push,
-        logout,
-        serverLogout,
-        clientLogout,
-      };
-    }, [app]);
-
-    return <AppActionsContext value={actions}>{children}</AppActionsContext>;
-  }
-
-  return function AppMachineProvider(props: { children: ReactNode }) {
-    const { children } = props;
-
-    return (
-      <InternalMachineProvider
-        logic={machine.provide({
-          actors: { auth, sync, pullChanges, pushChanges },
-        })}
-      >
-        <AppActionsProvider>{children}</AppActionsProvider>
-      </InternalMachineProvider>
-    );
-  };
-}

package/lib/store/store.ts

@@ -1,479 +0,0 @@
-import { number } from "superstruct";
-import {
-  and,
-  assertEvent,
-  assign,
-  fromCallback,
-  fromPromise,
-  setup,
-} from "xstate";
-import {
-  createSafeStorage,
-  type SafeStorageKey,
-} from "../createSafeStorage.ts";
-import { currentUser, sessionInfo } from "../structs.ts";
-import type { CurrentUser, SessionInfo } from "../types.ts";
-import type {
-  MachineContext,
-  MachineEvent,
-  PullResult,
-  PushResult,
-  SyncedItem,
-} from "./types.ts";
-import { assertNonNullish, caughtToResult } from "./utils.ts";
-
-const safeStorage = createSafeStorage({
-  currentUser: currentUser(),
-  sessionInfo: sessionInfo(),
-  lastSuccessfulSyncTs: number(),
-});
-
-function createInMemoryContext(): Omit<
-  MachineContext,
-  SafeStorageKey<typeof safeStorage>
-> {
-  return {
-    currentSync: null,
-    pushOnceIdle: false,
-    syncLog: [],
-  };
-}
-
-function createInitialContext(): MachineContext {
-  return {
-    ...createInMemoryContext(),
-    currentUser: safeStorage.getItem("currentUser"),
-    sessionInfo: safeStorage.getItem("sessionInfo"),
-    lastSuccessfulSyncTs: safeStorage.getItem("lastSuccessfulSyncTs"),
-  };
-}
-
-const sync = fromCallback<MachineEvent>(() => {
-  throw new Error(`Sync actor not provided.`);
-});
-
-const auth = fromCallback<MachineEvent>(() => {
-  throw new Error(`Auth actor not provided.`);
-});
-
-export type PullChangesInput = {
-  sinceTs: number | null;
-  currentUser: CurrentUser;
-};
-
-const pullChanges = fromPromise<PullResult, PullChangesInput>(() => {
-  throw new Error(`Pull changes actor not provided.`);
-});
-
-export type PushChangesInput = {
-  sinceTs: number | null;
-  currentSyncTs: number;
-  ignoredItems: SyncedItem[];
-  currentUser: CurrentUser;
-};
-
-const pushChanges = fromPromise<PushResult, PushChangesInput>(async () => {
-  throw new Error(`Push changes actor not provided.`);
-});
-
-const config = setup({
-  types: {
-    context: {} as MachineContext,
-    events: {} as MachineEvent,
-    children: {} as {
-      sync: "sync";
-      auth: "auth";
-    },
-  },
-
-  actors: {
-    auth,
-    sync,
-    pullChanges,
-    pushChanges,
-  },
-
-  actions: {
-    setCurrentSync: assign({
-      currentSync: () => ({ startedTs: Date.now(), pull: null, push: null }),
-    }),
-
-    flushCurrentSync: assign(({ context }) => {
-      const { currentSync, syncLog } = context;
-
-      assertNonNullish(
-        currentSync,
-        "Flushing current sync but context.currentSync is nullish.",
-      );
-
-      return {
-        currentSync: null,
-        syncLog: [currentSync, ...syncLog],
-      };
-    }),
-
-    setLastSuccessfulSync: assign(({ context }) => {
-      assertNonNullish(
-        context.currentSync,
-        "Setting last successful sync but context.currentSync is nullish.",
-      );
-
-      const lastSuccessfulSyncTs = context.currentSync.startedTs;
-      safeStorage.setItem("lastSuccessfulSyncTs", lastSuccessfulSyncTs);
-      return { lastSuccessfulSyncTs };
-    }),
-
-    markSyncStepResult: assign({
-      currentSync: (
-        { context },
-        params: { pull?: PullResult; push?: PushResult },
-      ) => {
-        assertNonNullish(
-          context.currentSync,
-          "Marking sync step result but context.currentSync is nullish.",
-        );
-
-        return {
-          ...context.currentSync,
-          ...params,
-        };
-      },
-    }),
-
-    queuePush: assign({ pushOnceIdle: true }),
-
-    clearPushQueue: assign({ pushOnceIdle: false }),
-
-    setCurrentUser: assign((_, currentUser: CurrentUser) => {
-      safeStorage.setItem("currentUser", currentUser);
-      return { currentUser };
-    }),
-
-    patchSessionInfo: assign(({ context }, newSessionInfo: SessionInfo) => {
-      const sessionInfo = context.sessionInfo
-        ? { ...context.sessionInfo, expiresTs: newSessionInfo.expiresTs }
-        : newSessionInfo;
-
-      safeStorage.setItem("sessionInfo", sessionInfo);
-      return { sessionInfo };
-    }),
-
-    resetContext: assign((): MachineContext => {
-      safeStorage.clear();
-
-      return {
-        ...createInMemoryContext(),
-        currentUser: null,
-        sessionInfo: null,
-        lastSuccessfulSyncTs: null,
-      };
-    }),
-
-    resetWithServerUser: assign((_, serverUser: CurrentUser) => {
-      safeStorage.clear();
-      safeStorage.setItem("currentUser", serverUser);
-
-      return {
-        ...createInMemoryContext(),
-        currentUser: serverUser,
-        sessionInfo: null,
-        lastSuccessfulSyncTs: null,
-      };
-    }),
-  },
-
-  guards: {
-    shouldPushOnceIdle: ({ context }) => {
-      return context.pushOnceIdle;
-    },
-
-    isEligibleForSync: and(["isUserVerified", "isNotMismatched"]),
-
-    isUserVerified: ({ event }) => {
-      assertEvent(event, "currentUser");
-
-      return event.currentUser.isVerified;
-    },
-
-    isNotMismatched: ({ event, context }) => {
-      assertEvent(event, "currentUser");
-
-      // If there is no current user, there cannot be a mismatch
-      if (!context.currentUser) {
-        return true;
-      }
-
-      // Otherwise check that user IDs match.
-      return context.currentUser.id === event.currentUser.id;
-    },
-
-    hasBecomeEligibleForSync: and(["isNotMismatched", "hasBecomeVerified"]),
-
-    hasBecomeVerified: ({ event, context }) => {
-      assertEvent(event, "currentUser");
-
-      if (!context.currentUser) {
-        return false;
-      }
-
-      // User was unverified previously, but now they are verified.
-      return (
-        context.currentUser.isVerified === false &&
-        event.currentUser.isVerified === true
-      );
-    },
-  },
-});
-
-export const machine = config.createMachine({
-  /** @xstate-layout N4IgpgJg5mDOIC5QEMAOqDEAnOYAuA2gAwC6ioqA9rAJZ42UB25IAHogLQBMRAbAHQBOQbwCMggOy8ALES7DRAGhABPTvIn8AzAA5B0rdN4BWCRKKDRvAL7XlaVPwCujZE7wALMI3oBjZHiQGL5OWDg+AKqwYFjEZEggVLT0TCzsCEZc-FyiXHqiOtJcvLwSymoI3Fqi-LkiIjkSIrIStvbozq7uXj40-oEQwaHheFExBKLxFNR0DMwJ6dJL-GJ1gkTSwubS5Yj6mjrG602F0ietdiAOnW6e3n4BQSFh92OxXFOJMynzoIs6uwQljaVw6LluPQeAww0SwADcYm84iwkrNUgtEHkiICOKI8SDrhD7n1HoNniMkaQUd85mlELkctktLxDkQdDoJFYuGVVPTREZaoZjMKdNzRFILu1HETev0nsNXrCJp9UT86QhRVkiHVjDIiHwSlxAXiBaJDEVqkRzNVpASOjKofKXpElR9qclaRiENjed67dLusS5YNorBaEwAJKMABmlGRCVVnr+9JKAkE3LyPF4zN0Sl9JoEZukwuMos5Ev9-AdJOhofDjAAoqxUDQcBB49MPejkwhDDUtERqjwDBIuMYszitOnsmaOdJcqW5zZLoTA7LSfxYCpGL5N9vfDRGFAMBAmGBN3hHlX7WvHRA9zuHwejx2vl3fmxMcVpPxjOLNgOeISAYgLcsY-DmJIxjVJYg6iBslbVsGT5Poex6oE4sAeK+ibdp+CDwdqQjSHogimPopiGICxaaAU6bchseS6IIiG3jWkAoVuO5ofwGEADZ8WhJ5nvwh5wpQADW56rnc64DJx+48fxglHggYmUP0cxxDhNJ4ekuQbPwhz6AYA6FCUWjGgIHLCLopj8tqJmsbJd4KdxR68U4AlCTEWCUFgvF8QEsZYAAtteAYuex95cbusVKV5KlQGpjDiZpTDaVSCa6R++n8j+YjmKYo7ATovDGgY2SbCY2YkUczmQtFbnPlAnlYUJp6MOe6lSRFVZschsWoR5GHtap6npYwmUqjl6pWBIOhGdq1r6pyYqAgOtR8MY2q6HkYiag1QYbkN8UjZhHg+WE-mBcF-nhTJjWDfuw2taNl3jalGkBFppA6e+c26tZpksiRFjzgCvpcFwP7QUU46CDoQH8sYR1yRxQ00BAfFgBg73-WiuX0usAh-sBghaOYZWFICUg-nR0HajDejAWjrmY9juPKQTapejkxRLbk7KDoawqAtmgi-tDxhLNBZljmzTUczjGA80m+EFGI2haDrZhyKKxZGr6SNaNrOvjkU2aiqIivPY+ADuyCzEeeMXWren0lIWRkwBFhIzyFQslkdE8DLXBTtmkqgpFT0nS9jvO8erCwJegRVtGgRYAAFKIO1EAAlBgj3HfJQ0J-QL5ZZ2hNzUUWTcrwMMSNBZEmYCpaaI3lN8PqPDAbaIKMJQEBwCwDjujXXrcDLQgiOIdNyAoOKrLUBjjloPDHFOlbggNpIT7zPa4sBEH6gObImBy+qQxUHBGDUueitmMhmufqMrjeUXBgf6vpAbTI6CIKYAC9RLK+jvlIFYa9zakUcu-KU-Uv4bkPGAQSUAaAACMcY-w9kCQy4ckZ4gUGRcQgIKbgRRpsM0RYmhR2LujGK+4cFEw1KOABQDyYRwppOZYMgtC6m1DIUUSNlwIKQnHR8Z0oDMPVOmIg7DgEU1ATicUi0+FwxkLBeCdDP6x1Li9KRnlvJHhkV6EQi0CEcJAbwbh+YCrbW1MtWQiMWIfxjiXDGBjFLnTGtI7KAMvT8jyPwIw1ReBskKFYaCFUjI6z4Pwng1DCq2wkXFbxrVYqQFMT2cQeJT4imECRIoAd6Sm34SYfUiMzDh3HDoFJ+jJHpP4NGJ2OMIDZPwokzQ9l5xHHgrnBaoEpy1DMCRGGMMRBmFEdHRBejPGPixtg-xk8ew5AKNoJmHIdDdw5LTRu2hdTimbsAsU9T5m7nLmhDp+kIbaE5Drfko4ii5D2VkcpRzhTAW5FoWwtggA */
-  id: "app",
-  context: () => createInitialContext(),
-
-  invoke: {
-    id: "auth",
-    src: "auth",
-  },
-
-  initial: "unauthenticated",
-
-  on: {
-    reset: [
-      {
-        actions: "resetContext",
-        target: ".unauthenticated",
-      },
-    ],
-  },
-
-  states: {
-    unauthenticated: {
-      description:
-        "The user is either completely anonymous, authenticated via insecure means (localStorage), or in an otherwise no-correctly-authenticated state (e.g. user mismatch).",
-
-      on: {
-        currentUser: [
-          {
-            guard: "isEligibleForSync",
-            target: "authenticated",
-
-            actions: {
-              type: "setCurrentUser",
-              params: ({ event }) => event.currentUser,
-            },
-          },
-          {
-            guard: "isNotMismatched",
-            target: "authenticated.ineligible",
-
-            actions: {
-              type: "setCurrentUser",
-              params: ({ event }) => event.currentUser,
-            },
-          },
-          { target: "unauthenticated" },
-        ],
-        serverUser: {
-          target: "authenticated",
-          actions: {
-            type: "resetWithServerUser",
-            params: ({ event }) => event.serverUser,
-          },
-        },
-      },
-    },
-
-    authenticated: {
-      description: "The user has a session with ITC.",
-
-      initial: "sync",
-
-      on: {
-        currentUser: [
-          {
-            guard: "hasBecomeEligibleForSync",
-            target: "authenticated",
-            reenter: true,
-
-            actions: {
-              type: "setCurrentUser",
-              params: ({ event }) => event.currentUser,
-            },
-          },
-          {
-            guard: "isNotMismatched",
-            actions: {
-              type: "setCurrentUser",
-              params: ({ event }) => event.currentUser,
-            },
-          },
-          {
-            target: "unauthenticated",
-          },
-        ],
-
-        sessionInfo: {
-          actions: {
-            type: "patchSessionInfo",
-            params: ({ event }) => event.sessionInfo,
-          },
-        },
-
-        sessionExpired: {
-          target: "unauthenticated",
-        },
-      },
-
-      states: {
-        ineligible: {
-          description: "The user is not eligible for sync (e.g. unverified)",
-        },
-
-        sync: {
-          description: "The user is eligible for the sync feature.",
-          invoke: {
-            id: "sync",
-            src: "sync",
-          },
-
-          initial: "syncing",
-
-          states: {
-            syncing: {
-              description: "The sync operation is in progress.",
-              initial: "pulling",
-              entry: "setCurrentSync",
-              exit: "flushCurrentSync",
-
-              on: {
-                push: {
-                  actions: "queuePush",
-                },
-              },
-
-              states: {
-                pulling: {
-                  invoke: {
-                    src: "pullChanges",
-                    input: ({ context }) => ({
-                      sinceTs: context.lastSuccessfulSyncTs,
-                      currentUser: context.currentUser!,
-                    }),
-                    onDone: {
-                      target: "pushing",
-                      actions: [
-                        {
-                          type: "markSyncStepResult",
-                          params: ({ event }) => ({
-                            pull: event.output,
-                          }),
-                        },
-                      ],
-                    },
-                    onError: {
-                      target: "failed",
-                      actions: {
-                        type: "markSyncStepResult",
-                        params: ({ event }) => ({
-                          pull: caughtToResult(event.error),
-                        }),
-                      },
-                    },
-                  },
-                },
-                pushing: {
-                  entry: "clearPushQueue",
-
-                  invoke: {
-                    src: "pushChanges",
-                    input: ({ context }) => {
-                      assertNonNullish(
-                        context.currentSync,
-                        "Setting pushChanges input but context.currentSync is unset.",
-                      );
-
-                      assertNonNullish(
-                        context.currentUser,
-                        "Setting pushChanges input but context.currentUser is unset.",
-                      );
-
-                      // This value might be unset if no push was made during
-                      // this sync attempt.
-                      const pulledItems =
-                        context.currentSync.pull?.valueOrNull()?.pulled ?? [];
-
-                      return {
-                        ignoredItems: pulledItems,
-                        currentSyncTs: context.currentSync.startedTs,
-                        sinceTs: context.lastSuccessfulSyncTs,
-                        currentUser: context.currentUser,
-                      };
-                    },
-                    onDone: {
-                      target: "synced",
-                      actions: {
-                        type: "markSyncStepResult",
-                        params: ({ event }) => ({
-                          push: event.output,
-                        }),
-                      },
-                    },
-                    onError: {
-                      target: "failed",
-                      actions: {
-                        type: "markSyncStepResult",
-                        params: ({ event }) => ({
-                          push: caughtToResult(event.error),
-                        }),
-                      },
-                    },
-                  },
-                },
-                synced: {
-                  type: "final",
-                  entry: "setLastSuccessfulSync",
-                },
-
-                failed: {
-                  type: "final",
-                },
-              },
-
-              onDone: "idle",
-            },
-
-            idle: {
-              description: "The app is listening for sync events.",
-              always: {
-                guard: "shouldPushOnceIdle",
-                target: "waiting",
-              },
-              on: {
-                push: "waiting",
-                pull: "syncing",
-              },
-            },
-
-            waiting: {
-              description:
-                "We are waiting for further push events to batch them.",
-
-              after: {
-                1500: {
-                  target: "syncing.pushing",
-                },
-              },
-
-              on: {
-                push: {
-                  target: "waiting",
-                  reenter: true,
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-});