@indietabletop/appkit 7.0.0-rc.4 → 7.0.0-rc.6

package/lib/AppConfig/AppConfig.tsx

@@ -58,7 +58,7 @@ export type AppConfig = {
    */
   fmt: AppkitFormatters;
 
-  database: ModernIDB<any, any> & DatabaseAppMachineMethods;
+  database: ModernIDB<any, any> & DatabaseAppMachineMethods<any>;
 };
 
 const [AppConfigContext, useAppConfig] = createStrictContext<AppConfig>();

package/lib/RichText/style.css.ts

@@ -21,7 +21,6 @@ globalStyle(`${content} > :first-child`, {
 
 globalStyle(`${content} em`, {
   fontFamily: richTextTheme.emphasisFont,
-  textTransform: "lowercase",
 });
 
 globalStyle(`${content} :is(h1, h2, h3, h4, h5, h6)`, {

package/lib/client.ts

@@ -14,7 +14,6 @@ import {
   partial,
   string,
   Struct,
-  unknown,
   type Infer,
 } from "superstruct";
 import { Failure, Success } from "./async-op.ts";
@@ -42,9 +41,8 @@ type ClientEventMap = {
 };
 
 type ClientEventArgs<T extends ClientEventType> =
-  ClientEventMap[T] extends undefined
-    ? [type: T]
-    : [type: T, detail: ClientEventMap[T]];
+  ClientEventMap[T] extends undefined ? [type: T]
+  : [type: T, detail: ClientEventMap[T]];
 
 export class ClientEvent<T extends keyof ClientEventMap> extends CustomEvent<
   ClientEventMap[T]
@@ -70,8 +68,8 @@ function toParams(init: Record<string, Primitives | Array<Primitives>>) {
   const params = new URLSearchParams();
 
   const entries = Object.entries(init).flatMap(([key, value]) => {
-    return Array.isArray(value)
-      ? value.map((v) => [key, v] as const)
+    return Array.isArray(value) ?
+        value.map((v) => [key, v] as const)
       : [[key, value] as const];
   });
 
@@ -82,13 +80,22 @@ function toParams(init: Record<string, Primitives | Array<Primitives>>) {
   return params;
 }
 
-export class IndieTabletopClient {
+export class IndieTabletopClient<
+  SnapshotPayload = any,
+  GameDataPayload = any,
+  RulesetPayload = any,
+> {
   origin: string;
   private refreshTokenPromise?: Promise<
     Success<{ sessionInfo: SessionInfo }> | Failure<FailurePayload>
   >;
   private maxLogLevel: number;
   private eventTarget: EventTarget;
+  private validation: {
+    snapshot: Struct<SnapshotPayload, any>;
+    gameData: Struct<GameDataPayload, any>;
+    ruleset: Struct<RulesetPayload, any>;
+  };
 
   constructor(props: {
     apiOrigin: string;
@@ -119,10 +126,17 @@ export class IndieTabletopClient {
      * @default 'info'
      */
     logLevel?: LogLevel;
+
+    validation: {
+      snapshot: Struct<SnapshotPayload, any>;
+      gameData: Struct<GameDataPayload, any>;
+      ruleset: Struct<RulesetPayload, any>;
+    };
   }) {
     this.eventTarget = new EventTarget();
     this.origin = props.apiOrigin;
     this.maxLogLevel = props.logLevel ? logLevelToInt[props.logLevel] : 1;
+    this.validation = props.validation;
 
     // If handlers were passed to the constructor, we set them up here. No need
     // to clean them up, as if the instance is destroyed, the listeners will
@@ -466,12 +480,11 @@ export class IndieTabletopClient {
     return req;
   }
 
-  async getSnapshot<T, S>(
-    gameCode: string,
-    snapshotId: string,
-    struct: Struct<T, S>,
-  ) {
-    return await this.fetch(`/v1/snapshots/${gameCode}/${snapshotId}`, struct);
+  async getSnapshot(gameCode: string, snapshotId: string) {
+    return await this.fetch(
+      `/v1/snapshots/${gameCode}/${snapshotId}`,
+      this.validation.snapshot,
+    );
   }
 
   async createSnapshot(gameCode: string, payload: object) {
@@ -503,7 +516,10 @@ export class IndieTabletopClient {
   }
 
   getRuleset(game: string, version: string) {
-    return this.fetch(`/v1/rulesets/${game}/${version}`, unknown());
+    return this.fetch(
+      `/v1/rulesets/${game}/${version}`,
+      this.validation.ruleset,
+    );
   }
 
   /**
@@ -578,7 +594,9 @@ export class IndieTabletopClient {
 
   async pullUserData(props: {
     sinceTs: number | null;
-    include: GameCode | GameCode[];
+    include:
+      | (string & keyof GameDataPayload)
+      | (string & keyof GameDataPayload)[];
     expectCurrentUserId: string;
   }) {
     const params = toParams({
@@ -590,30 +608,26 @@ export class IndieTabletopClient {
 
     return await this.fetch(
       `/v1/me/game-data?${params}`,
-      unknown() as Struct<UserGameData, null>,
+      this.validation.gameData,
     );
   }
 
   async pushUserData(props: {
     currentSyncTs: number;
     pullSinceTs: number | null;
-    data: UserGameData;
+    data: GameDataPayload;
     expectCurrentUserId: string | null | undefined;
   }) {
-    return await this.fetch(
-      `/v1/me/game-data`,
-      unknown() as Struct<UserGameData, null>,
-      {
-        method: "PATCH",
-        json: {
-          data: props.data,
-          syncedTs: props.currentSyncTs,
-          pullSinceTs: props.pullSinceTs ?? 0,
-          pullOmitDeleted: !props.pullSinceTs,
-          expectCurrentUserId: props.expectCurrentUserId,
-        },
+    return await this.fetch(`/v1/me/game-data`, this.validation.gameData, {
+      method: "PATCH",
+      json: {
+        data: props.data,
+        syncedTs: props.currentSyncTs,
+        pullSinceTs: props.pullSinceTs ?? 0,
+        pullOmitDeleted: !props.pullSinceTs,
+        expectCurrentUserId: props.expectCurrentUserId,
       },
-    );
+    });
   }
 
   async getUnlocks<T extends FeatureUnlock["gameCode"]>(gameCode: T) {

package/lib/store/index.tsx

@@ -1,10 +1,9 @@
-import type { UserGameData } from "@indietabletop/types";
 import { useActorRef, useSelector } from "@xstate/react";
 import { useMemo, type ReactNode } from "react";
 import { Actor, fromCallback, fromPromise } from "xstate";
 import { useAppConfig } from "../AppConfig/AppConfig.tsx";
 import { Failure, Success } from "../async-op.ts";
-import type { GameCode, IndieTabletopClient } from "../client.ts";
+import type { IndieTabletopClient } from "../client.ts";
 import { createStrictContext } from "../createStrictContext.ts";
 import type { ModernIDB } from "../ModernIDB/ModernIDB.ts";
 import type { ModernIDBIndexes, ModernIDBSchema } from "../ModernIDB/types.ts";
@@ -16,7 +15,7 @@ import {
   type PushChangesInput,
 } from "./store.ts";
 import type { MachineEvent, PullResult, PushResult } from "./types.ts";
-import { toSyncedItems } from "./utils.ts";
+import { toSyncedItems, type UserGameDataShape } from "./utils.ts";
 
 export type AppActions = ReturnType<typeof useCreateActions>;
 
@@ -104,13 +103,13 @@ export function useAppActions() {
   return useAppMachineContext().actions;
 }
 
-export type DatabaseAppMachineMethods = {
-  upsertGameData(data: UserGameData): Promise<Success<string[]>>;
+export type DatabaseAppMachineMethods<GameDataPayload> = {
+  upsertGameData(data: GameDataPayload): Promise<Success<string[]>>;
 
   getUpdatedGameDataSince(props: {
     sinceTs: number | null;
     exclude: Set<string>;
-  }): Promise<Success<UserGameData>>;
+  }): Promise<Success<GameDataPayload>>;
 
   clearAll(): Promise<Success<string> | Failure<string>>;
 };
@@ -118,9 +117,14 @@ export type DatabaseAppMachineMethods = {
 export function createMachine<
   Schema extends ModernIDBSchema,
   Indexes extends ModernIDBIndexes<Schema>,
+  SnapshotPayload,
+  GameDataPayload extends UserGameDataShape,
+  RulesetPayload,
 >(options: {
-  database: ModernIDB<Schema, Indexes> & DatabaseAppMachineMethods;
-  client: IndieTabletopClient;
+  database: ModernIDB<Schema, Indexes> &
+    DatabaseAppMachineMethods<GameDataPayload>;
+
+  client: IndieTabletopClient<SnapshotPayload, GameDataPayload, RulesetPayload>;
 
   /**
    * Which games should the machine pull game data for?
@@ -130,7 +134,10 @@ export function createMachine<
    * @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;
+  pullGameDataFor:
+    | (string & keyof GameDataPayload)
+    | (string & keyof GameDataPayload)[]
+    | null;
 }) {
   const { client, database } = options;
 

package/lib/store/utils.ts

@@ -1,12 +1,22 @@
-import type { UserGameData } from "@indietabletop/types";
 import { Failure } from "../async-op.js";
 import type { FailurePayload } from "../types.ts";
 import type { SyncedItem } from "./types.ts";
 
+export type UserGameDataShape = Record<
+  string,
+  Record<
+    string,
+    (
+      | { id: string; name: string; updatedTs: number }
+      | { id: string; name: string; updatedTs: number; deleted: boolean }
+    )[]
+  >
+>;
+
 /**
  * Flattens the UserGameData structure to a flat SyncedItem[].
  */
-export function toSyncedItems(data: UserGameData) {
+export function toSyncedItems(data: UserGameDataShape) {
   return Object.values(data).flatMap((groups) => {
     return Object.values(groups).flatMap((items) => {
       return items.map((item): SyncedItem => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indietabletop/appkit",
-  "version": "7.0.0-rc.4",
+  "version": "7.0.0-rc.6",
   "description": "A collection of modules used in apps built by Indie Tabletop Club",
   "private": false,
   "type": "module",