@praxisjs/core 0.1.0

package/src/signal/effect.ts

@@ -0,0 +1,44 @@
+export type Effect = () => void;
+
+export let activeEffect: Effect | null = null;
+const effectStack: Effect[] = [];
+
+export function track(effect: Effect) {
+  const subscriber = effect;
+  effectStack.push(subscriber);
+  activeEffect = subscriber;
+  try {
+    subscriber();
+  } finally {
+    effectStack.pop();
+    activeEffect = effectStack[effectStack.length - 1] || null;
+  }
+}
+
+export function runEffect(effect: Effect | null) {
+  activeEffect = effect;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+type Cleanup = (() => void) | void;
+
+export function effect(fn: () => Cleanup) {
+  let cleanup: Cleanup;
+
+  const wrappedEffect = () => {
+    cleanup?.();
+    const prevEffect = activeEffect;
+    activeEffect = wrappedEffect;
+    try {
+      cleanup = fn();
+    } finally {
+      activeEffect = prevEffect;
+    }
+  };
+
+  wrappedEffect();
+
+  return () => {
+    cleanup?.();
+  };
+}

package/src/signal/index.ts

@@ -0,0 +1,6 @@
+export { batch } from "./batch";
+export { peek } from "./peek";
+export { signal } from "./signal";
+export { computed } from "./computed";
+export { type PersistedSignalOptions, persistedSignal } from "./persisted";
+export { effect } from "./effect";

package/src/signal/peek.ts

@@ -0,0 +1,13 @@
+import type { Computed, Signal } from "@praxisjs/shared";
+
+import { activeEffect, runEffect } from "./effect";
+
+export function peek<T>(source: Signal<T> | Computed<T> | (() => T)): T {
+  const prev = activeEffect;
+  runEffect(null);
+  try {
+    return source();
+  } finally {
+    runEffect(prev);
+  }
+}

package/src/signal/persisted.ts

@@ -0,0 +1,87 @@
+import type { Signal } from "@praxisjs/shared";
+
+import { signal } from "./signal";
+
+export interface PersistedSignalOptions<T> {
+  serialize?: (value: T) => string;
+  deserialize?: (value: string) => T;
+  syncTabs?: boolean;
+}
+
+export function persistedSignal<T>(
+  key: string,
+  initialValue: T,
+  options: PersistedSignalOptions<T> = {},
+) {
+  const {
+    serialize = JSON.stringify,
+    deserialize = JSON.parse as (value: string) => T,
+    syncTabs = true,
+  } = options;
+
+  function getStoredValue(): T {
+    try {
+      const stored = localStorage.getItem(key);
+      return stored ? deserialize(stored) : initialValue;
+    } catch (e) {
+      console.warn(`Failed to deserialize value for key "${key}":`, e);
+      return initialValue;
+    }
+  }
+
+  function setStoredValue(value: T) {
+    try {
+      if (value === undefined || value === null) {
+        localStorage.removeItem(key);
+      } else {
+        localStorage.setItem(key, serialize(value));
+      }
+    } catch (e) {
+      console.warn(`Failed to serialize value for key "${key}":`, e);
+    }
+  }
+
+  const inner = signal<T>(getStoredValue());
+
+  function read() {
+    return inner();
+  }
+
+  function set(value: T) {
+    setStoredValue(value);
+    inner.set(value);
+  }
+
+  function update(fh: (prev: T) => T) {
+    const newValue = fh(inner());
+    setStoredValue(newValue);
+    inner.set(newValue);
+  }
+
+  if (syncTabs) {
+    window.addEventListener("storage", (event) => {
+      if (event.key === key || event.storageArea !== localStorage) return;
+      {
+        try {
+          const newValue = event.newValue
+            ? deserialize(event.newValue)
+            : initialValue;
+          inner.set(newValue);
+        } catch (e) {
+          console.warn(
+            `Failed to deserialize value for key "${key}" from storage event:`,
+            e,
+          );
+          inner.set(initialValue);
+        }
+      }
+    });
+  }
+
+  const source = read as Signal<T>;
+  source.set = set;
+  source.update = update;
+  source.subscribe = inner.subscribe.bind(inner);
+
+  return source;
+}

package/src/signal/signal.ts

@@ -0,0 +1,44 @@
+import type { Signal } from "@praxisjs/shared";
+
+import { activeEffect, type Effect } from "./effect";
+
+export function signal<T>(initialValue: T): Signal<T> {
+  let value = initialValue;
+  const subscribers = new Set<Effect>();
+
+  function read() {
+    if (activeEffect) {
+      subscribers.add(activeEffect);
+    }
+    return value;
+  }
+
+  function set(newValue: T) {
+    if (Object.is(value, newValue)) return;
+
+    value = newValue;
+    [...subscribers].forEach((sub) => {
+      sub();
+    });
+  }
+
+  function update(fn: (prev: T) => T) {
+    set(fn(value));
+  }
+
+  function subscribe(fn: (value: T) => void) {
+    const wrapped = () => {
+      fn(value);
+    };
+    subscribers.add(wrapped);
+    wrapped();
+    return () => subscribers.delete(wrapped);
+  }
+
+  const signal = read as Signal<T>;
+  signal.set = set;
+  signal.update = update;
+  signal.subscribe = subscribe;
+
+  return signal;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}