round-core 0.0.6 → 0.0.8

package/src/runtime/store.js

@@ -1,215 +0,0 @@
-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;
-}

package/src/runtime/suspense.js

@@ -1,128 +0,0 @@
-import { signal } from './signals.js';
-import { createElement, Fragment } from './dom.js';
-import { createContext } from './context.js';
-
-function isPromiseLike(v) {
-    return v && (typeof v === 'object' || typeof v === 'function') && typeof v.then === 'function';
-}
-
-const SuspenseContext = createContext(null);
-export { SuspenseContext };
-
-export function lazy(loader) {
-    if (typeof loader !== 'function') {
-        throw new Error('lazy(loader) expects a function that returns a Promise');
-    }
-
-    let status = 'uninitialized';
-    let promise = null;
-    let component = null;
-    let error = null;
-
-    function pickComponent(mod) {
-        if (!mod) return null;
-        if (typeof mod === 'function') return mod;
-        if (typeof mod.default === 'function') return mod.default;
-        if (typeof mod.Counter === 'function') return mod.Counter;
-
-        const fns = [];
-        for (const k of Object.keys(mod)) {
-            if (typeof mod[k] === 'function') fns.push(mod[k]);
-        }
-        if (fns.length === 1) return fns[0];
-        return null;
-    }
-
-    return function LazyComponent(props = {}) {
-        if (status === 'resolved') {
-            return createElement(component, props);
-        }
-
-        if (status === 'rejected') {
-            throw error;
-        }
-
-        if (!promise) {
-            status = 'pending';
-            try {
-                promise = Promise.resolve(loader())
-                    .then((mod) => {
-                        const resolved = pickComponent(mod);
-                        if (typeof resolved !== 'function') {
-                            throw new Error('lazy() loaded module does not export a component');
-                        }
-                        component = resolved;
-                        status = 'resolved';
-                    })
-                    .catch((e) => {
-                        error = e instanceof Error ? e : new Error(String(e));
-                        status = 'rejected';
-                    });
-            } catch (e) {
-                error = e instanceof Error ? e : new Error(String(e));
-                status = 'rejected';
-                throw error;
-            }
-        }
-
-        throw promise;
-    };
-}
-
-export function Suspense(props = {}) {
-    const tick = signal(0);
-    const pending = new Set();
-
-    // Track promises we are currently waiting for to avoid re-adding them or flickering
-    const waiting = new Set();
-
-    const child = Array.isArray(props.children) ? props.children[0] : props.children;
-    const childFn = typeof child === 'function' ? child : () => child;
-
-    const register = (promise) => {
-        if (!waiting.has(promise)) {
-            waiting.add(promise);
-            pending.add(promise);
-            promise.then(
-                () => {
-                    waiting.delete(promise);
-                    pending.delete(promise);
-                    tick(tick.peek() + 1);
-                },
-                () => {
-                    waiting.delete(promise);
-                    pending.delete(promise);
-                    tick(tick.peek() + 1);
-                }
-            );
-        }
-    };
-
-    return createElement(SuspenseContext.Provider, {
-        value: { register }
-    }, () => {
-        // Read tick to re-render when promises resolve
-        tick();
-
-        // If pending promises, show fallback depending on strategy.
-
-        if (pending.size > 0) {
-            return props.fallback ?? null;
-        }
-
-        try {
-            const res = childFn();
-            if (isPromiseLike(res)) {
-                register(res);
-                return props.fallback ?? null;
-            }
-            return res ?? null;
-        } catch (e) {
-            if (isPromiseLike(e)) {
-                register(e);
-                return props.fallback ?? null;
-            }
-            throw e;
-        }
-    });
-}

package/vite.config.build.js

@@ -1,48 +0,0 @@
-import { defineConfig } from 'vite';
-import path from 'node:path';
-import fs from 'node:fs';
-
-export default defineConfig({
-    build: {
-        target: 'es2022',
-        outDir: 'dist',
-        emptyOutDir: true,
-        minify: false,
-        lib: {
-            entry: {
-                index: path.resolve(__dirname, 'src/index.js'),
-                cli: path.resolve(__dirname, 'src/cli.js'),
-                'vite-plugin': path.resolve(__dirname, 'src/compiler/vite-plugin.js')
-            },
-            formats: ['es']
-        },
-        rollupOptions: {
-            external: [
-                'vite',
-                'marked',
-                'node:fs', 'node:path', 'node:process', 'node:url', 'node:vm', 'node:util',
-                'fs', 'path', 'process', 'url', 'vm', 'util'
-            ],
-            output: {
-                banner: (chunk) => {
-                    if (chunk.name === 'cli' || chunk.fileName === 'cli.js') {
-                        return '#!/usr/bin/env node';
-                    }
-                    return '';
-                }
-            }
-        },
-    },
-    plugins: [
-        {
-            name: 'copy-dts',
-            closeBundle() {
-                const src = path.resolve(__dirname, 'src/index.d.ts');
-                const dest = path.resolve(__dirname, 'dist/index.d.ts');
-                if (fs.existsSync(src)) {
-                    fs.copyFileSync(src, dest);
-                }
-            }
-        }
-    ]
-});

package/vite.config.js

@@ -1,10 +0,0 @@
-import { defineConfig } from 'vite';
-import RoundPlugin from './src/compiler/vite-plugin.js';
-
-export default defineConfig({
-    plugins: [RoundPlugin({ configPath: './start_exmpl/round.config.json' })],
-    root: './', // Serve from root
-    server: {
-        port: 3000
-    }
-});

package/vitest.config.js

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-    test: {
-        environment: 'jsdom',
-        globals: true
-    }
-});