@praxisjs/core 0.1.0

package/dist/signal/index.js

@@ -0,0 +1,7 @@
+export { batch } from "./batch";
+export { peek } from "./peek";
+export { signal } from "./signal";
+export { computed } from "./computed";
+export { persistedSignal } from "./persisted";
+export { effect } from "./effect";
+//# sourceMappingURL=index.js.map

package/dist/signal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/signal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAA+B,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/dist/signal/peek.d.ts

@@ -0,0 +1,3 @@
+import type { Computed, Signal } from "@praxisjs/shared";
+export declare function peek<T>(source: Signal<T> | Computed<T> | (() => T)): T;
+//# sourceMappingURL=peek.d.ts.map

package/dist/signal/peek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peek.d.ts","sourceRoot":"","sources":["../../src/signal/peek.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAIzD,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAQtE"}

package/dist/signal/peek.js

@@ -0,0 +1,12 @@
+import { activeEffect, runEffect } from "./effect";
+export function peek(source) {
+    const prev = activeEffect;
+    runEffect(null);
+    try {
+        return source();
+    }
+    finally {
+        runEffect(prev);
+    }
+}
+//# sourceMappingURL=peek.js.map

package/dist/signal/peek.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peek.js","sourceRoot":"","sources":["../../src/signal/peek.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEnD,MAAM,UAAU,IAAI,CAAI,MAA2C;IACjE,MAAM,IAAI,GAAG,YAAY,CAAC;IAC1B,SAAS,CAAC,IAAI,CAAC,CAAC;IAChB,IAAI,CAAC;QACH,OAAO,MAAM,EAAE,CAAC;IAClB,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC;AACH,CAAC"}

package/dist/signal/persisted.d.ts

@@ -0,0 +1,8 @@
+import type { Signal } from "@praxisjs/shared";
+export interface PersistedSignalOptions<T> {
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+    syncTabs?: boolean;
+}
+export declare function persistedSignal<T>(key: string, initialValue: T, options?: PersistedSignalOptions<T>): Signal<T>;
+//# sourceMappingURL=persisted.d.ts.map

package/dist/signal/persisted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted.d.ts","sourceRoot":"","sources":["../../src/signal/persisted.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI/C,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,EACf,OAAO,GAAE,sBAAsB,CAAC,CAAC,CAAM,aAyExC"}

package/dist/signal/persisted.js

@@ -0,0 +1,64 @@
+import { signal } from "./signal";
+export function persistedSignal(key, initialValue, options = {}) {
+    const { serialize = JSON.stringify, deserialize = JSON.parse, syncTabs = true, } = options;
+    function getStoredValue() {
+        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) {
+        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(getStoredValue());
+    function read() {
+        return inner();
+    }
+    function set(value) {
+        setStoredValue(value);
+        inner.set(value);
+    }
+    function update(fh) {
+        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;
+    source.set = set;
+    source.update = update;
+    source.subscribe = inner.subscribe.bind(inner);
+    return source;
+}
+//# sourceMappingURL=persisted.js.map

package/dist/signal/persisted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted.js","sourceRoot":"","sources":["../../src/signal/persisted.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAQlC,MAAM,UAAU,eAAe,CAC7B,GAAW,EACX,YAAe,EACf,UAAqC,EAAE;IAEvC,MAAM,EACJ,SAAS,GAAG,IAAI,CAAC,SAAS,EAC1B,WAAW,GAAG,IAAI,CAAC,KAA6B,EAChD,QAAQ,GAAG,IAAI,GAChB,GAAG,OAAO,CAAC;IAEZ,SAAS,cAAc;QACrB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACzC,OAAO,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;QACrD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,wCAAwC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;YACjE,OAAO,YAAY,CAAC;QACtB,CAAC;IACH,CAAC;IAED,SAAS,cAAc,CAAC,KAAQ;QAC9B,IAAI,CAAC;YACH,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBAC1C,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC/B,CAAC;iBAAM,CAAC;gBACN,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,sCAAsC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAI,cAAc,EAAE,CAAC,CAAC;IAE1C,SAAS,IAAI;QACX,OAAO,KAAK,EAAE,CAAC;IACjB,CAAC;IAED,SAAS,GAAG,CAAC,KAAQ;QACnB,cAAc,CAAC,KAAK,CAAC,CAAC;QACtB,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAED,SAAS,MAAM,CAAC,EAAkB;QAChC,MAAM,QAAQ,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC;QAC7B,cAAc,CAAC,QAAQ,CAAC,CAAC;QACzB,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtB,CAAC;IAED,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE;YAC3C,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,KAAK,CAAC,WAAW,KAAK,YAAY;gBAAE,OAAO;YACpE,CAAC;gBACC,IAAI,CAAC;oBACH,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ;wBAC7B,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC;wBAC7B,CAAC,CAAC,YAAY,CAAC;oBACjB,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACtB,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,OAAO,CAAC,IAAI,CACV,wCAAwC,GAAG,uBAAuB,EAClE,CAAC,CACF,CAAC;oBACF,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;gBAC1B,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,MAAM,GAAG,IAAiB,CAAC;IACjC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAE/C,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/signal/signal.d.ts

@@ -0,0 +1,3 @@
+import type { Signal } from "@praxisjs/shared";
+export declare function signal<T>(initialValue: T): Signal<T>;
+//# sourceMappingURL=signal.d.ts.map

package/dist/signal/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/signal/signal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI/C,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAuCpD"}

package/dist/signal/signal.js

@@ -0,0 +1,36 @@
+import { activeEffect } from "./effect";
+export function signal(initialValue) {
+    let value = initialValue;
+    const subscribers = new Set();
+    function read() {
+        if (activeEffect) {
+            subscribers.add(activeEffect);
+        }
+        return value;
+    }
+    function set(newValue) {
+        if (Object.is(value, newValue))
+            return;
+        value = newValue;
+        [...subscribers].forEach((sub) => {
+            sub();
+        });
+    }
+    function update(fn) {
+        set(fn(value));
+    }
+    function subscribe(fn) {
+        const wrapped = () => {
+            fn(value);
+        };
+        subscribers.add(wrapped);
+        wrapped();
+        return () => subscribers.delete(wrapped);
+    }
+    const signal = read;
+    signal.set = set;
+    signal.update = update;
+    signal.subscribe = subscribe;
+    return signal;
+}
+//# sourceMappingURL=signal.js.map

package/dist/signal/signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.js","sourceRoot":"","sources":["../../src/signal/signal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAe,MAAM,UAAU,CAAC;AAErD,MAAM,UAAU,MAAM,CAAI,YAAe;IACvC,IAAI,KAAK,GAAG,YAAY,CAAC;IACzB,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IAEtC,SAAS,IAAI;QACX,IAAI,YAAY,EAAE,CAAC;YACjB,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,GAAG,CAAC,QAAW;QACtB,IAAI,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC;YAAE,OAAO;QAEvC,KAAK,GAAG,QAAQ,CAAC;QACjB,CAAC,GAAG,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAC/B,GAAG,EAAE,CAAC;QACR,CAAC,CAAC,CAAC;IACL,CAAC;IAED,SAAS,MAAM,CAAC,EAAkB;QAChC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACjB,CAAC;IAED,SAAS,SAAS,CAAC,EAAsB;QACvC,MAAM,OAAO,GAAG,GAAG,EAAE;YACnB,EAAE,CAAC,KAAK,CAAC,CAAC;QACZ,CAAC,CAAC;QACF,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACzB,OAAO,EAAE,CAAC;QACV,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,MAAM,GAAG,IAAiB,CAAC;IACjC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,SAAS,GAAG,SAAS,CAAC;IAE7B,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@praxisjs/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@praxisjs/jsx": "0.1.0",
+    "@praxisjs/shared": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/src/async/resource.ts

@@ -0,0 +1,98 @@
+import type { Computed, Signal } from "@praxisjs/shared";
+
+import { computed, signal } from "../signal";
+import { effect } from "../signal/effect";
+
+export type ResourceStatus = "idle" | "pending" | "success" | "error";
+
+export interface Resource<T> {
+  readonly data: Computed<T | null>;
+  readonly pending: Computed<boolean>;
+  readonly error: Computed<unknown>;
+  readonly status: Computed<ResourceStatus>;
+  refetch(): void;
+  cancel(): void;
+  mutate(data: T): void;
+}
+
+export interface ResourceOptions<T> {
+  initialData?: T;
+  immediate?: boolean;
+  keepPreviousData?: boolean;
+}
+
+export function resource<T>(
+  fetcher: () => Promise<T>,
+  options: ResourceOptions<T> = {},
+): Resource<T> {
+  const {
+    initialData = null,
+    immediate = true,
+    keepPreviousData = false,
+  } = options;
+
+  const _data = signal<T | null>(initialData);
+  const _error = signal<Error | null>(null);
+  const _status = signal<ResourceStatus>("idle");
+
+  let _runId = 0;
+
+  function _execute(fn: Promise<T>) {
+    const currentRunId = ++_runId;
+
+    if (!keepPreviousData) {
+      _data.set(null);
+    }
+    _error.set(null);
+    _status.set("pending");
+
+    fn.then((result) => {
+      if (currentRunId !== _runId) return;
+      _data.set(result);
+      _error.set(null);
+      _status.set("success");
+    }).catch((err: unknown) => {
+      if (currentRunId !== _runId) return;
+      _error.set(err instanceof Error ? err : new Error(String(err)));
+      _status.set("error");
+    });
+  }
+
+  function execute() {
+    _execute(fetcher());
+  }
+
+  if (immediate) {
+    effect(() => {
+      _execute(fetcher());
+    });
+  }
+
+  return {
+    data: computed(() => _data()),
+    pending: computed(() => _status() === "pending"),
+    error: computed(() => _error()),
+    status: computed(() => _status()),
+    refetch() {
+      execute();
+    },
+    cancel() {
+      _runId++;
+      _status.set("idle");
+    },
+    mutate(data: T) {
+      _runId++;
+      _data.set(data);
+      _error.set(null);
+      _status.set("success");
+    },
+  };
+}
+
+export function createResource<P, T>(
+  param: Signal<P> | Computed<P>,
+  fetcher: (param: P) => Promise<T>,
+  options: ResourceOptions<T> = {},
+): Resource<T> {
+  return resource(() => fetcher(param()), options);
+}

package/src/component/base.ts

@@ -0,0 +1,52 @@
+import type { VNode } from "@praxisjs/shared";
+
+export abstract class BaseComponent {
+  /** Props passed by the parent — filled by the renderer when instantiating/updating. */
+  readonly _rawProps: Record<string, unknown> = {};
+
+  /** Default values declared in the class. */
+  readonly _defaults: Record<string, unknown> = {};
+
+  /** @internal — holds the previous props snapshot so `onAfterUpdate` can compare against them after the renderer commits to the DOM */
+  _pendingPreviusProps: Record<string, unknown> | null = null;
+
+  /** @internal — becomes `true` after `onMount` fires; the renderer uses this flag to skip the initial effect run */
+  _mounted = false;
+
+  /** @internal — set to true by @State on any write; cleared by renderer after each re-render */
+  _stateDirty = false;
+
+  constructor(props: Record<string, unknown> = {}) {
+    Object.assign(this._rawProps, props);
+  }
+
+  _setProps(props: Record<string, unknown>) {
+    const previous = { ...this._rawProps };
+    this.onBeforeUpdate?.(previous);
+    Object.keys(this._rawProps).forEach((k) => { Reflect.deleteProperty(this._rawProps, k); });
+    Object.assign(this._rawProps, props);
+    this._pendingPreviusProps = previous;
+    this.onUpdate?.(previous);
+
+    queueMicrotask(() => {
+      this.onAfterUpdate?.(previous);
+      this._pendingPreviusProps = null;
+    });
+  }
+
+  get props(): Record<string, unknown> {
+    return this._rawProps;
+  }
+
+  abstract render(): VNode | null;
+
+  onBeforeMount?(): void;
+  onMount?(): void;
+  onUnmount?(): void;
+
+  onBeforeUpdate?(prevProps: Record<string, unknown>): void;
+  onUpdate?(prevProps: Record<string, unknown>): void;
+  onAfterUpdate?(prevProps: Record<string, unknown>): void;
+
+  onError?(error: Error): void;
+}

package/src/component/index.ts

@@ -0,0 +1,12 @@
+export { BaseComponent } from "./base";
+export {
+  VALID_LIFECYCLE_HOOK_SIGNATURES,
+  createFunctionalContext,
+  setFunctionalContext,
+  onBeforeMount,
+  onError,
+  onMount,
+  onUnmount,
+  type FunctionalContext,
+  type LifeCycleHook,
+} from "./lifecycle";

package/src/component/lifecycle.ts

@@ -0,0 +1,82 @@
+export type LifeCycleHook =
+  | "onBeforeMount"
+  | "onMount"
+  | "onBeforeUpdate"
+  | "onUpdate"
+  | "onAfterUpdate"
+  | "onUnmount"
+  | "onError";
+
+export const VALID_LIFECYCLE_HOOK_SIGNATURES: Record<LifeCycleHook, string> = {
+  onBeforeMount: "(): void",
+  onMount: "(): void",
+  onUnmount: "(): void",
+
+  onBeforeUpdate: "(prevProps: Record<string, unknown>): void",
+  onUpdate: "(prevProps: Record<string, unknown>): void",
+  onAfterUpdate: "(prevProps: Record<string, unknown>): void",
+
+  onError: "(error: Error): void",
+};
+
+export interface FunctionalContext {
+  onBeforeMount: Array<() => void>;
+  onMount: Array<() => void>;
+  onUnmount: Array<() => void>;
+  onError: Array<(error: Error) => void>;
+}
+
+let _functionalContext: FunctionalContext | null = null;
+
+export function setFunctionalContext(ctx: FunctionalContext | null): void {
+  _functionalContext = ctx;
+}
+
+export function createFunctionalContext(): FunctionalContext {
+  return {
+    onBeforeMount: [],
+    onMount: [],
+    onUnmount: [],
+    onError: [],
+  };
+}
+
+export function onBeforeMount(fn: () => void): void {
+  if (_functionalContext) {
+    _functionalContext.onBeforeMount.push(fn);
+    return;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.warn("[onBeforeMount] Called outside of a functional component context.");
+  }
+}
+
+export function onMount(fn: () => void): void {
+  if (_functionalContext) {
+    _functionalContext.onMount.push(fn);
+    return;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.warn("[onMount] Called outside of a functional component context.");
+  }
+}
+
+export function onUnmount(fn: () => void): void {
+  if (_functionalContext) {
+    _functionalContext.onUnmount.push(fn);
+    return;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.warn("[onUnmount] Called outside of a functional component context.");
+  }
+}
+
+export function onError(fn: (error: Error) => void): void {
+  if (_functionalContext) {
+    _functionalContext.onError.push(fn);
+    return;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.warn("[onError] Called outside of a functional component context.");
+  }
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+export {
+  resource,
+  createResource,
+  type ResourceStatus,
+  type Resource,
+  type ResourceOptions,
+} from "./async/resource";
+export {
+  debounced,
+  until,
+  when,
+  history,
+  type HistoryElement,
+} from "./reactive";
+export {
+  signal,
+  persistedSignal,
+  peek,
+  computed,
+  batch,
+  effect,
+  type PersistedSignalOptions,
+} from "./signal";
+export {
+  BaseComponent,
+  VALID_LIFECYCLE_HOOK_SIGNATURES,
+  onBeforeMount,
+  onError,
+  onMount,
+  onUnmount,
+  createFunctionalContext,
+  setFunctionalContext,
+  type FunctionalContext,
+  type LifeCycleHook,
+} from "./component";

package/src/reactive/history.ts

@@ -0,0 +1,81 @@
+import { type Computed, isSignal, type Signal } from "@praxisjs/shared";
+
+import { computed, signal } from "../signal";
+import { effect } from "../signal/effect";
+
+export interface HistoryElement<T> {
+  readonly values: Computed<T[]>;
+  readonly current: Computed<T>;
+  readonly canUndo: Computed<boolean>;
+  readonly canRedo: Computed<boolean>;
+  undo(): void;
+  redo(): void;
+  clear(): void;
+}
+
+export function history<T>(
+  source: Signal<T> | Computed<T> | (() => T),
+  limit = 50,
+): HistoryElement<T> {
+  const read = typeof source === "function" ? source : (source as () => T);
+
+  const _past = signal<T[]>([]);
+  const _future = signal<T[]>([]);
+  const _current = signal<T>(read());
+
+  let _ignoreNext = false;
+
+  effect(() => {
+    const value = read();
+
+    if (_ignoreNext) {
+      _ignoreNext = false;
+      return;
+    }
+
+    const past = _past();
+    const next = [...past, _current()];
+    _past.set(next.length > limit ? next.slice(next.length - limit) : next);
+    _future.set([]);
+    _current.set(value);
+  });
+
+  return {
+    values: computed(() => [..._past(), _current()]),
+    current: computed(() => _current()),
+    canUndo: computed(() => _past().length > 0),
+    canRedo: computed(() => _future().length > 0),
+    undo(): void {
+      const past = _past();
+      if (past.length === 0) return;
+
+      const previous = past[past.length - 1];
+      _past.set(past.slice(0, past.length - 1));
+      _future.set([_current(), ..._future()]);
+      _ignoreNext = true;
+      _current.set(previous);
+
+      if (isSignal(source)) {
+        (source as Signal<T>).set(previous);
+      }
+    },
+    redo(): void {
+      const future = _future();
+      if (future.length === 0) return;
+
+      const next = future[0];
+      _future.set(future.slice(1));
+      _past.set([..._past(), _current()]);
+      _ignoreNext = true;
+      _current.set(next);
+
+      if (isSignal(source)) {
+        (source as Signal<T>).set(next);
+      }
+    },
+    clear(): void {
+      _past.set([]);
+      _future.set([]);
+    },
+  };
+}

package/src/reactive/index.ts

@@ -0,0 +1,2 @@
+export { history, type HistoryElement } from "./history";
+export { debounced, until, when } from "./reactive";

package/src/reactive/reactive.ts

@@ -0,0 +1,53 @@
+import type { Computed, Signal } from "@praxisjs/shared";
+
+import { signal } from "../signal";
+import { effect } from "../signal/effect";
+
+export function when<T>(
+  source: Signal<T> | Computed<T> | (() => T),
+  fn: (value: NonNullable<T>) => void,
+) {
+  const read = typeof source === "function" ? source : (source as () => T);
+  let disposed = false;
+
+  const stop = effect(() => {
+    const value = read();
+    if (!value || disposed) return;
+
+    disposed = true;
+    stop();
+    fn(value);
+  });
+
+  return stop;
+}
+
+export function until<T>(source: Signal<T> | Computed<T> | (() => T)) {
+  return new Promise<NonNullable<T>>((resolve) => {
+    const stop = when(source, (value) => {
+      resolve(value);
+    });
+
+    void stop;
+  });
+}
+
+export function debounced<T>(
+  source: Signal<T> | Computed<T> | (() => T),
+  ms: number,
+) {
+  const read = typeof source === "function" ? source : (source as () => T);
+  const current = signal<T>(read());
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+
+  effect(() => {
+    const value = read();
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      current.set(value);
+      timeout = undefined;
+    }, ms);
+  });
+
+  return current;
+}

package/src/signal/batch.ts

@@ -0,0 +1,14 @@
+import type { Effect } from "./effect";
+
+let batchQueue: Set<Effect> | null = null;
+
+export function batch(fn: () => void) {
+  batchQueue = new Set();
+  try {
+    fn();
+  } finally {
+    const effectsToRun = batchQueue;
+    batchQueue = null;
+    effectsToRun.forEach((eff) => { eff(); });
+  }
+}

package/src/signal/computed.ts

@@ -0,0 +1,48 @@
+import type { Computed } from "@praxisjs/shared";
+
+import { track, activeEffect, runEffect, type Effect } from "./effect";
+
+export function computed<T>(computeFn: () => T): Computed<T> {
+  let cachedValue: T;
+  let dirty = true;
+  const subscribers = new Set<Effect>();
+
+  const recompute = () => {
+    dirty = true;
+    [...subscribers].forEach((sub) => {
+      sub();
+    });
+  };
+
+  function read() {
+    if (activeEffect) {
+      subscribers.add(activeEffect);
+    }
+
+    if (dirty) {
+      const prevEffect = activeEffect;
+      runEffect(recompute);
+      cachedValue = computeFn();
+      dirty = false;
+      runEffect(prevEffect);
+    }
+
+    return cachedValue;
+  }
+
+  function subscribe(fn: (value: T) => void) {
+    const wrappedEffect = () => {
+      fn(read());
+    };
+    subscribers.add(wrappedEffect);
+    wrappedEffect();
+    return () => subscribers.delete(wrappedEffect);
+  }
+
+  track(recompute);
+
+  const computedSignal = read as Computed<T>;
+  computedSignal.subscribe = subscribe;
+
+  return computedSignal;
+}