@couch-kit/core 0.8.2 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @couch-kit/core
 
+## 0.9.0
+
+### Minor Changes
+
+- [#36](https://github.com/faluciano/react-native-couch-kit/pull/36) [`a17371d`](https://github.com/faluciano/react-native-couch-kit/commit/a17371d9523e59c1fbffe94248bb2af080de3b51) Thanks [@faluciano](https://github.com/faluciano)! - Add CJS export for core package and fix host main field
+  - Added `require` export condition and CJS build step to `@couch-kit/core` for CommonJS consumers
+  - Fixed `@couch-kit/host` main field from `lib/index.d.ts` to `./src/index.tsx`
+  - Removed `typescript` from core `peerDependencies`
+  - Added `engines` field (`node >=18`) to all packages
+
+## 0.8.3
+
+### Patch Changes
+
+- [#33](https://github.com/faluciano/react-native-couch-kit/pull/33) [`8773b1d`](https://github.com/faluciano/react-native-couch-kit/commit/8773b1d8687247f3f77faf116c041a26c634c8d0) Thanks [@faluciano](https://github.com/faluciano)! - Access `crypto` via `globalThis.crypto` to avoid `ReferenceError` in React Native's Hermes engine where `typeof crypto` throws instead of returning `"undefined"`. Fixes `derivePlayerId` and `generateId` on Android TV.
+
 ## 0.8.2
 
 ### Patch Changes

package/dist/index.cjs

@@ -0,0 +1,286 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  toErrorMessage: () => toErrorMessage,
+  replayActions: () => replayActions,
+  isValidSecret: () => isValidSecret,
+  generateId: () => generateId,
+  derivePlayerIdLegacy: () => derivePlayerIdLegacy,
+  derivePlayerId: () => derivePlayerId,
+  createGameReducer: () => createGameReducer,
+  applyMiddleware: () => applyMiddleware,
+  actionValidator: () => actionValidator,
+  actionLogger: () => actionLogger,
+  MessageTypes: () => MessageTypes,
+  MAX_PENDING_PINGS: () => MAX_PENDING_PINGS,
+  MAX_FRAME_SIZE: () => MAX_FRAME_SIZE,
+  KEEPALIVE_TIMEOUT: () => KEEPALIVE_TIMEOUT,
+  KEEPALIVE_INTERVAL: () => KEEPALIVE_INTERVAL,
+  InternalActionTypes: () => InternalActionTypes,
+  DEFAULT_WS_PORT_OFFSET: () => DEFAULT_WS_PORT_OFFSET,
+  DEFAULT_WS_PATH: () => DEFAULT_WS_PATH,
+  DEFAULT_SYNC_INTERVAL: () => DEFAULT_SYNC_INTERVAL,
+  DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES,
+  DEFAULT_MAX_DELAY: () => DEFAULT_MAX_DELAY,
+  DEFAULT_HTTP_PORT: () => DEFAULT_HTTP_PORT,
+  DEFAULT_DISCONNECT_TIMEOUT: () => DEFAULT_DISCONNECT_TIMEOUT,
+  DEFAULT_BASE_DELAY: () => DEFAULT_BASE_DELAY
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/middleware.ts
+function applyMiddleware(...middlewares) {
+  return (reducer) => {
+    let currentState;
+    const api = {
+      getState: () => currentState
+    };
+    const baseDispatch = (action) => {
+      currentState = reducer(currentState, action);
+      return currentState;
+    };
+    const chain = middlewares.map((mw, index) => {
+      const layer = mw(api);
+      return (next) => {
+        return (action) => {
+          let nextCalled = false;
+          const safeNext = (a) => {
+            nextCalled = true;
+            return next(a);
+          };
+          const safeHandler = layer(safeNext);
+          try {
+            return safeHandler(action);
+          } catch (error) {
+            console.error(`[couch-kit] Middleware ${index} threw on action "${action.type}":`, error);
+            return nextCalled ? api.getState() : next(action);
+          }
+        };
+      };
+    });
+    const dispatch = chain.reduceRight((next, layer) => layer(next), baseDispatch);
+    return (state, action) => {
+      currentState = state;
+      return dispatch(action);
+    };
+  };
+}
+function actionLogger(options) {
+  const collapsed = options?.collapsed ?? true;
+  return (api) => (next) => (action) => {
+    const prevState = api.getState();
+    const group = collapsed ? console.groupCollapsed : console.group;
+    group(`[couch-kit] action ${action.type}`);
+    console.log("prev state", prevState);
+    console.log("action", action);
+    try {
+      const nextState = next(action);
+      console.log("next state", nextState);
+      return nextState;
+    } finally {
+      console.groupEnd();
+    }
+  };
+}
+var _internalTypes;
+function getInternalTypes() {
+  if (!_internalTypes) {
+    _internalTypes = new Set(Object.values(InternalActionTypes));
+  }
+  return _internalTypes;
+}
+function actionValidator(schema) {
+  return (_api) => (next) => (action) => {
+    if (getInternalTypes().has(action.type))
+      return next(action);
+    const validate = schema[action.type];
+    if (validate && !validate(action)) {
+      console.warn(`[couch-kit] Action "${action.type}" failed validation, skipping`);
+      return _api.getState();
+    }
+    return next(action);
+  };
+}
+
+// src/types.ts
+var InternalActionTypes = {
+  HYDRATE: "__HYDRATE__",
+  PLAYER_JOINED: "__PLAYER_JOINED__",
+  PLAYER_LEFT: "__PLAYER_LEFT__",
+  PLAYER_RECONNECTED: "__PLAYER_RECONNECTED__",
+  PLAYER_REMOVED: "__PLAYER_REMOVED__"
+};
+function createGameReducer(reducer, options) {
+  const baseReducer = (state, action) => {
+    switch (action.type) {
+      case InternalActionTypes.HYDRATE:
+        return action.payload;
+      case InternalActionTypes.PLAYER_JOINED: {
+        const { id, name, avatar } = action.payload;
+        return {
+          ...state,
+          players: {
+            ...state.players,
+            [id]: {
+              id,
+              name,
+              avatar,
+              isHost: false,
+              connected: true
+            }
+          }
+        };
+      }
+      case InternalActionTypes.PLAYER_LEFT: {
+        const { playerId } = action.payload;
+        const player = state.players[playerId];
+        if (!player)
+          return state;
+        return {
+          ...state,
+          players: {
+            ...state.players,
+            [playerId]: { ...player, connected: false }
+          }
+        };
+      }
+      case InternalActionTypes.PLAYER_RECONNECTED: {
+        const { playerId } = action.payload;
+        const player = state.players[playerId];
+        if (!player)
+          return state;
+        return {
+          ...state,
+          players: {
+            ...state.players,
+            [playerId]: { ...player, connected: true }
+          }
+        };
+      }
+      case InternalActionTypes.PLAYER_REMOVED: {
+        const { playerId } = action.payload;
+        if (!state.players[playerId])
+          return state;
+        const { [playerId]: _, ...remainingPlayers } = state.players;
+        return {
+          ...state,
+          players: remainingPlayers
+        };
+      }
+      default:
+        return reducer(state, action);
+    }
+  };
+  const middlewares = options?.middleware;
+  if (!middlewares || middlewares.length === 0)
+    return baseReducer;
+  return applyMiddleware(...middlewares)(baseReducer);
+}
+// src/protocol.ts
+var MessageTypes = {
+  JOIN: "JOIN",
+  ACTION: "ACTION",
+  PING: "PING",
+  ASSETS_LOADED: "ASSETS_LOADED",
+  WELCOME: "WELCOME",
+  STATE_UPDATE: "STATE_UPDATE",
+  PONG: "PONG",
+  RECONNECTED: "RECONNECTED",
+  ERROR: "ERROR"
+};
+// src/constants.ts
+var DEFAULT_HTTP_PORT = 8080;
+var DEFAULT_WS_PORT_OFFSET = 2;
+var DEFAULT_WS_PATH = "/ws";
+var MAX_FRAME_SIZE = 1024 * 1024;
+var DEFAULT_MAX_RETRIES = 5;
+var DEFAULT_BASE_DELAY = 1000;
+var DEFAULT_MAX_DELAY = 1e4;
+var DEFAULT_SYNC_INTERVAL = 5000;
+var MAX_PENDING_PINGS = 50;
+var DEFAULT_DISCONNECT_TIMEOUT = 5 * 60 * 1000;
+var KEEPALIVE_INTERVAL = 30000;
+var KEEPALIVE_TIMEOUT = 1e4;
+function generateId() {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes).map((b2) => b2.toString(16).padStart(2, "0")).join("");
+  }
+  const a = Math.random().toString(36).substring(2, 15);
+  const b = Math.random().toString(36).substring(2, 10);
+  return a + b;
+}
+function isValidSecret(secret) {
+  const hex = secret.replace(/-/g, "");
+  return hex.length >= 32 && /^[0-9a-f]+$/i.test(hex);
+}
+async function derivePlayerId(secret) {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.subtle?.digest === "function") {
+    const data = new TextEncoder().encode(secret);
+    const hash = await globalThis.crypto.subtle.digest("SHA-256", data);
+    return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
+  }
+  return derivePlayerIdLegacy(secret);
+}
+function derivePlayerIdLegacy(secret) {
+  return secret.replace(/-/g, "").slice(0, 16);
+}
+function toErrorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+// src/replay.ts
+function replayActions(recording, reducer) {
+  const snapshots = [];
+  let currentState = recording.initialState;
+  for (let i = 0;i < recording.actions.length; i++) {
+    const { action, timestamp } = recording.actions[i];
+    currentState = reducer(currentState, action);
+    snapshots.push({
+      state: currentState,
+      action,
+      timestamp,
+      index: i
+    });
+  }
+  const endTimestamp = recording.endTimestamp ?? (recording.actions.length > 0 ? recording.actions[recording.actions.length - 1].timestamp : recording.startTimestamp);
+  return {
+    finalState: currentState,
+    snapshots,
+    duration: endTimestamp - recording.startTimestamp,
+    actionCount: recording.actions.length
+  };
+}

package/dist/index.js

@@ -172,12 +172,12 @@ var DEFAULT_DISCONNECT_TIMEOUT = 5 * 60 * 1000;
 var KEEPALIVE_INTERVAL = 30000;
 var KEEPALIVE_TIMEOUT = 1e4;
 function generateId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
   }
-  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
     const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
+    globalThis.crypto.getRandomValues(bytes);
     return Array.from(bytes).map((b2) => b2.toString(16).padStart(2, "0")).join("");
   }
   const a = Math.random().toString(36).substring(2, 15);
@@ -189,9 +189,9 @@ function isValidSecret(secret) {
   return hex.length >= 32 && /^[0-9a-f]+$/i.test(hex);
 }
 async function derivePlayerId(secret) {
-  if (typeof crypto !== "undefined" && typeof crypto.subtle?.digest === "function") {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.subtle?.digest === "function") {
     const data = new TextEncoder().encode(secret);
-    const hash = await crypto.subtle.digest("SHA-256", data);
+    const hash = await globalThis.crypto.subtle.digest("SHA-256", data);
     return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
   }
   return derivePlayerIdLegacy(secret);

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@couch-kit/core",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
   "description": "Shared types, protocol, and game reducer for Couch Kit party games",
   "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/faluciano/react-native-couch-kit.git",
@@ -26,6 +29,7 @@
     ".": {
       "types": "./lib/index.d.ts",
       "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "default": "./dist/index.js"
     }
   },
@@ -38,7 +42,7 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target browser && tsc -p tsconfig.build.json",
+    "build": "bun build ./src/index.ts --outdir ./dist --target browser && bun build ./src/index.ts --outfile ./dist/index.cjs --target browser --format cjs && tsc -p tsconfig.build.json",
     "prepublishOnly": "bun run build",
     "test": "bun test",
     "lint": "eslint src/",
@@ -46,10 +50,6 @@
     "clean": "rm -rf dist lib"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
-    "eslint": "^8.57.0"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.4.0"
   }
 }

package/src/constants.ts

@@ -44,19 +44,19 @@ export const KEEPALIVE_TIMEOUT = 10000;
  */
 export function generateId(): string {
   if (
-    typeof crypto !== "undefined" &&
-    typeof crypto.randomUUID === "function"
+    typeof globalThis.crypto !== "undefined" &&
+    typeof globalThis.crypto.randomUUID === "function"
   ) {
-    return crypto.randomUUID();
+    return globalThis.crypto.randomUUID();
   }
 
   // Fallback: 32 hex chars from crypto.getRandomValues
   if (
-    typeof crypto !== "undefined" &&
-    typeof crypto.getRandomValues === "function"
+    typeof globalThis.crypto !== "undefined" &&
+    typeof globalThis.crypto.getRandomValues === "function"
   ) {
     const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
+    globalThis.crypto.getRandomValues(bytes);
     return Array.from(bytes)
       .map((b) => b.toString(16).padStart(2, "0"))
       .join("");
@@ -87,11 +87,11 @@ export function isValidSecret(secret: string): boolean {
  */
 export async function derivePlayerId(secret: string): Promise<string> {
   if (
-    typeof crypto !== "undefined" &&
-    typeof crypto.subtle?.digest === "function"
+    typeof globalThis.crypto !== "undefined" &&
+    typeof globalThis.crypto.subtle?.digest === "function"
   ) {
     const data = new TextEncoder().encode(secret);
-    const hash = await crypto.subtle.digest("SHA-256", data);
+    const hash = await globalThis.crypto.subtle.digest("SHA-256", data);
     return Array.from(new Uint8Array(hash))
       .map((b) => b.toString(16).padStart(2, "0"))
       .join("")