@holo-js/flux-react 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -1,6 +1,26 @@
 import { FluxClient, FluxConnectionStatus, FluxListenerControls } from '@holo-js/flux';
-import { GeneratedBroadcastManifest, BroadcastPayloadFor } from '@holo-js/broadcast';
+import { GeneratedBroadcastManifest, BroadcastPayloadFor, BroadcastJsonObject } from '@holo-js/broadcast';
 
+type ManifestEventName<TManifest extends GeneratedBroadcastManifest> = TManifest['events'][number]['name'] & string;
+type ManifestChannelPattern<TManifest extends GeneratedBroadcastManifest> = TManifest['channels'][number]['pattern'] & string;
+type ManifestChannelEntryByPattern<TManifest extends GeneratedBroadcastManifest, TPattern extends string> = Extract<TManifest['channels'][number], {
+    pattern: TPattern;
+}>;
+type ManifestPresenceMember<TManifest extends GeneratedBroadcastManifest, TPattern extends string> = Extract<ManifestChannelEntryByPattern<TManifest, TPattern>, {
+    member: unknown;
+}> extends {
+    member: infer TMember;
+} ? TMember : BroadcastJsonObject;
+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;
+    }[];
+} ? 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> : never;
+type ManifestHookChannel<TManifest extends GeneratedBroadcastManifest> = string extends ManifestChannelPattern<TManifest> ? string : ManifestChannelPattern<TManifest>;
+type ManifestHookEvent<TManifest extends GeneratedBroadcastManifest, TChannel extends string, TEvent extends string> = TEvent & ManifestSubscriptionEventName<TManifest, TChannel>;
+type ManifestHookPresenceMember<TMember, TManifest extends GeneratedBroadcastManifest, TChannel extends string> = unknown extends TMember ? string extends ManifestChannelPattern<TManifest> ? BroadcastJsonObject : ManifestPresenceMember<TManifest, TChannel> : TMember;
 interface FluxHookOptions<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest> {
     readonly client?: FluxClient<TManifest>;
     readonly onUnmount?: (cleanup: () => void) => void;
@@ -14,12 +34,12 @@ interface FluxPresenceHookCallbacks<TMember = unknown> {
 type FluxPresenceHookState<TMember = unknown> = FluxListenerControls & {
     readonly members: readonly TMember[];
 };
-declare function useFlux<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
-declare function useFluxPublic<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
-declare function useFluxPrivate<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
-declare function useFluxPresence<TMember = unknown, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, callbacks?: FluxPresenceHookCallbacks<TMember>, options?: FluxHookOptions<TManifest>): FluxPresenceHookState<TMember>;
-declare function useFluxNotification<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, callback: (payload: unknown) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
-declare function useFluxModel<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
+declare function useFlux<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends ManifestHookChannel<TManifest> = ManifestHookChannel<TManifest>>(channel: TChannel & ManifestHookChannel<NoInfer<TManifest>>, events: ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent> | readonly ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent>[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
+declare function useFluxPublic<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends ManifestHookChannel<TManifest> = ManifestHookChannel<TManifest>>(channel: TChannel & ManifestHookChannel<NoInfer<TManifest>>, events: ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent> | readonly ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent>[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
+declare function useFluxPrivate<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends ManifestHookChannel<TManifest> = ManifestHookChannel<TManifest>>(channel: TChannel & ManifestHookChannel<NoInfer<TManifest>>, events: ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent> | readonly ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent>[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
+declare function useFluxPresence<TMember = unknown, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends ManifestHookChannel<TManifest> = ManifestHookChannel<TManifest>>(channel: TChannel & ManifestHookChannel<NoInfer<TManifest>>, callbacks?: FluxPresenceHookCallbacks<ManifestHookPresenceMember<TMember, TManifest, TChannel>>, options?: FluxHookOptions<TManifest>): FluxPresenceHookState<ManifestHookPresenceMember<TMember, TManifest, TChannel>>;
+declare function useFluxNotification<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends ManifestHookChannel<TManifest> = ManifestHookChannel<TManifest>>(channel: TChannel & ManifestHookChannel<NoInfer<TManifest>>, callback: (payload: unknown) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
+declare function useFluxModel<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest, TChannel extends ManifestHookChannel<TManifest> = ManifestHookChannel<TManifest>>(channel: TChannel & ManifestHookChannel<NoInfer<TManifest>>, events: ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent> | readonly ManifestHookEvent<NoInfer<TManifest>, TChannel, TEvent>[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHookOptions<TManifest>): FluxListenerControls;
 declare function useFluxConnectionStatus<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(options?: FluxConnectionStatusHookOptions<TManifest>): FluxConnectionStatus;
 
 export { type FluxConnectionStatusHookOptions, type FluxHookOptions, type FluxPresenceHookCallbacks, type FluxPresenceHookState, useFlux, useFluxConnectionStatus, useFluxModel, useFluxNotification, useFluxPresence, useFluxPrivate, useFluxPublic };

package/dist/index.mjs

@@ -23,6 +23,20 @@ function useLatestRef(value) {
 function serializeEventDependency(events) {
   return Array.isArray(events) ? events.map(String).join("\0") : String(events);
 }
+function memberKey(member) {
+  return JSON.stringify(member) ?? String(member);
+}
+function appendPresenceMember(members, member) {
+  return Object.freeze([...members, member]);
+}
+function removePresenceMember(members, member) {
+  const key = memberKey(member);
+  const index = members.findIndex((candidate) => Object.is(candidate, member) || memberKey(candidate) === key);
+  if (index < 0) {
+    return members;
+  }
+  return Object.freeze(members.filter((_, candidateIndex) => candidateIndex !== index));
+}
 function useControls(createSubscription, onUnmount, dependencies = []) {
   const controlsRef = useRef(createNoopControls());
   const onUnmountRef = useLatestRef(onUnmount);
@@ -105,32 +119,49 @@ function useFluxPresence(channel, callbacks = {}, options = {}) {
   const onUnmountRef = useLatestRef(options.onUnmount);
   useEffect(() => {
     const subscription = client.presence(channel);
+    let active = true;
     const updateMembers = (members) => {
       membersRef.current = members;
       callbacksRef.current.onHere?.(membersRef.current);
       rerender();
     };
-    updateMembers(subscription.members);
-    const stop = subscription.__onPresenceChange?.(updateMembers);
     const cleanup = () => {
-      stop?.();
+      active = false;
       subscription.leaveChannel();
     };
     controlsRef.current = Object.freeze({
       leave: () => {
+        active = false;
         subscription.leave();
       },
       leaveChannel: () => {
+        active = false;
         subscription.leaveChannel();
       },
       listen: () => {
+        active = true;
         subscription.listen();
+        updateMembers(subscription.members);
         return controlsRef.current;
       },
       stopListening: () => {
+        active = false;
         subscription.stopListening();
       }
     });
+    subscription.here((members) => {
+      if (active) {
+        updateMembers(members);
+      }
+    }).joining((member) => {
+      if (active) {
+        updateMembers(appendPresenceMember(membersRef.current, member));
+      }
+    }).leaving((member) => {
+      if (active) {
+        updateMembers(removePresenceMember(membersRef.current, member));
+      }
+    }).listen();
     onUnmountRef.current?.(cleanup);
     return cleanup;
   }, [channel, client, callbacksRef, onUnmountRef]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/flux-react",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Holo-JS Framework - React and Next hook skeletons for Flux",
   "type": "module",
   "license": "MIT",
@@ -19,24 +19,26 @@
   "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/flux": "^0.1.4"
+    "@holo-js/broadcast": "^0.1.5",
+    "@holo-js/flux": "^0.1.5"
   },
   "peerDependencies": {
-    "react": "^18.3.1 || ^19.0.0"
+    "react": "^19.2.6"
   },
   "devDependencies": {
-    "@types/react": "^18.3.12",
-    "@types/react-test-renderer": "^18.3.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@types/react-test-renderer": "^19.1.0",
     "@types/node": "^22.10.2",
-    "react": "^18.3.1",
-    "react-test-renderer": "^18.3.1",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "react-test-renderer": "^19.2.6",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }