sibujs 1.0.0-beta.1

package/dist/src/reactivity/bindAttribute.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bind a reactive getter to an element attribute.
+ * Returns a teardown that stops all future updates.
+ */
+export declare function bindAttribute(el: HTMLElement, attr: string, getter: () => any): () => void;

package/dist/src/reactivity/bindAttribute.js

@@ -0,0 +1,31 @@
+import { track } from "./track";
+import { sanitize } from "../utils/sanitize";
+/**
+ * Bind a reactive getter to an element attribute.
+ * Returns a teardown that stops all future updates.
+ */
+export function bindAttribute(el, attr, getter) {
+    function commit() {
+        let value;
+        try {
+            value = getter();
+        }
+        catch {
+            return;
+        }
+        const str = (attr === "href" || attr === "title")
+            ? sanitize(String(value))
+            : String(value);
+        // If binding an input value or checked state, update the property
+        if ((attr === "value" || attr === "checked") && attr in el) {
+            // @ts-ignore
+            el[attr] = attr === "checked" ? Boolean(value) : str;
+        }
+        else {
+            el.setAttribute(attr, str);
+        }
+    }
+    // Initial run + reactive updates
+    const teardown = track(commit, commit);
+    return teardown;
+}

package/dist/src/reactivity/bindChildNode.d.ts

@@ -0,0 +1,10 @@
+import type { NodeChild } from "../core/types";
+/**
+ * Binds a reactive getter that returns NodeChild or NodeChild[] next to a placeholder comment.
+ * Render errors are swallowed to preserve the last successful state.
+ *
+ * @param placeholder Anchor Comment node for insertion
+ * @param getter Function returning NodeChild or NodeChild[] to render
+ * @returns Teardown function to cancel the binding
+ */
+export declare function bindChildNode(placeholder: Comment, getter: () => NodeChild | NodeChild[]): () => void;

package/dist/src/reactivity/bindChildNode.js

@@ -0,0 +1,46 @@
+import { track } from "./track";
+/**
+ * Binds a reactive getter that returns NodeChild or NodeChild[] next to a placeholder comment.
+ * Render errors are swallowed to preserve the last successful state.
+ *
+ * @param placeholder Anchor Comment node for insertion
+ * @param getter Function returning NodeChild or NodeChild[] to render
+ * @returns Teardown function to cancel the binding
+ */
+export function bindChildNode(placeholder, getter) {
+    let lastNodes = [];
+    function commit() {
+        let result;
+        try {
+            result = getter();
+        }
+        catch {
+            return;
+        }
+        // Remove previously inserted nodes
+        for (const node of lastNodes) {
+            node.parentNode?.removeChild(node);
+        }
+        lastNodes = [];
+        if (result == null)
+            return;
+        const parent = placeholder.parentNode;
+        const anchor = placeholder.nextSibling;
+        const newNodes = [];
+        const insertItem = (item) => {
+            const node = item instanceof Node ? item : document.createTextNode(String(item));
+            parent.insertBefore(node, anchor);
+            newNodes.push(node);
+        };
+        if (Array.isArray(result)) {
+            for (const item of result)
+                insertItem(item);
+        }
+        else {
+            insertItem(result);
+        }
+        lastNodes = newNodes;
+    }
+    // Initial render and reactive subscription
+    return track(commit, commit);
+}

package/dist/src/reactivity/bindTextNode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Binds a reactive getter to a Text node, updating its content reactively.
+ * Render errors are swallowed to preserve last displayed text.
+ * Sanitizes text to prevent HTML injection.
+ *
+ * @param textNode Target Text node whose content will be updated
+ * @param getter Function returning string or number to display
+ * @returns Teardown function to cancel the binding
+ */
+export declare function bindTextNode(textNode: Text, getter: () => string | number): () => void;

package/dist/src/reactivity/bindTextNode.js

@@ -0,0 +1,27 @@
+import { track } from "./track";
+import { sanitize } from "../utils/sanitize";
+/**
+ * Binds a reactive getter to a Text node, updating its content reactively.
+ * Render errors are swallowed to preserve last displayed text.
+ * Sanitizes text to prevent HTML injection.
+ *
+ * @param textNode Target Text node whose content will be updated
+ * @param getter Function returning string or number to display
+ * @returns Teardown function to cancel the binding
+ */
+export function bindTextNode(textNode, getter) {
+    function commit() {
+        let value;
+        try {
+            value = getter();
+        }
+        catch {
+            return;
+        }
+        // Sanitize output to escape HTML
+        textNode.textContent = sanitize(String(value));
+    }
+    // Initial render and reactive subscription
+    const teardown = track(commit, commit);
+    return teardown;
+}

package/dist/src/reactivity/signal.d.ts

@@ -0,0 +1,3 @@
+export interface ReactiveSignal {
+    _subscribe?: (subscriber: () => void) => () => void;
+}

package/dist/src/reactivity/signal.js

@@ -0,0 +1 @@
+export {};

package/dist/src/reactivity/track.d.ts

@@ -0,0 +1,18 @@
+import type { ReactiveSignal } from "./signal";
+type Subscriber = () => void;
+/**
+ * Track dependencies of an effect or computed subscriber.
+ * Returns a teardown function to remove all subscriptions.
+ */
+export declare function track(effectFn: () => void, subscriber: Subscriber): () => void;
+/**
+ * Record that the current subscriber depends on this signal.
+ * Called by signal.get().
+ */
+export declare function recordDependency(signal: ReactiveSignal): void;
+/**
+ * Notify all subscribers of a given signal change.
+ * Called by signal.set().
+ */
+export declare function notifySubscribers(signal: ReactiveSignal): void;
+export {};

package/dist/src/reactivity/track.js

@@ -0,0 +1,73 @@
+// Stack to support nested subscribers
+const subscriberStack = [];
+let currentSubscriber = null;
+// Maps to track dependencies and allow cleanup
+const subscriberDependencies = new WeakMap();
+const signalSubscribers = new WeakMap();
+/**
+ * Track dependencies of an effect or computed subscriber.
+ * Returns a teardown function to remove all subscriptions.
+ */
+export function track(effectFn, subscriber) {
+    // Cleanup previous dependencies
+    cleanup(subscriber);
+    // Push subscriber to stack and set current
+    subscriberStack.push(subscriber);
+    currentSubscriber = subscriber;
+    // Execute the effect, during which recordDependency will be called by signals
+    effectFn();
+    // Pop subscriber and restore previous
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    // Return teardown to allow manual unsubscription
+    return () => cleanup(subscriber);
+}
+/**
+ * Record that the current subscriber depends on this signal.
+ * Called by signal.get().
+ */
+export function recordDependency(signal) {
+    if (!currentSubscriber)
+        return;
+    let deps = subscriberDependencies.get(currentSubscriber);
+    if (!deps) {
+        deps = new Set();
+        subscriberDependencies.set(currentSubscriber, deps);
+    }
+    if (!deps.has(signal)) {
+        deps.add(signal);
+        let subs = signalSubscribers.get(signal);
+        if (!subs) {
+            subs = new Set();
+            signalSubscribers.set(signal, subs);
+        }
+        subs.add(currentSubscriber);
+    }
+}
+/**
+ * Notify all subscribers of a given signal change.
+ * Called by signal.set().
+ */
+export function notifySubscribers(signal) {
+    const subs = signalSubscribers.get(signal);
+    if (!subs)
+        return;
+    // Clone to avoid issues if subscribers modify subscriptions during notification
+    for (const sub of Array.from(subs)) {
+        sub();
+    }
+}
+/**
+ * Remove a subscriber from all signal dependency lists.
+ */
+function cleanup(subscriber) {
+    const deps = subscriberDependencies.get(subscriber);
+    if (!deps)
+        return;
+    for (const signal of deps) {
+        const subs = signalSubscribers.get(signal);
+        subs?.delete(subscriber);
+    }
+    deps.clear();
+    subscriberDependencies.delete(subscriber);
+}

package/dist/src/reactivity/useComputed.d.ts

@@ -0,0 +1,6 @@
+/**
+ * useComputed creates a derived reactive signal whose value updates when dependencies change.
+ * @param getter Function returning computed value based on reactive signals.
+ * @returns Getter function for the computed value.
+ */
+export declare function useComputed<T>(getter: () => T): () => T;

package/dist/src/reactivity/useComputed.js

@@ -0,0 +1,30 @@
+import { track, recordDependency, notifySubscribers } from "./track";
+/**
+ * useComputed creates a derived reactive signal whose value updates when dependencies change.
+ * @param getter Function returning computed value based on reactive signals.
+ * @returns Getter function for the computed value.
+ */
+export function useComputed(getter) {
+    // Initial value computation
+    let value = getter();
+    // Signal object representing this computed's identity
+    const computedSignal = {};
+    // Recompute function subscribed to dependency changes
+    const recompute = () => {
+        const next = getter();
+        if (Object.is(next, value))
+            return;
+        value = next;
+        notifySubscribers(computedSignal);
+    };
+    // Track dependencies and register recompute callback
+    track(recompute, recompute);
+    /**
+     * Getter for the computed value.
+     * Registers a dependency on this computed signal and returns the current value.
+     */
+    return function computedGetter() {
+        recordDependency(computedSignal);
+        return value;
+    };
+}

package/dist/src/reactivity/useEffect.d.ts

@@ -0,0 +1,6 @@
+/**
+ * useEffect runs the provided effectFn immediately and re-runs it whenever
+ * any reactive dependency changes.
+ * Returns a cleanup function to stop further executions.
+ */
+export declare function useEffect(effectFn: () => void): () => void;

package/dist/src/reactivity/useEffect.js

@@ -0,0 +1,23 @@
+import { track } from "./track";
+/**
+ * useEffect runs the provided effectFn immediately and re-runs it whenever
+ * any reactive dependency changes.
+ * Returns a cleanup function to stop further executions.
+ */
+export function useEffect(effectFn) {
+    // Internal cleanup handle for previous subscription
+    let cleanupHandle = () => { };
+    // Subscriber function that re-schedules the effect when dependencies notify
+    const subscriber = () => {
+        // Cleanup previous subscriptions before re-running
+        cleanupHandle();
+        // Track the effect and update cleanupHandle
+        cleanupHandle = track(effectFn, subscriber);
+    };
+    // Initial execution and subscription
+    cleanupHandle = track(effectFn, subscriber);
+    // Return a function to cleanup and stop any further effect runs
+    return () => {
+        cleanupHandle();
+    };
+}

package/dist/src/reactivity/useState.d.ts

@@ -0,0 +1,10 @@
+type SetState<T> = (next: T | ((prev: T) => T)) => void;
+type StateTuple<T> = [() => T, SetState<T>];
+/**
+ * useState creates a reactive signal that holds a value of type T.
+ * Returns a tuple: [getter, setter].
+ * - getter(): registers dependency and returns the current state value.
+ * - setter(next): updates the state and notifies subscribers if changed.
+ */
+export declare function useState<T>(initial: T): StateTuple<T>;
+export {};

package/dist/src/reactivity/useState.js

@@ -0,0 +1,34 @@
+import { recordDependency, notifySubscribers } from "./track";
+/**
+ * useState creates a reactive signal that holds a value of type T.
+ * Returns a tuple: [getter, setter].
+ * - getter(): registers dependency and returns the current state value.
+ * - setter(next): updates the state and notifies subscribers if changed.
+ */
+export function useState(initial) {
+    // Internal state container acts as the ReactiveSignal
+    const state = { value: initial };
+    /**
+     * Getter for the state value.
+     * Registers this call as a dependency on the current subscriber.
+     */
+    function get() {
+        recordDependency(state);
+        return state.value;
+    }
+    /**
+     * Setter for the state value.
+     * Accepts a new value or an updater function.
+     * Notifies subscribers only if the new value is different (Object.is).
+     */
+    function set(next) {
+        const newValue = typeof next === "function"
+            ? next(state.value)
+            : next;
+        if (Object.is(newValue, state.value))
+            return;
+        state.value = newValue;
+        notifySubscribers(state);
+    }
+    return [get, set];
+}

package/dist/src/reactivity/useStore.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates a global store with reactive properties.
+ *
+ * @param initialState Initial state object
+ * @returns A tuple [store, actions]:
+ *  - store: Proxy object with reactive getters for each state property
+ *  - actions:
+ *      - setState: apply a partial patch or updater function
+ *      - reset: revert to initial state
+ */
+export declare function useStore<T extends object>(initialState: T): [
+    store: {
+        readonly [K in keyof T]: T[K];
+    },
+    actions: {
+        setState: (patch: Partial<T> | ((state: T) => T)) => void;
+        reset: () => void;
+    }
+];

package/dist/src/reactivity/useStore.js

@@ -0,0 +1,53 @@
+import { useState } from "./useState";
+/**
+ * Creates a global store with reactive properties.
+ *
+ * @param initialState Initial state object
+ * @returns A tuple [store, actions]:
+ *  - store: Proxy object with reactive getters for each state property
+ *  - actions:
+ *      - setState: apply a partial patch or updater function
+ *      - reset: revert to initial state
+ */
+export function useStore(initialState) {
+    // Create individual signals for each key
+    const signals = {};
+    // Initialize signals
+    Object.keys(initialState).forEach((key) => {
+        const [getter, setter] = useState(initialState[key]);
+        signals[key] = [getter, setter];
+    });
+    // Proxy to expose reactive getters
+    const store = new Proxy({}, {
+        get(_, prop) {
+            if (prop in signals) {
+                const getter = signals[prop][0];
+                return getter();
+            }
+            return undefined;
+        },
+        set() {
+            throw new Error("Direct mutation of store is not allowed. Use actions.setState.");
+        },
+    });
+    // Actions
+    const setState = (patch) => {
+        const current = {};
+        Object.keys(signals).forEach((key) => {
+            current[key] = signals[key][0]();
+        });
+        const nextState = typeof patch === "function" ? patch(current) : patch;
+        Object.entries(nextState).forEach(([key, value]) => {
+            if (key in signals) {
+                signals[key][1](value);
+            }
+        });
+    };
+    const reset = () => {
+        Object.keys(initialState).forEach((key) => {
+            const setter = signals[key][1];
+            setter(initialState[key]);
+        });
+    };
+    return [store, { setState, reset }];
+}

package/dist/src/reactivity/useWatch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Watches a reactive getter and calls callback with (newValue, oldValue) when it changes.
+ *
+ * @param getter Function that returns the value to watch (reads reactive signals).
+ * @param callback Function called when the watched value changes.
+ * @returns Teardown function to cancel the watcher.
+ */
+export declare function useWatch<T>(getter: () => T, callback: (value: T, prev: T | undefined) => void): () => void;

package/dist/src/reactivity/useWatch.js

@@ -0,0 +1,23 @@
+import { track } from "./track";
+/**
+ * Watches a reactive getter and calls callback with (newValue, oldValue) when it changes.
+ *
+ * @param getter Function that returns the value to watch (reads reactive signals).
+ * @param callback Function called when the watched value changes.
+ * @returns Teardown function to cancel the watcher.
+ */
+export function useWatch(getter, callback) {
+    // Get initial value without registering dependencies
+    let oldValue = getter();
+    // Subscriber function for track
+    const subscriber = () => {
+        const newValue = getter();
+        if (newValue !== oldValue) {
+            callback(newValue, oldValue);
+            oldValue = newValue;
+        }
+    };
+    // Track dependencies and return teardown for unsubscription
+    const teardown = track(subscriber, subscriber);
+    return teardown;
+}

package/dist/src/utils/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitize(value: any): string;

package/dist/src/utils/sanitize.js

@@ -0,0 +1,8 @@
+export function sanitize(value) {
+    return String(value)
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}

package/dist/ssr-27FOM46T.js

@@ -0,0 +1,35 @@
+import {
+  sbCollectStream,
+  sbDeserializeState,
+  sbHydrate,
+  sbHydrateIslands,
+  sbHydrateProgressively,
+  sbIsland,
+  sbRenderToDocument,
+  sbRenderToReadableStream,
+  sbRenderToStream,
+  sbRenderToString,
+  sbRenderToSuspenseStream,
+  sbResetSSRState,
+  sbSerializeState,
+  sbSsrSuspense,
+  sbSuspenseSwapScript
+} from "./chunk-VM4QMKVK.js";
+import "./chunk-MLKGABMK.js";
+export {
+  sbCollectStream,
+  sbDeserializeState,
+  sbHydrate,
+  sbHydrateIslands,
+  sbHydrateProgressively,
+  sbIsland,
+  sbRenderToDocument,
+  sbRenderToReadableStream,
+  sbRenderToStream,
+  sbRenderToString,
+  sbRenderToSuspenseStream,
+  sbResetSSRState,
+  sbSerializeState,
+  sbSsrSuspense,
+  sbSuspenseSwapScript
+};

package/dist/ssr-GFUTTSJD.js

@@ -0,0 +1,22 @@
+import {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  island,
+  renderToDocument,
+  renderToStream,
+  renderToString,
+  serializeState
+} from "./chunk-5G67D3IZ.js";
+export {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  island,
+  renderToDocument,
+  renderToStream,
+  renderToString,
+  serializeState
+};

package/dist/ssr-K7DCR6BZ.js

@@ -0,0 +1,35 @@
+import {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  island,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  serializeState,
+  ssrSuspense,
+  suspenseSwapScript
+} from "./chunk-7UASYN3G.js";
+import "./chunk-MLKGABMK.js";
+export {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  island,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  serializeState,
+  ssrSuspense,
+  suspenseSwapScript
+};

package/dist/ssr-O6LFMRFP.js

@@ -0,0 +1,35 @@
+import {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  island,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  serializeState,
+  ssrSuspense,
+  suspenseSwapScript
+} from "./chunk-KP2DZH5Q.js";
+import "./chunk-MLKGABMK.js";
+export {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  island,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  serializeState,
+  ssrSuspense,
+  suspenseSwapScript
+};

package/dist/ssr-QZEVGMMK.js

@@ -0,0 +1,35 @@
+import {
+  island,
+  sbCollectStream,
+  sbDeserializeState,
+  sbHydrate,
+  sbHydrateIslands,
+  sbHydrateProgressively,
+  sbRenderToDocument,
+  sbRenderToReadableStream,
+  sbRenderToStream,
+  sbRenderToString,
+  sbRenderToSuspenseStream,
+  sbResetSSRState,
+  sbSerializeState,
+  sbSsrSuspense,
+  sbSuspenseSwapScript
+} from "./chunk-XKVFQTJJ.js";
+import "./chunk-MLKGABMK.js";
+export {
+  island,
+  sbCollectStream,
+  sbDeserializeState,
+  sbHydrate,
+  sbHydrateIslands,
+  sbHydrateProgressively,
+  sbRenderToDocument,
+  sbRenderToReadableStream,
+  sbRenderToStream,
+  sbRenderToString,
+  sbRenderToSuspenseStream,
+  sbResetSSRState,
+  sbSerializeState,
+  sbSsrSuspense,
+  sbSuspenseSwapScript
+};

package/dist/ssr-SGVBCAGC.js

@@ -0,0 +1,35 @@
+import {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  island,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  serializeState,
+  ssrSuspense,
+  suspenseSwapScript
+} from "./chunk-3IVI3J54.js";
+import "./chunk-MLKGABMK.js";
+export {
+  collectStream,
+  deserializeState,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  island,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  serializeState,
+  ssrSuspense,
+  suspenseSwapScript
+};