@holo-js/flux 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -13,11 +13,13 @@ type ManifestPresenceMember<TManifest extends GeneratedBroadcastManifest, TPatte
     member: infer TMember;
 } ? TMember : BroadcastJsonObject;
 type ManifestWhisperName<TManifest extends GeneratedBroadcastManifest, TPattern extends string> = ManifestChannelEntryByPattern<TManifest, TPattern>['whispers'][number] & string;
-type ManifestEventNamesForPattern<TManifest extends GeneratedBroadcastManifest, TPattern extends string> = Extract<TManifest['events'][number], {
-    channels: readonly {
-        pattern: TPattern;
+type ManifestEventNamesForPattern<TManifest extends GeneratedBroadcastManifest, TPattern extends string> = TManifest['events'][number] extends infer TEvent ? TEvent extends {
+    readonly name: infer TName;
+    readonly channels: readonly {
+        readonly pattern: infer TEventPattern;
     }[];
-}>['name'] & string;
+} ? TPattern extends TEventPattern & string ? TName & string : never : never : never;
+type ManifestSubscriptionEventName<TManifest extends GeneratedBroadcastManifest, TChannel extends string> = string extends ManifestEventName<TManifest> ? string : TChannel extends ManifestChannelPattern<TManifest> ? ManifestEventNamesForPattern<TManifest, TChannel> : ManifestEventName<TManifest>;
 interface FluxClientOptions<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest> {
     readonly manifest?: TManifest;
     readonly connection?: string;
@@ -33,6 +35,11 @@ interface FluxListenerControls {
 interface FluxPresenceState<TMember = unknown> {
     readonly members: readonly TMember[];
 }
+interface FluxPresenceListenerControls<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends string = string> {
+    here(callback: (members: readonly ManifestPresenceMember<TManifest, TChannel>[]) => void): FluxPresenceSubscription<TManifest, TChannel>;
+    joining(callback: (member: ManifestPresenceMember<TManifest, TChannel>) => void): FluxPresenceSubscription<TManifest, TChannel>;
+    leaving(callback: (member: ManifestPresenceMember<TManifest, TChannel>) => void): FluxPresenceSubscription<TManifest, TChannel>;
+}
 interface FluxConnectionControls {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -60,12 +67,12 @@ interface FluxConnector {
 interface FluxSubscription<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends string = string> extends FluxListenerControls {
     readonly name: TChannel;
     readonly type: FluxChannelKind;
-    listen<TEvent extends ManifestEventNamesForPattern<TManifest, TChannel> | ManifestEventName<TManifest>>(event?: TEvent | readonly TEvent[], callback?: (payload: BroadcastJsonObject) => void): FluxSubscription<TManifest, TChannel>;
+    listen<TEvent extends ManifestSubscriptionEventName<TManifest, TChannel>>(event?: TEvent | readonly TEvent[], callback?: (payload: BroadcastJsonObject) => void): FluxSubscription<TManifest, TChannel>;
     notification(callback: (payload: BroadcastJsonObject) => void): FluxSubscription<TManifest, TChannel>;
     listenForWhisper<TWhisper extends ManifestWhisperName<TManifest, TChannel>>(name: TWhisper, callback: (payload: BroadcastJsonObject) => void): FluxSubscription<TManifest, TChannel>;
     whisper<TWhisper extends ManifestWhisperName<TManifest, TChannel>>(name: TWhisper, payload: BroadcastJsonObject): Promise<void>;
 }
-interface FluxPresenceSubscription<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends string = string> extends FluxSubscription<TManifest, TChannel>, FluxPresenceState<ManifestPresenceMember<TManifest, TChannel>> {
+interface FluxPresenceSubscription<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends string = string> extends FluxSubscription<TManifest, TChannel>, FluxPresenceState<ManifestPresenceMember<TManifest, TChannel>>, FluxPresenceListenerControls<TManifest, TChannel> {
 }
 interface FluxClient<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest> extends FluxConnectionControls {
     readonly options: Readonly<FluxClientOptions<TManifest>>;
@@ -94,7 +101,7 @@ declare function createSubscription<TManifest extends GeneratedBroadcastManifest
     readonly __onPresenceChange: (callback: (members: readonly BroadcastJsonObject[]) => void) => () => void;
 };
 declare function createPresenceSubscription<TManifest extends GeneratedBroadcastManifest, TChannel extends string>(name: TChannel, connector: FluxConnector, registry: SubscriptionRegistry): FluxPresenceSubscription<TManifest, TChannel>;
-declare function createFluxClient<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(options?: FluxClientOptions<TManifest>): FluxClient<TManifest> & ConnectorDebugCarrier;
+declare function createFluxClient<const TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(options?: FluxClientOptions<TManifest>): FluxClient<TManifest> & ConnectorDebugCarrier;
 declare function configureFluxClient(options: FluxClientOptions | FluxClient): FluxClient;
 declare function getFluxClient(): FluxClient;
 declare function resetFluxClient(): void;
@@ -106,4 +113,4 @@ declare const fluxInternals: {
     createSubscription: typeof createSubscription;
 };
 
-export { type FluxChannelKind, type FluxClient, type FluxClientOptions, type FluxConnectionControls, type FluxConnectionStatus, type FluxConnector, type FluxConnectorChannel, type FluxListenerControls, type FluxPresenceState, type FluxPresenceSubscription, type FluxSubscription, configureFluxClient, createFluxClient, flux as default, flux, fluxInternals, getFluxClient, resetFluxClient };
+export { type FluxChannelKind, type FluxClient, type FluxClientOptions, type FluxConnectionControls, type FluxConnectionStatus, type FluxConnector, type FluxConnectorChannel, type FluxListenerControls, type FluxPresenceListenerControls, type FluxPresenceState, type FluxPresenceSubscription, type FluxSubscription, configureFluxClient, createFluxClient, flux as default, flux, fluxInternals, getFluxClient, resetFluxClient };

package/dist/index.mjs

@@ -9,6 +9,40 @@ function normalizeRequiredString(value, label) {
 function toReadonlyArray(value) {
   return Array.isArray(value) ? [...value] : [value];
 }
+function presenceMemberKey(member) {
+  return JSON.stringify(member) ?? String(member);
+}
+function presenceMemberDiff(previousMembers, nextMembers) {
+  const previousCounts = /* @__PURE__ */ new Map();
+  const nextCounts = /* @__PURE__ */ new Map();
+  for (const member of previousMembers) {
+    const key = presenceMemberKey(member);
+    previousCounts.set(key, (previousCounts.get(key) ?? 0) + 1);
+  }
+  for (const member of nextMembers) {
+    const key = presenceMemberKey(member);
+    nextCounts.set(key, (nextCounts.get(key) ?? 0) + 1);
+  }
+  const joining = nextMembers.filter((member) => {
+    const key = presenceMemberKey(member);
+    const previousCount = previousCounts.get(key) ?? 0;
+    if (previousCount > 0) {
+      previousCounts.set(key, previousCount - 1);
+      return false;
+    }
+    return true;
+  });
+  const leaving = previousMembers.filter((member) => {
+    const key = presenceMemberKey(member);
+    const nextCount = nextCounts.get(key) ?? 0;
+    if (nextCount > 0) {
+      nextCounts.set(key, nextCount - 1);
+      return false;
+    }
+    return true;
+  });
+  return { joining, leaving };
+}
 function addCallback(map, event, callback) {
   const listeners = map.get(event) ?? /* @__PURE__ */ new Set();
   listeners.add(callback);
@@ -256,8 +290,8 @@ function createSubscription(channelName, kind, connector, registry) {
     registeredSubscriptions.delete(leaveChannel);
     if (registeredSubscriptions.size === 0) {
       registry.delete(registryKey);
+      connectorChannel.leave();
     }
-    connectorChannel.leave();
   };
   const leaveRelated = () => {
     for (const leave of [...registry.get(registryKey) ?? []]) {
@@ -296,19 +330,92 @@ function createSubscription(channelName, kind, connector, registry) {
       return connectorChannel.members;
     },
     __onPresenceChange(callback) {
-      return connectorChannel.onMembersChange(callback);
+      const stop = connectorChannel.onMembersChange(callback);
+      detachCallbacks.add(stop);
+      return () => {
+        detachCallbacks.delete(stop);
+        stop();
+      };
     }
   };
   return Object.freeze(subscription);
 }
 function createPresenceSubscription(name, connector, registry) {
   const base = createSubscription(name, "presence", connector, registry);
-  return Object.freeze({
-    ...base,
+  const joiningCallbacks = /* @__PURE__ */ new Set();
+  const leavingCallbacks = /* @__PURE__ */ new Set();
+  let active = true;
+  let previousMembers = base.__presenceMembers();
+  const stopPresenceChanges = base.__onPresenceChange((nextMembers) => {
+    if (!active) {
+      previousMembers = nextMembers;
+      return;
+    }
+    const diff = presenceMemberDiff(previousMembers, nextMembers);
+    previousMembers = nextMembers;
+    for (const member of diff.joining) {
+      for (const callback of joiningCallbacks) {
+        callback(member);
+      }
+    }
+    for (const member of diff.leaving) {
+      for (const callback of leavingCallbacks) {
+        callback(member);
+      }
+    }
+  });
+  const stopPresenceSubscription = () => {
+    active = false;
+    joiningCallbacks.clear();
+    leavingCallbacks.clear();
+    stopPresenceChanges();
+  };
+  const subscription = Object.freeze({
+    name: base.name,
+    type: base.type,
     get members() {
       return base.__presenceMembers();
+    },
+    here(callback) {
+      callback(subscription.members);
+      return subscription;
+    },
+    joining(callback) {
+      joiningCallbacks.add(callback);
+      return subscription;
+    },
+    leaving(callback) {
+      leavingCallbacks.add(callback);
+      return subscription;
+    },
+    leaveChannel() {
+      stopPresenceSubscription();
+      base.leaveChannel();
+    },
+    leave() {
+      stopPresenceSubscription();
+      base.leave();
+    },
+    stopListening() {
+      active = false;
+      base.stopListening();
+    },
+    listen(event, callback) {
+      active = true;
+      base.listen(event, callback);
+      return subscription;
+    },
+    notification(callback) {
+      return base.notification(callback);
+    },
+    listenForWhisper(name2, callback) {
+      return base.listenForWhisper(name2, callback);
+    },
+    async whisper(name2, payload) {
+      await base.whisper(name2, payload);
     }
   });
+  return subscription;
 }
 function createFluxClient(options = {}) {
   const connector = options.connector ?? options.connectorFactory?.(options) ?? createUnavailableConnector();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/flux",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Holo-JS Framework - framework-agnostic realtime client skeleton for broadcast and presence",
   "type": "module",
   "license": "MIT",
@@ -19,16 +19,16 @@
   "scripts": {
     "build": "tsup",
     "stub": "tsup",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.type-tests.json --noEmit",
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/broadcast": "^0.1.4"
+    "@holo-js/broadcast": "^0.1.6"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }