@indietabletop/appkit 4.0.0-2 → 4.1.0

package/lib/store/types.ts

@@ -0,0 +1,45 @@
+import type { Failure, Success } from "../async-op.ts";
+import type { CurrentUser, FailurePayload, SessionInfo } from "../types.ts";
+
+export type EmitterActor<Outgoing> = {
+  sendBack: (event: Outgoing) => void;
+};
+
+export type PullResult =
+  | Success<{ pulled: SyncedItem[] }>
+  | Failure<FailurePayload>;
+
+export type PushResult =
+  | Success<{ pushed: SyncedItem[]; pulled: SyncedItem[] }>
+  | Failure<FailurePayload>;
+
+export type SyncedItem = {
+  id: string;
+  name: string;
+  updatedTs: number;
+  deleted: boolean;
+};
+
+export type SyncAttempt = {
+  startedTs: number;
+  pull: PullResult | null;
+  push: PushResult | null;
+};
+
+export type MachineContext = {
+  currentSync: SyncAttempt | null;
+  lastSuccessfulSyncTs: number | null;
+  currentUser: CurrentUser | null;
+  sessionInfo: SessionInfo | null;
+  pushOnceIdle: boolean;
+  syncLog: SyncAttempt[];
+};
+
+export type MachineEvent =
+  | { type: "push" }
+  | { type: "pull" }
+  | { type: "currentUser"; currentUser: CurrentUser }
+  | { type: "serverUser"; serverUser: CurrentUser }
+  | { type: "sessionInfo"; sessionInfo: SessionInfo }
+  | { type: "sessionExpired" }
+  | { type: "reset" };

package/lib/store/utils.ts

@@ -0,0 +1,46 @@
+import { Failure } from "../async-op.js";
+import type { UserGameData } from "../client.ts";
+import type { FailurePayload } from "../types.ts";
+import type { SyncedItem } from "./types.ts";
+
+/**
+ * Flattens the UserGameData structure to a flat SyncedItem[].
+ */
+
+export function toSyncedItems(data: UserGameData) {
+  return Object.values(data).flatMap((groups) => {
+    return Object.values(groups).flatMap((items) => {
+      return items.map((item): SyncedItem => {
+        return {
+          id: item.id,
+          name: item.name,
+          deleted: item.deleted,
+          updatedTs: item.updatedTs,
+        };
+      });
+    });
+  });
+}
+
+export function assertNonNullish<T>(
+  value: T,
+  message: string,
+): asserts value is NonNullable<T> {
+  if (value == null) {
+    throw new Error(message);
+  }
+}
+
+function isFailurePayload(
+  error: unknown,
+): error is { cause: Failure<FailurePayload> } {
+  return error instanceof Error && error.cause instanceof Failure;
+}
+
+export function caughtToResult(error: unknown): Failure<FailurePayload> {
+  if (isFailurePayload(error)) {
+    return error.cause;
+  }
+
+  return new Failure<FailurePayload>({ type: "UNKNOWN_ERROR" });
+}

package/lib/types/spacegits.ts

@@ -0,0 +1,108 @@
+import {
+  array,
+  assign,
+  enums,
+  literal,
+  nullable,
+  number,
+  object,
+  omit,
+  string,
+  type Infer,
+} from "superstruct";
+
+export type Ref = Infer<ReturnType<typeof ref>>;
+
+export type VehicleWeaponRef = Infer<ReturnType<typeof vehicleWeaponRef>>;
+
+export type TreatmentRef = Infer<ReturnType<typeof treatmentRef>>;
+
+export type RepairRef = Infer<ReturnType<typeof repairRef>>;
+
+export type VehicleData = Infer<ReturnType<typeof vehicleData>>;
+
+export type GitData = Infer<ReturnType<typeof gitData>>;
+
+export type GangTombstone = Infer<ReturnType<typeof gangTombstone>>;
+
+export type GangData = Infer<ReturnType<typeof gangData>>;
+
+export type GangSnapshotData = Infer<ReturnType<typeof gangSnapshotData>>;
+
+export function ref() {
+  return object({ id: string() });
+}
+
+export function treatmentRef() {
+  return assign(ref(), object({ locationId: string() }));
+}
+
+export function vehicleWeaponRef() {
+  return assign(
+    ref(),
+    object({ placement: enums(["FIXED", "PINTLE_MOUNTED"]) }),
+  );
+}
+
+export function repairRef() {
+  return assign(ref(), object({ locationId: string() }));
+}
+
+export function gitData() {
+  return object({
+    id: string(),
+    type: ref(),
+    name: string(),
+    weapons: array(ref()),
+    gear: array(ref()),
+    offenses: array(ref()),
+    treatments: array(treatmentRef()),
+  });
+}
+
+export function vehicleData() {
+  return object({
+    id: string(),
+    type: ref(),
+    name: string(),
+    mods: array(ref()),
+    repairs: array(repairRef()),
+    weapons: array(vehicleWeaponRef()),
+  });
+}
+
+export function gangTombstone() {
+  return object({
+    id: string(),
+    name: string(),
+    updatedTs: number(),
+    deleted: literal(true),
+  });
+}
+
+export function gangData() {
+  return object({
+    id: string(),
+    name: string(),
+    description: string(),
+    gits: array(gitData()),
+    vehicles: array(vehicleData()),
+    buildMode: enums([
+      "A_LA_CARTE",
+      "CHEFS_RECOMMENDATION",
+      "CHAOS_MODE",
+      "SANDBOX",
+    ]),
+    snapshotId: nullable(string()),
+    faction: nullable(ref()),
+    stash: number(),
+    createdTs: number(),
+    updatedTs: number(),
+    rulesetVersion: string(),
+    deleted: literal(false),
+  });
+}
+
+export function gangSnapshotData() {
+  return omit(gangData(), ["snapshotId", "deleted"]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indietabletop/appkit",
-  "version": "4.0.0-2",
+  "version": "4.1.0",
   "description": "A collection of modules used in apps built by Indie Tabletop Club",
   "private": false,
   "type": "module",
@@ -9,7 +9,8 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "test": "vitest",
-    "storybook": "storybook dev"
+    "storybook": "storybook dev",
+    "typecheck": "tsc --noEmit"
   },
   "exports": {
     ".": "./lib/index.ts",
@@ -44,10 +45,12 @@
     "@vanilla-extract/dynamic": "^2.1.3",
     "@vanilla-extract/recipes": "^0.5.7",
     "@vanilla-extract/sprinkles": "^1.6.3",
+    "@xstate/react": "^6.0.0",
     "nanoid": "^5.1.5",
     "superstruct": "^2.0.2",
     "swr": "^2.3.6",
-    "wouter": "^3.7.1"
+    "wouter": "^3.7.1",
+    "xstate": "^5.23.0"
   },
   "msw": {
     "workerDirectory": [