@holo-js/flux-svelte 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { Readable } from 'svelte/store';
+import { FluxClient, FluxConnectionStatus, FluxListenerControls } from '@holo-js/flux';
+import { GeneratedBroadcastManifest, BroadcastPayloadFor } from '@holo-js/broadcast';
+
+interface FluxHelperOptions<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest> {
+    readonly client?: FluxClient<TManifest>;
+    readonly onUnmount?: (cleanup: () => void) => void;
+}
+interface FluxConnectionStatusHelperOptions<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest> extends FluxHelperOptions<TManifest> {
+    readonly onChange?: (status: FluxConnectionStatus) => void;
+}
+interface FluxPresenceHelperCallbacks<TMember = unknown> {
+    readonly onHere?: (members: readonly TMember[]) => void;
+}
+type FluxPresenceHelperState<TMember = unknown> = FluxListenerControls & {
+    readonly members: Readable<readonly TMember[]>;
+};
+declare function useFlux<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHelperOptions<TManifest>): FluxListenerControls;
+declare function useFluxPublic<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHelperOptions<TManifest>): FluxListenerControls;
+declare function useFluxPrivate<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHelperOptions<TManifest>): FluxListenerControls;
+declare function useFluxPresence<TMember = unknown, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, callbacks?: FluxPresenceHelperCallbacks<TMember>, options?: FluxHelperOptions<TManifest>): FluxPresenceHelperState<TMember>;
+declare function useFluxNotification<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, callback: (payload: unknown) => void, options?: FluxHelperOptions<TManifest>): FluxListenerControls;
+declare function useFluxModel<TEvent extends string, TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(channel: string, events: TEvent | readonly TEvent[], callback: (payload: BroadcastPayloadFor<TEvent>) => void, options?: FluxHelperOptions<TManifest>): FluxListenerControls;
+declare function useFluxConnectionStatus<TManifest extends GeneratedBroadcastManifest = GeneratedBroadcastManifest>(options?: FluxConnectionStatusHelperOptions<TManifest>): Readable<FluxConnectionStatus>;
+
+export { type FluxConnectionStatusHelperOptions, type FluxHelperOptions, type FluxPresenceHelperCallbacks, type FluxPresenceHelperState, useFlux, useFluxConnectionStatus, useFluxModel, useFluxNotification, useFluxPresence, useFluxPrivate, useFluxPublic };

package/dist/index.mjs

@@ -0,0 +1,123 @@
+// src/index.ts
+import { onDestroy } from "svelte";
+import { readable, writable } from "svelte/store";
+import { getFluxClient } from "@holo-js/flux";
+function resolveClient(options) {
+  return options.client ?? getFluxClient();
+}
+function registerCleanup(options, cleanup) {
+  const runCleanup = () => {
+    cleanup();
+  };
+  let registered = false;
+  try {
+    onDestroy(runCleanup);
+    registered = true;
+  } catch {
+    registered = false;
+  }
+  if (!registered) {
+    options.onUnmount?.(runCleanup);
+  }
+}
+function controlsFromSubscription(subscription) {
+  const controls = {
+    leave: () => {
+      subscription.leave();
+    },
+    leaveChannel: () => {
+      subscription.leaveChannel();
+    },
+    listen: () => {
+      subscription.listen();
+      return controls;
+    },
+    stopListening: () => {
+      subscription.stopListening();
+    }
+  };
+  return Object.freeze(controls);
+}
+function subscribeWithEvents(subscription, events, callback) {
+  return subscription.listen(
+    events,
+    callback
+  );
+}
+function useFlux(channel, events, callback, options = {}) {
+  const subscription = subscribeWithEvents(
+    resolveClient(options).private(channel),
+    events,
+    callback
+  );
+  registerCleanup(options, () => {
+    subscription.leaveChannel();
+  });
+  return controlsFromSubscription(subscription);
+}
+function useFluxPublic(channel, events, callback, options = {}) {
+  const subscription = subscribeWithEvents(
+    resolveClient(options).channel(channel),
+    events,
+    callback
+  );
+  registerCleanup(options, () => {
+    subscription.leaveChannel();
+  });
+  return controlsFromSubscription(subscription);
+}
+function useFluxPrivate(channel, events, callback, options = {}) {
+  return useFlux(channel, events, callback, options);
+}
+function useFluxPresence(channel, callbacks = {}, options = {}) {
+  const subscription = resolveClient(options).presence(channel);
+  callbacks.onHere?.(subscription.members);
+  const members = writable(subscription.members);
+  const stop = subscription.__onPresenceChange?.((nextMembers) => {
+    const typedMembers = nextMembers;
+    callbacks.onHere?.(typedMembers);
+    members.set(typedMembers);
+  });
+  registerCleanup(options, () => {
+    stop?.();
+    subscription.leaveChannel();
+  });
+  return Object.freeze({
+    ...controlsFromSubscription(subscription),
+    members
+  });
+}
+function useFluxNotification(channel, callback, options = {}) {
+  const subscription = resolveClient(options).private(channel).notification(callback);
+  registerCleanup(options, () => {
+    subscription.leaveChannel();
+  });
+  return controlsFromSubscription(subscription);
+}
+function useFluxModel(channel, events, callback, options = {}) {
+  return useFluxPrivate(channel, events, callback, options);
+}
+function useFluxConnectionStatus(options = {}) {
+  const client = resolveClient(options);
+  const status = writable(client.getStatus());
+  const unsubscribe = client.onStatusChange((nextStatus) => {
+    options.onChange?.(nextStatus);
+    status.set(nextStatus);
+  });
+  registerCleanup(options, unsubscribe);
+  return readable(client.getStatus(), (set) => {
+    const stop = status.subscribe(set);
+    return () => {
+      stop();
+    };
+  });
+}
+export {
+  useFlux,
+  useFluxConnectionStatus,
+  useFluxModel,
+  useFluxNotification,
+  useFluxPresence,
+  useFluxPrivate,
+  useFluxPublic
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@holo-js/flux-svelte",
+  "version": "0.1.3",
+  "description": "Holo-JS Framework - Svelte and SvelteKit Flux helper skeletons",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "stub": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@holo-js/broadcast": "^0.1.3",
+    "@holo-js/flux": "^0.1.3"
+  },
+  "peerDependencies": {
+    "svelte": "^5.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "svelte": "^5.16.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}