round-core 0.1.2 → 0.1.3

package/src/runtime/signals.js

@@ -0,0 +1,484 @@
+import { onMount, triggerUpdate, getCurrentComponent } from './lifecycle.js';
+import { reportErrorSafe } from './error-reporter.js';
+
+let context = null;
+let batchCount = 0;
+let pendingEffects = [];
+let globalVersion = 0;
+
+function isPromiseLike(v) {
+    return v && (typeof v === 'object' || typeof v === 'function') && typeof v.then === 'function';
+}
+
+function isSignalLike(v) {
+    return typeof v === 'function' && typeof v.peek === 'function' && ('value' in v);
+}
+
+/**
+ * Run a function without tracking any signals it reads.
+ */
+export function untrack(fn) {
+    const prev = context;
+    context = null;
+    try {
+        return typeof fn === 'function' ? fn() : undefined;
+    } finally {
+        context = prev;
+    }
+}
+
+/**
+ * Batches multiple signal updates into a single effect run.
+ */
+export function batch(fn) {
+    batchCount++;
+    try {
+        return fn();
+    } finally {
+        if (--batchCount === 0) {
+            const effects = pendingEffects;
+            pendingEffects = [];
+            for (let i = 0; i < effects.length; i++) {
+                effects[i].queued = false;
+                effects[i].run();
+            }
+        }
+    }
+}
+
+function subscribe(sub, dep) {
+    let link = sub.deps;
+    while (link) {
+        if (link.dep === dep) return;
+        link = link.nextDep;
+    }
+
+    link = {
+        sub,
+        dep,
+        nextSub: dep.subs,
+        prevSub: null,
+        nextDep: sub.deps,
+        prevDep: null
+    };
+
+    if (dep.subs) dep.subs.prevSub = link;
+    dep.subs = link;
+
+    if (sub.deps) sub.deps.prevDep = link;
+    sub.deps = link;
+}
+
+function cleanup(sub) {
+    let link = sub.deps;
+    while (link) {
+        const { dep, prevSub, nextSub } = link;
+        if (prevSub) prevSub.nextSub = nextSub;
+        else dep.subs = nextSub;
+        if (nextSub) nextSub.prevSub = prevSub;
+        link = link.nextDep;
+    }
+    sub.deps = null;
+}
+
+function notify(dep) {
+    let link = dep.subs;
+    while (link) {
+        const sub = link.sub;
+        if (sub.isComputed) {
+            sub.version = -1;
+            notify(sub);
+        } else {
+            if (batchCount > 0) {
+                if (!sub.queued) {
+                    sub.queued = true;
+                    pendingEffects.push(sub);
+                }
+            } else {
+                sub.run();
+            }
+        }
+        link = link.nextSub;
+    }
+}
+
+/**
+ * Create a reactive side-effect.
+ */
+export function effect(arg1, arg2, arg3) {
+    let callback, explicitDeps = null, options = { onLoad: true };
+    let owner = getCurrentComponent();
+
+    if (typeof arg1 === 'function') {
+        callback = arg1;
+        if (arg2 && typeof arg2 === 'object') options = { ...options, ...arg2 };
+    } else {
+        explicitDeps = arg1; callback = arg2;
+        if (arg3 && typeof arg3 === 'object') options = { ...options, ...arg3 };
+    }
+
+    const sub = {
+        deps: null,
+        queued: false,
+        run() {
+            if (this._cleanup) {
+                try { this._cleanup(); } catch (e) {
+                    reportErrorSafe(e, { phase: 'effect.cleanup', component: owner?.name });
+                }
+                this._cleanup = null;
+            }
+            cleanup(this);
+            const prev = context;
+            context = this;
+            try {
+                if (explicitDeps) {
+                    if (Array.isArray(explicitDeps)) {
+                        for (let i = 0; i < explicitDeps.length; i++) {
+                            const d = explicitDeps[i];
+                            if (typeof d === 'function') d();
+                        }
+                    } else if (typeof explicitDeps === 'function') {
+                        explicitDeps();
+                    }
+                }
+                const res = callback();
+                if (typeof res === 'function') this._cleanup = res;
+                if (owner?.isMounted) triggerUpdate(owner);
+            } catch (e) {
+                if (!isPromiseLike(e)) reportErrorSafe(e, { phase: 'effect', component: owner?.name });
+                else throw e;
+            } finally {
+                context = prev;
+            }
+        },
+        _cleanup: null
+    };
+
+    const dispose = () => {
+        if (sub._cleanup) {
+            try { sub._cleanup(); } catch (e) { }
+            sub._cleanup = null;
+        }
+        cleanup(sub);
+    };
+
+    if (options.onLoad) {
+        onMount(() => sub.run());
+    } else {
+        sub.run();
+    }
+
+    return dispose;
+}
+
+function defineBindMarkerIfNeeded(source, target) {
+    if (source && source.bind === true) {
+        try {
+            Object.defineProperty(target, 'bind', { enumerable: true, value: true, configurable: true });
+        } catch {
+            target.bind = true;
+        }
+    }
+}
+
+function attachHelpers(s) {
+    if (!s || typeof s !== 'function') return s;
+    if (typeof s.transform === 'function' && typeof s.validate === 'function' && typeof s.$pick === 'function') return s;
+
+    s.$pick = (p) => pick(s, p);
+
+    s.transform = (fromInput, toOutput) => {
+        const fromFn = typeof fromInput === 'function' ? fromInput : (v) => v;
+        const toFn = typeof toOutput === 'function' ? toOutput : (v) => v;
+
+        const wrapped = function (...args) {
+            if (args.length > 0) return s(fromFn(args[0]));
+            return toFn(s());
+        };
+
+        wrapped.peek = () => toFn(s.peek());
+        Object.defineProperty(wrapped, 'value', {
+            enumerable: true,
+            configurable: true,
+            get() { return wrapped.peek(); },
+            set(v) { wrapped(v); }
+        });
+
+        defineBindMarkerIfNeeded(s, wrapped);
+        return attachHelpers(wrapped);
+    };
+
+    s.validate = (validator, options = {}) => {
+        const validateFn = typeof validator === 'function' ? validator : null;
+        const error = signal(null);
+        const validateOn = options?.validateOn || 'input';
+        const validateInitial = !!options?.validateInitial;
+
+        const wrapped = function (...args) {
+            if (args.length > 0) {
+                const next = args[0];
+                if (validateFn) {
+                    let res = true;
+                    try { res = validateFn(next, s.peek()); } catch { res = 'Invalid value'; }
+
+                    if (res === true || res === undefined || res === null) {
+                        error(null);
+                        return s(next);
+                    }
+                    error(typeof res === 'string' && res.length ? res : 'Invalid value');
+                    return s.peek();
+                }
+                error(null);
+                return s(next);
+            }
+            return s();
+        };
+
+        wrapped.check = () => {
+            if (!validateFn) { error(null); return true; }
+            const cur = s.peek();
+            let res = true;
+            try { res = validateFn(cur, cur); } catch { res = 'Invalid value'; }
+            if (res === true || res === undefined || res === null) {
+                error(null); return true;
+            }
+            error(typeof res === 'string' && res.length ? res : 'Invalid value');
+            return false;
+        };
+
+        wrapped.peek = () => s.peek();
+        Object.defineProperty(wrapped, 'value', {
+            enumerable: true,
+            configurable: true,
+            get() { return wrapped.peek(); },
+            set(v) { wrapped(v); }
+        });
+
+        wrapped.error = error;
+        wrapped.__round_validateOn = validateOn;
+        if (validateInitial) { try { wrapped.check(); } catch { } }
+        defineBindMarkerIfNeeded(s, wrapped);
+        return attachHelpers(wrapped);
+    };
+
+    return s;
+}
+
+/**
+ * Create a reactive signal.
+ */
+export function signal(initialValue) {
+    const dep = {
+        value: initialValue,
+        version: 0,
+        subs: null
+    };
+
+    const s = function (newValue) {
+        if (arguments.length > 0) {
+            if (dep.value !== newValue) {
+                dep.value = newValue;
+                dep.version = ++globalVersion;
+                notify(dep);
+            }
+            return dep.value;
+        }
+        if (context) subscribe(context, dep);
+        return dep.value;
+    };
+
+    s.peek = () => dep.value;
+    Object.defineProperty(s, 'value', {
+        enumerable: true,
+        configurable: true,
+        get() { return s(); },
+        set(v) { s(v); }
+    });
+
+    return attachHelpers(s);
+}
+
+/**
+ * Create a bindable signal.
+ */
+export function bindable(initialValue) {
+    const s = signal(initialValue);
+    try {
+        Object.defineProperty(s, 'bind', { enumerable: true, value: true, configurable: true });
+    } catch {
+        s.bind = true;
+    }
+    return attachHelpers(s);
+}
+
+function getIn(obj, path) {
+    let cur = obj;
+    for (let i = 0; i < path.length; i++) {
+        if (cur == null) return undefined;
+        cur = cur[path[i]];
+    }
+    return cur;
+}
+
+function setIn(obj, path, value) {
+    if (!Array.isArray(path) || path.length === 0) return value;
+    const root = (obj && typeof obj === 'object') ? obj : {};
+    const out = Array.isArray(root) ? root.slice() : { ...root };
+    let curOut = out;
+    let curIn = root;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        const nextIn = (curIn && typeof curIn === 'object') ? curIn[key] : undefined;
+        const nextOut = (nextIn && typeof nextIn === 'object')
+            ? (Array.isArray(nextIn) ? nextIn.slice() : { ...nextIn })
+            : {};
+        curOut[key] = nextOut;
+        curOut = nextOut;
+        curIn = nextIn;
+    }
+    curOut[path[path.length - 1]] = value;
+    return out;
+}
+
+function parsePath(path) {
+    if (Array.isArray(path)) return path.map(p => String(p));
+    if (typeof path === 'string') return path.split('.').filter(Boolean);
+    return [String(path)];
+}
+
+/**
+ * Create a read/write view of a specific path within a signal object.
+ */
+export function pick(root, path) {
+    if (!isSignalLike(root)) throw new Error('[round] pick() expects a signal.');
+    const pathArr = parsePath(path);
+
+    const view = function (...args) {
+        if (args.length > 0) {
+            const nextRoot = setIn(root.peek(), pathArr, args[0]);
+            return root(nextRoot);
+        }
+        const v = root();
+        return getIn(v, pathArr);
+    };
+
+    view.peek = () => getIn(root.peek(), pathArr);
+    Object.defineProperty(view, 'value', {
+        enumerable: true,
+        configurable: true,
+        get() { return view.peek(); },
+        set(v) { view(v); }
+    });
+
+    if (root.bind === true) {
+        try { Object.defineProperty(view, 'bind', { enumerable: true, value: true, configurable: true }); }
+        catch { view.bind = true; }
+    }
+
+    return view;
+}
+
+function createBindableObjectProxy(root, basePath) {
+    const cache = new Map();
+    const handler = {
+        get(_target, prop) {
+            if (prop === Symbol.toStringTag) return 'BindableObject';
+            if (prop === 'peek') return () => (basePath.length ? pick(root, basePath).peek() : root.peek());
+            if (prop === 'value') return (basePath.length ? pick(root, basePath).peek() : root.peek());
+            if (prop === 'bind') return true;
+            if (prop === '$pick') {
+                return (p) => createBindableObjectProxy(root, basePath.concat(parsePath(p)));
+            }
+            if (prop === '_root') return root;
+            if (prop === '_path') return basePath.slice();
+
+            const key = String(prop);
+            const nextPath = basePath.concat(key);
+            const cacheKey = nextPath.join('.');
+            if (cache.has(cacheKey)) return cache.get(cacheKey);
+
+            try {
+                const stored = getIn(root.peek(), nextPath);
+                if (isSignalLike(stored)) { cache.set(cacheKey, stored); return stored; }
+            } catch { }
+
+            const next = createBindableObjectProxy(root, nextPath);
+            cache.set(cacheKey, next);
+            return next;
+        },
+        set(_target, prop, value) {
+            const key = String(prop);
+            const nextPath = basePath.concat(key);
+            try {
+                const stored = getIn(root.peek(), nextPath);
+                if (isSignalLike(stored)) { stored(value); return true; }
+            } catch { }
+            pick(root, nextPath)(value);
+            return true;
+        },
+        has(_target, prop) {
+            if (prop === 'peek' || prop === 'value' || prop === 'bind' || prop === '$pick') return true;
+            const v = basePath.length ? pick(root, basePath).peek() : root.peek();
+            return v != null && Object.prototype.hasOwnProperty.call(v, prop);
+        }
+    };
+
+    const fn = function (...args) {
+        if (args.length > 0) return (basePath.length ? pick(root, basePath)(args[0]) : root(args[0]));
+        return (basePath.length ? pick(root, basePath)() : root());
+    };
+
+    fn.peek = () => (basePath.length ? pick(root, basePath).peek() : root.peek());
+    Object.defineProperty(fn, 'value', { enumerable: true, configurable: true, get() { return fn.peek(); }, set(v) { fn(v); } });
+    try { Object.defineProperty(fn, 'bind', { enumerable: true, value: true, configurable: true }); }
+    catch { fn.bind = true; }
+
+    return new Proxy(fn, handler);
+}
+
+bindable.object = function (initialObject = {}) {
+    const root = bindable((initialObject && typeof initialObject === 'object') ? initialObject : {});
+    return createBindableObjectProxy(root, []);
+};
+
+/**
+ * Create a read-only computed signal.
+ */
+export function derive(fn) {
+    const dep = {
+        fn,
+        value: undefined,
+        version: -1,
+        depsVersion: -1,
+        subs: null,
+        deps: null,
+        isComputed: true,
+        run() {
+            cleanup(this);
+            const prev = context;
+            context = this;
+            try {
+                this.value = this.fn();
+                this.depsVersion = globalVersion;
+                this.version = ++globalVersion;
+            } finally {
+                context = prev;
+            }
+        }
+    };
+
+    const s = function () {
+        if (dep.version === -1 || dep.depsVersion < globalVersion) dep.run();
+        if (context) subscribe(context, dep);
+        return dep.value;
+    };
+
+    s.peek = () => {
+        if (dep.version === -1 || dep.depsVersion < globalVersion) dep.run();
+        return dep.value;
+    };
+
+    Object.defineProperty(s, 'value', { enumerable: true, configurable: true, get() { return s(); } });
+
+    return attachHelpers(s);
+}

package/src/runtime/store.js

@@ -0,0 +1,215 @@
+import { bindable, effect } from './signals.js';
+import { reportErrorSafe } from './error-reporter.js';
+
+function hasWindow() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+
+/**
+ * Create a shared global state store with actions and optional persistence.
+ * @template T
+ * @param {T} [initialState={}] Initial state object.
+ * @param {Record<string, (state: T, ...args: any[]) => any>} [actions] Action reducers.
+ * @returns {RoundStore<T>} The store object.
+ */
+export function createStore(initialState = {}, actions = null) {
+    const state = (initialState && typeof initialState === 'object') ? initialState : {};
+    const signals = Object.create(null);
+    const persistState = {
+        enabled: false,
+        key: null,
+        storage: null,
+        persisting: false,
+        persistNow: null,
+        watchers: new Set()
+    };
+
+    for (const k of Object.keys(state)) {
+        signals[k] = bindable(state[k]);
+    }
+
+    function setKey(k, v) {
+        const key = String(k);
+        if (!Object.prototype.hasOwnProperty.call(signals, key)) {
+            signals[key] = bindable(state[key]);
+        }
+        state[key] = v;
+        signals[key](v);
+        if (persistState.enabled && typeof persistState.persistNow === 'function') {
+            persistState.persistNow();
+        }
+        return v;
+    }
+
+    function patch(obj) {
+        if (!obj || typeof obj !== 'object') return;
+        for (const [k, v] of Object.entries(obj)) {
+            setKey(k, v);
+        }
+    }
+
+    function getSnapshot(reactive = false) {
+        const out = {};
+        for (const k of Object.keys(signals)) {
+            out[k] = reactive ? signals[k]() : signals[k].peek();
+        }
+        return out;
+    }
+
+    const store = {
+        use(key) {
+            const k = String(key);
+            if (!Object.prototype.hasOwnProperty.call(signals, k)) {
+                signals[k] = bindable(state[k]);
+                if (!Object.prototype.hasOwnProperty.call(state, k)) {
+                    try {
+                        reportErrorSafe(new Error(`Store key not found: ${k}`), { phase: 'store.use', component: 'createStore' });
+                    } catch {
+                    }
+                }
+            }
+
+            if (persistState.enabled) {
+                const sig = signals[k];
+                if (sig && typeof sig === 'function' && !persistState.watchers.has(k)) {
+                    persistState.watchers.add(k);
+                    effect(() => {
+                        sig();
+                        if (persistState.persisting) return;
+                        if (typeof persistState.persistNow === 'function') persistState.persistNow();
+                    }, { onLoad: false });
+                }
+            }
+
+            return signals[k];
+        },
+        set(key, value) {
+            return setKey(key, value);
+        },
+        patch,
+        snapshot(options = {}) {
+            const reactive = options && typeof options === 'object' && options.reactive === true;
+            return getSnapshot(reactive);
+        },
+        actions: {}
+    };
+
+    if (actions && typeof actions === 'object') {
+        Object.entries(actions).forEach(([name, reducer]) => {
+            if (typeof reducer !== 'function') return;
+            const fn = (...args) => {
+                try {
+                    const next = reducer(getSnapshot(false), ...args);
+                    if (next && typeof next === 'object') {
+                        patch(next);
+                    }
+                    return next;
+                } catch (e) {
+                    reportErrorSafe(e, { phase: 'store.action', component: String(name) });
+                }
+            };
+            store.actions[name] = fn;
+            store[name] = fn;
+        });
+    }
+
+    store.persist = (storageKey, optionsOrStorage) => {
+        if (typeof storageKey !== 'string' || !storageKey.length) return store;
+
+        const isStorageLike = optionsOrStorage
+            && (typeof optionsOrStorage.getItem === 'function')
+            && (typeof optionsOrStorage.setItem === 'function');
+
+        const opts = (!isStorageLike && optionsOrStorage && typeof optionsOrStorage === 'object')
+            ? optionsOrStorage
+            : {};
+
+        const st = isStorageLike
+            ? optionsOrStorage
+            : (opts.storage ?? (hasWindow() ? window.localStorage : null));
+
+        if (!st || typeof st.getItem !== 'function' || typeof st.setItem !== 'function') return store;
+
+        const debounceMs = Number.isFinite(Number(opts.debounce)) ? Number(opts.debounce) : 0;
+        const exclude = Array.isArray(opts.exclude) ? opts.exclude.map(String) : [];
+
+        try {
+            const raw = st.getItem(storageKey);
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === 'object') {
+                    const filtered = exclude.length
+                        ? Object.fromEntries(Object.entries(parsed).filter(([k]) => !exclude.includes(String(k))))
+                        : parsed;
+                    patch(filtered);
+                }
+            }
+        } catch {
+        }
+
+        const persistNow = () => {
+            try {
+                persistState.persisting = true;
+                const snap = getSnapshot(false);
+                const out = exclude.length
+                    ? Object.fromEntries(Object.entries(snap).filter(([k]) => !exclude.includes(String(k))))
+                    : snap;
+                st.setItem(storageKey, JSON.stringify(out));
+            } catch {
+            } finally {
+                persistState.persisting = false;
+            }
+        };
+
+        let debounceId = null;
+        const schedulePersist = () => {
+            if (debounceMs <= 0) return persistNow();
+            try {
+                if (debounceId != null) clearTimeout(debounceId);
+            } catch {
+            }
+            debounceId = setTimeout(() => {
+                debounceId = null;
+                persistNow();
+            }, debounceMs);
+        };
+
+        persistState.enabled = true;
+        persistState.key = storageKey;
+        persistState.storage = st;
+        persistState.persistNow = schedulePersist;
+
+        const origSet = store.set;
+        store.set = (k, v) => {
+            const res = origSet(k, v);
+            schedulePersist();
+            return res;
+        };
+
+        const origPatch = store.patch;
+        store.patch = (obj) => {
+            origPatch(obj);
+            schedulePersist();
+        };
+
+        Object.keys(store.actions).forEach((name) => {
+            const orig = store.actions[name];
+            if (typeof orig !== 'function') return;
+            store.actions[name] = (...args) => {
+                const res = orig(...args);
+                schedulePersist();
+                return res;
+            };
+            store[name] = store.actions[name];
+        });
+
+        Object.keys(signals).forEach((k) => {
+            try { store.use(k); } catch { }
+        });
+
+        schedulePersist();
+        return store;
+    };
+
+    return store;
+}