@praxisjs/core 1.4.1 → 1.6.0

package/src/signal/effect.ts

@@ -4,14 +4,13 @@ export let activeEffect: Effect | null = null;
 const effectStack: Effect[] = [];
 
 export function track(effect: Effect) {
-  const subscriber = effect;
-  effectStack.push(subscriber);
-  activeEffect = subscriber;
+  effectStack.push(effect);
+  activeEffect = effect;
   try {
-    subscriber();
+    effect();
   } finally {
     effectStack.pop();
-    activeEffect = effectStack[effectStack.length - 1] || null;
+    activeEffect = effectStack[effectStack.length - 1] ?? null;
   }
 }
 
@@ -36,21 +35,21 @@ export function effect(fn: () => Cleanup) {
   let cleanup: Cleanup;
   let stopped = false;
 
-  const wrappedEffect = () => {
+  function run(): void {
     if (stopped) return;
     cleanup?.();
-    const prevEffect = activeEffect;
-    activeEffect = wrappedEffect;
+    const prev = activeEffect;
+    activeEffect = run;
     try {
       cleanup = fn();
     } finally {
-      activeEffect = prevEffect;
+      activeEffect = prev;
     }
-  };
+  }
 
-  wrappedEffect();
+  run();
 
-  return () => {
+  return function stop(): void {
     stopped = true;
     cleanup?.();
     cleanup = undefined;

package/src/signal/index.ts

@@ -3,4 +3,5 @@ export { peek } from "./peek";
 export { signal } from "./signal";
 export { computed } from "./computed";
 export { type PersistedSignalOptions, persistedSignal } from "./persisted";
+export { type SyncedSignal, syncedSignal } from "./synced";
 export { effect, untrack } from "./effect";

package/src/signal/signal.ts

@@ -3,53 +3,78 @@ import type { Signal } from "@praxisjs/shared";
 import { isBatching, enqueueEffect } from "./batch";
 import { activeEffect, type Effect } from "./effect";
 
+export type SubList = Effect | Effect[] | null;
+
+export function addSub(holder: { subs: SubList }, eff: Effect): void {
+  const subs = holder.subs;
+  if (subs === null) {
+    holder.subs = eff;
+  } else if (typeof subs === "function") {
+    if (subs !== eff) holder.subs = [subs, eff];
+  } else {
+    if (!subs.includes(eff)) subs.push(eff);
+  }
+}
+
+export function removeSub(holder: { subs: SubList }, eff: Effect): void {
+  const subs = holder.subs;
+  if (subs === null) return;
+  if (typeof subs === "function") {
+    if (subs === eff) holder.subs = null;
+  } else {
+    const idx = subs.indexOf(eff);
+    if (idx >= 0) subs.splice(idx, 1);
+  }
+}
+
+export function notifySubs(subs: Exclude<SubList, null>, batching: boolean): void {
+  if (typeof subs === "function") {
+    if (batching) enqueueEffect(subs); else subs();
+    return;
+  }
+  if (batching) {
+    for (const sub of subs) enqueueEffect(sub);
+    return;
+  }
+  let lastError: unknown;
+  let hasError = false;
+  for (const sub of subs) {
+    try {
+      sub();
+    } catch (e) {
+      lastError = e;
+      hasError = true;
+    }
+  }
+  if (hasError) throw lastError;
+}
+
 export function signal<T>(initialValue: T): Signal<T> {
   let value = initialValue;
-  const subscribers = new Set<Effect>();
+  const holder = { subs: null as SubList };
 
-  function read() {
-    if (activeEffect) {
-      subscribers.add(activeEffect);
-    }
+  function read(): T {
+    if (activeEffect !== null) addSub(holder, activeEffect);
     return value;
   }
 
-  function set(newValue: T) {
+  const s = read as Signal<T>;
+
+  s.set = (newValue: T) => {
     if (Object.is(value, newValue)) return;
     value = newValue;
-    if (isBatching()) {
-      [...subscribers].forEach((sub) => { enqueueEffect(sub); });
-      return;
-    }
-    const errors: unknown[] = [];
-    [...subscribers].forEach((sub) => {
-      try {
-        sub();
-      } catch (e) {
-        errors.push(e);
-      }
-    });
-    if (errors.length > 0) throw errors[errors.length - 1];
-  }
+    if (holder.subs !== null) notifySubs(holder.subs, isBatching());
+  };
 
-  function update(fn: (prev: T) => T) {
-    set(fn(value));
-  }
+  s.update = (fn: (prev: T) => T) => { s.set(fn(value)); };
 
-  function subscribe(fn: (value: T) => void) {
-    const wrapped = () => {
-      fn(value);
-    };
-    subscribers.add(wrapped);
+  s.subscribe = (fn: (value: T) => void) => {
+    const wrapped: Effect = () => { fn(value); };
+    addSub(holder, wrapped);
     wrapped();
-    return () => subscribers.delete(wrapped);
-  }
-
-  const signal = read as Signal<T>;
-  signal.set = set;
-  signal.update = update;
-  signal.subscribe = subscribe;
-  signal.__isSignal = true;
+    return () => { removeSub(holder, wrapped); };
+  };
 
-  return signal;
+  s.__isSignal = true;
+  return s;
 }

package/src/signal/synced.ts

@@ -0,0 +1,56 @@
+import type { Signal } from "@praxisjs/shared";
+
+import { signal } from "./signal";
+
+export interface SyncedSignal<T> extends Signal<T> {
+  close(): void;
+}
+
+export function syncedSignal<T>(
+  channelName: string,
+  initialValue: T,
+): SyncedSignal<T> {
+  const inner = signal(initialValue);
+  const channel = new BroadcastChannel(channelName);
+  let posting = false;
+
+  channel.onmessage = (event: MessageEvent) => {
+    if (posting) return;
+    try {
+      inner.set(JSON.parse(String(event.data)) as T);
+    } catch {
+      // ignore malformed messages
+    }
+  };
+
+  function read() {
+    return inner();
+  }
+
+  function set(value: T) {
+    posting = true;
+    try {
+      inner.set(value);
+      channel.postMessage(JSON.stringify(value));
+    } finally {
+      posting = false;
+    }
+  }
+
+  function update(fn: (prev: T) => T) {
+    set(fn(inner()));
+  }
+
+  function close() {
+    channel.close();
+  }
+
+  const source = read as SyncedSignal<T>;
+  source.set = set;
+  source.update = update;
+  source.subscribe = inner.subscribe.bind(inner);
+  source.__isSignal = true;
+  source.close = close;
+
+  return source;
+}