@jsswift/core 1.0.41

package/src/33-debug-perf.js

@@ -0,0 +1,176 @@
+  // ===============================
+  // Debug utilities
+  // ===============================
+  JSswift.debug = (() => {
+    const counters = {
+      rodFlushes: 0,
+      rodNotifies: 0,
+      rodBinds: 0,
+      rodBindNull: 0,
+      rodBindDup: 0,
+    };
+
+    function enabled() {
+      return !!JSswift.config.debug;
+    }
+
+    function log(...a) { if (enabled()) console.log("[JSswift]", ...a); }
+    function warn(...a) { if (enabled()) console.warn("[JSswift]", ...a); }
+    function error(...a) { console.error("[JSswift]", ...a); } // error sempre
+
+    function inc(name, by = 1) {
+      if (!counters[name]) counters[name] = 0;
+      counters[name] += by;
+    }
+
+    function stats() {
+      // snapshot immutabile
+      return { ...counters };
+    }
+
+    function reset() {
+      for (const k of Object.keys(counters)) counters[k] = 0;
+    }
+
+    return { enabled, log, warn, error, inc, stats, reset };
+  })();
+
+  // ===============================
+  // Performance DevTools
+  // ===============================
+  JSswift.perf = (() => {
+    let enabled = false;
+
+    const counters = {
+      effectsRun: 0,
+      effectsSlow: 0,
+      rodNotifies: 0,
+      rodFlushes: 0,
+      domWrites: 0,
+      httpRequests: 0
+    };
+
+    const timeline = []; // {t,type,ms,meta}
+    const slow = [];     // {ms, meta}
+
+    const cfg = {
+      timelineMax: 200,
+      slowEffectMs: 8,   // soglia "lento"
+    };
+
+    function now() {
+      return (typeof performance !== "undefined" && performance.now) ? performance.now() : Date.now();
+    }
+
+    function pushEvent(type, ms = 0, meta = null) {
+      if (!enabled) return;
+      timeline.push({ t: Date.now(), type, ms, meta });
+      if (timeline.length > cfg.timelineMax) timeline.shift();
+    }
+
+    function inc(name, by = 1) {
+      if (!enabled) return;
+      counters[name] = (counters[name] || 0) + by;
+    }
+
+    function trackSlow(ms, meta) {
+      if (!enabled) return;
+      slow.push({ t: Date.now(), ms, meta });
+      if (slow.length > 100) slow.shift();
+    }
+
+    // --- patch reactive.effect ---
+    let _origEffect = null;
+
+    function patchEffect() {
+      if (_origEffect) return;
+      _origEffect = JSswift.reactive.effect;
+
+      JSswift.reactive.effect = function (fn, meta) {
+        // meta opzionale (string/object) per identificare
+        const wrapped = (...args) => {
+          const t0 = now();
+          inc("effectsRun");
+          try { return fn(...args); }
+          finally {
+            const dt = now() - t0;
+            if (dt >= cfg.slowEffectMs) {
+              inc("effectsSlow");
+              trackSlow(dt, meta || fn.name || "effect");
+              pushEvent("effect:slow", dt, meta || fn.name || null);
+            } else {
+              pushEvent("effect", dt, meta || fn.name || null);
+            }
+          }
+        };
+        return _origEffect(wrapped);
+      };
+    }
+
+    function unpatchEffect() {
+      if (_origEffect) {
+        JSswift.reactive.effect = _origEffect;
+        _origEffect = null;
+      }
+    }
+
+    // Public API
+    function enable(on = true) {
+      enabled = !!on;
+      if (enabled) patchEffect();
+      else unpatchEffect();
+      return enabled;
+    }
+
+    function reset() {
+      for (const k of Object.keys(counters)) counters[k] = 0;
+      timeline.length = 0;
+      slow.length = 0;
+    }
+
+    function stats() {
+      return {
+        enabled,
+        ...counters,
+        slowEffectMs: cfg.slowEffectMs,
+        timelineSize: timeline.length
+      };
+    }
+
+    function getTimeline() {
+      return timeline.slice();
+    }
+
+    function slowEffects(minMs = cfg.slowEffectMs) {
+      return slow.filter(x => x.ms >= minMs).slice().sort((a, b) => b.ms - a.ms);
+    }
+
+    // helper per misurare manualmente
+    function time(label, fn) {
+      const t0 = now();
+      try { return fn(); }
+      finally {
+        const dt = now() - t0;
+        pushEvent("time:" + label, dt, label);
+      }
+    }
+
+    // hook utili da chiamare in rod/http
+    function mark(type, meta) { pushEvent(type, 0, meta); }
+    function tick(type, ms, meta) { pushEvent(type, ms, meta); }
+
+    return {
+      enable,
+      reset,
+      stats,
+      timeline: getTimeline,
+      slowEffects,
+      time,
+      mark,
+      tick,
+      inc,
+      cfg
+    };
+  })();
+
+

package/src/34-rod-devtools.js

@@ -0,0 +1,43 @@
+  // ===============================
+  // Rod DevTools micro
+  // ===============================
+  JSswift.rod = JSswift.rod || {};
+
+  JSswift.rod.inspect = function (r, label = "rod") {
+    if (!r || r.type !== "rod") {
+      console.warn("[JSswift.rod.inspect] non è un rod:", r);
+      return null;
+    }
+
+    const bindings = typeof r.bindings === "function" ? r.bindings() : [];
+    const info = {
+      label,
+      value: r.value,
+      bindingsCount: bindings.length,
+      bindings: bindings.map(b => ({
+        key: b.key,
+        el: b.el?.nodeType === 3 ? "#text" : b.el?.tagName,
+        id: b.el?.id || null,
+        className: b.el?.className || null,
+        isConnected: b.el?.nodeType === 3 ? !!b.el.parentNode : (b.el?.isConnected ?? null)
+      })),
+      actionsCount: Array.isArray(r._actions) ? r._actions.length : null,
+      disposed: !!r._disposed
+    };
+
+    if (JSswift.config.debug) {
+      console.groupCollapsed(`[JSswift.rod.inspect] ${label}`);
+      console.log(info);
+      console.groupEnd();
+    } else {
+      console.log(info);
+    }
+
+    return info;
+  };
+
+  JSswift.rod.inspectAll = function () {
+    const all = JSswift.rod._all ? Array.from(JSswift.rod._all) : [];
+    all.forEach((r, i) => JSswift.rod.inspect(r, `rod#${i + 1}`));
+    return all.length;
+  };

package/src/39-store-shared.js

@@ -0,0 +1,60 @@
+  // ===============================
+  // Store shared helpers
+  // ===============================
+  JSswift._storeShared = (() => {
+    function scopeId(scope) {
+      return `${scope.storage}::${scope.prefix}`;
+    }
+
+    function createScopeTools(config, knownScopes) {
+      function getScope(opts = {}) {
+        const scope = {
+          storage: opts.storage ?? config.storage,
+          prefix: opts.prefix ?? config.prefix
+        };
+        knownScopes.set(scopeId(scope), scope);
+        return scope;
+      }
+
+      function getStorage(scope = null) {
+        const mode = typeof scope === "string" ? scope : (scope?.storage ?? config.storage);
+        return mode === "session" ? window.sessionStorage : window.localStorage;
+      }
+
+      function fullKey(key, scope = null) {
+        const resolved = scope || getScope();
+        return resolved.prefix + key;
+      }
+
+      function channelKey(key, scope = null) {
+        const resolved = scope || getScope();
+        return `${scopeId(resolved)}::${key}`;
+      }
+
+      return { getScope, getStorage, fullKey, channelKey };
+    }
+
+    function safeParse(str) {
+      try { return JSON.parse(str); } catch { return undefined; }
+    }
+
+    function safeStringify(value) {
+      try { return JSON.stringify(value); } catch { return undefined; }
+    }
+
+    function clearScopedMapEntries(scope, ...maps) {
+      const prefix = `${scope.storage}::${scope.prefix}::`;
+      for (const map of maps) {
+        for (const id of Array.from(map.keys())) {
+          if (id.startsWith(prefix)) map.delete(id);
+        }
+      }
+    }
+
+    return {
+      createScopeTools,
+      safeParse,
+      safeStringify,
+      clearScopedMapEntries
+    };
+  })();

package/src/40-store-core.js

@@ -0,0 +1,203 @@
+  // ===============================
+  // JSswift.store v1 (persisted reactive state)
+  // ===============================
+  JSswift.store = (() => {
+    const config = {
+      prefix: "JSswift:",
+      storage: "local", // "local" | "session"
+      syncTabs: true,
+      writeDelay: 0, // ms (0 = microtask)
+    };
+
+    const mem = new Map();          // channelKey -> value (runtime cache)
+    const watchers = new Map();     // channelKey -> Set(fn)
+    const pendingWrites = new Map();// channelKey -> { key, scope }
+    const knownScopes = new Map();  // scopeId -> { storage, prefix }
+    let writeQueued = false;
+    const {
+      createScopeTools,
+      safeParse,
+      safeStringify,
+      clearScopedMapEntries
+    } = JSswift._storeShared;
+    const {
+      getScope,
+      getStorage,
+      fullKey,
+      channelKey
+    } = createScopeTools(config, knownScopes);
+
+    function emit(key, value, scope = null) {
+      const resolved = scope || getScope();
+      const set = watchers.get(channelKey(key, resolved));
+      if (!set) return;
+      for (const fn of set) {
+        try {
+          if (JSswift.reactive?.untracked) {
+            JSswift.reactive.untracked(() => fn(value));
+          } else {
+            fn(value);
+          }
+        } catch (e) { console.error("[store] watcher error:", e); }
+      }
+    }
+
+    function flushWrites() {
+      writeQueued = false;
+      for (const [id, pending] of Array.from(pendingWrites.entries())) {
+        pendingWrites.delete(id);
+        const v = mem.get(id);
+        const s = safeStringify(v);
+        if (s === undefined) continue;
+        const st = getStorage(pending.scope);
+        try { st.setItem(fullKey(pending.key, pending.scope), s); }
+        catch (e) { console.error("[store] write error:", e); }
+      }
+    }
+
+    function scheduleWrite(key, scope = null) {
+      const resolved = scope || getScope();
+      pendingWrites.set(channelKey(key, resolved), { key, scope: resolved });
+      if (writeQueued) return;
+      writeQueued = true;
+
+      if (config.writeDelay > 0) {
+        setTimeout(flushWrites, config.writeDelay);
+      } else {
+        queueMicrotask(flushWrites);
+      }
+    }
+
+    function readFromStorage(key, scope = null) {
+      const resolved = scope || getScope();
+      const st = getStorage(resolved);
+      const raw = st.getItem(fullKey(key, resolved));
+      if (raw == null) return undefined;
+      return safeParse(raw);
+    }
+
+    function get(key, fallback, scope = null) {
+      const resolved = scope || getScope();
+      const id = channelKey(key, resolved);
+      if (mem.has(id)) return mem.get(id);
+      const v = readFromStorage(key, resolved);
+      if (v !== undefined) {
+        mem.set(id, v);
+        return v;
+      }
+      return fallback;
+    }
+
+    function set(key, value, scope = null) {
+      const resolved = scope || getScope();
+      mem.set(channelKey(key, resolved), value);
+      scheduleWrite(key, resolved);
+      emit(key, value, resolved);
+      return value;
+    }
+
+    function remove(key, scope = null) {
+      const resolved = scope || getScope();
+      const id = channelKey(key, resolved);
+      mem.delete(id);
+      pendingWrites.delete(id);
+      try { getStorage(resolved).removeItem(fullKey(key, resolved)); } catch { }
+      emit(key, undefined, resolved);
+    }
+
+    function clear(opts = {}) {
+      const scope = getScope(opts);
+      // rimuove solo chiavi col prefix nel relativo storage
+      const st = getStorage(scope);
+      const keys = [];
+      for (let i = 0; i < st.length; i++) {
+        const k = st.key(i);
+        if (k && k.startsWith(scope.prefix)) keys.push(k);
+      }
+      for (const k of keys) st.removeItem(k);
+
+      clearScopedMapEntries(scope, mem, pendingWrites, watchers);
+    }
+
+    function watch(key, fn, scope = null) {
+      if (typeof fn !== "function") return () => { };
+      const resolved = scope || getScope();
+      const id = channelKey(key, resolved);
+      if (!watchers.has(id)) watchers.set(id, new Set());
+      watchers.get(id).add(fn);
+      return () => watchers.get(id)?.delete(fn);
+    }
+
+    // Signal persistente (core feature)
+    function signal(key, initial, opts = {}) {
+      const scope = getScope({
+        storage: opts.storage,
+        prefix: opts.prefix
+      });
+
+      const hydrated = get(key, initial, scope);
+      const [getSig, setSig, disposeSignal] = JSswift.reactive.signal(hydrated);
+
+      // quando cambia signal -> store, deve restare nello scope corretto
+      const stopEffect = JSswift.reactive.effect(() => {
+        const v = getSig();
+        set(key, v, scope);
+      });
+
+      // quando cambia store (cross-tab o set manuale nello stesso scope) -> signal
+      const unwatch = watch(key, (v) => {
+        // evita loop inutili
+        if (getSig() !== v) setSig(v);
+      }, scope);
+
+      // cleanup helper
+      const dispose = () => {
+        try { stopEffect?.(); } catch { }
+        try { unwatch?.(); } catch { }
+        try { disposeSignal?.(); } catch { }
+      };
+
+      return [getSig, setSig, dispose];
+    }
+
+    getScope();
+
+    // cross-tab sync
+    if (config.syncTabs) {
+      window.addEventListener("storage", (e) => {
+        if (!e.key || !e.storageArea) return;
+
+        for (const scope of knownScopes.values()) {
+          if (getStorage(scope) !== e.storageArea) continue;
+          if (!e.key.startsWith(scope.prefix)) continue;
+
+          const key = e.key.slice(scope.prefix.length);
+          const v = e.newValue == null ? undefined : safeParse(e.newValue);
+          const id = channelKey(key, scope);
+
+          // aggiorna cache + watchers (senza forzare write)
+          if (v === undefined) mem.delete(id);
+          else mem.set(id, v);
+
+          emit(key, v, scope);
+        }
+      });
+    }
+
+    function configure(next = {}) {
+      Object.assign(config, next);
+      getScope();
+    }
+
+    function stats() {
+      return {
+        prefix: config.prefix,
+        storage: config.storage,
+        syncTabs: config.syncTabs,
+        cacheSize: mem.size,
+        scopeCount: knownScopes.size,
+      };
+    }
+
+    return { configure, stats, get, set, remove, clear, watch, signal };
+  })();

package/src/41-store-extensions.js

@@ -0,0 +1,194 @@
+  // ===============================
+  // 1) store.computed (derivato, non persistito)
+  // ===============================
+  JSswift.store.computed = function (fn) {
+    if (typeof fn !== "function") throw new Error("store.computed: fn must be a function");
+    return JSswift.reactive.computed(fn);
+  };
+
+
+  // ===============================
+  // 2) store.migrate (versioning + migrazioni)
+  // ===============================
+  // targetVersion: numero intero (es. 3)
+  // steps: object { 0: fn, 1: fn, 2: fn } dove la chiave è la versione "from"
+  //   step[v] porta da v -> v+1
+  JSswift.store.migrate = function (targetVersion, steps, opts = {}) {
+    const versionKey = opts.versionKey ?? "__version";
+    const from = Number(JSswift.store.get(versionKey, 0) ?? 0);
+    const to = Number(targetVersion ?? 0);
+
+    if (!Number.isFinite(to) || to < 0) throw new Error("store.migrate: targetVersion non valido");
+    if (from >= to) return { from, to, applied: 0 };
+
+    let applied = 0;
+
+    for (let v = from; v < to; v++) {
+      const step = steps?.[v];
+      if (typeof step === "function") {
+        try {
+          step(JSswift.store);
+        } catch (e) {
+          console.error("[store.migrate] step error at version", v, e);
+          // puoi scegliere se interrompere qui: io continuo ma è discutibile.
+          // return { from, to, applied, error: e };
+        }
+      }
+      applied++;
+      // salva versione raggiunta (più sicuro step-by-step)
+      JSswift.store.set(versionKey, v + 1);
+    }
+
+    return { from, to, applied };
+  };
+
+
+  // ===============================
+  // 3) store.model (form persistenti + rodModel)
+  // ===============================
+  // elOrList: Element | NodeList | Array<Element> (radio group ecc.)
+  // key: string per storage
+  // initial: valore iniziale se non presente
+  // opts: { storage, prefix, event, parse, format }
+  JSswift.store.model = function (elOrList, key, initial, opts = {}) {
+    if (typeof key !== "string" || !key) throw new Error("store.model: key deve essere una stringa non vuota");
+
+    // signal persistente
+    const [get, set, disposeSignal] = JSswift.store.signal(key, initial, {
+      storage: opts.storage,
+      prefix: opts.prefix,
+    });
+
+    // bridge signal <-> rod
+    const r = JSswift.rodFromSignal(get, set);
+
+    // two-way con elementi form (checkbox/radio/select/text/number)
+    const unbindModel = JSswift.rodModel(elOrList, r, {
+      event: opts.event,
+      parse: opts.parse,
+      format: opts.format
+    });
+
+    // cleanup totale (utile con component dispose)
+    return () => {
+      try { unbindModel?.(); } catch { }
+      try { disposeSignal?.(); } catch { }
+      try { r.dispose?.(); } catch { }
+    };
+  };
+
+  // ===============================
+  // store.bind (DX alias super corto)
+  // ===============================
+  // selectorOrEl: "#id" | Element | NodeList | Array<Element>
+  // key: string storage key
+  // initial: valore iniziale
+  // opts: { storage, prefix, event, parse, format }
+  JSswift.store.bind = function (selectorOrEl, key, initial, opts = {}) {
+    let target = selectorOrEl;
+
+    // risolve selector string
+    if (typeof selectorOrEl === "string") {
+      // se è un radio group: input[name=...]
+      if (selectorOrEl.includes("[") || selectorOrEl.includes(" ")) {
+        target = document.querySelectorAll(selectorOrEl);
+      } else {
+        target = JSswift.dom.q(selectorOrEl);
+      }
+    }
+
+    if (!target) {
+      if (JSswift.config?.debug) {
+        console.warn("[store.bind] target non trovato:", selectorOrEl);
+      }
+      return () => { };
+    }
+
+    return JSswift.store.model(target, key, initial, opts);
+  };
+
+  // ===============================
+  // store.bindAll (form -> store)
+  // ===============================
+  JSswift.store.bindAll = function (formEl, schema = {}, opts = {}) {
+    if (typeof formEl === "string") formEl = JSswift.dom.q(formEl);
+    if (!formEl || !formEl.querySelectorAll) {
+      console.warn("[store.bindAll] form non valido:", formEl);
+      return () => { };
+    }
+
+    const disposers = [];
+
+    for (const [name, initial] of Object.entries(schema)) {
+      const els = formEl.querySelectorAll(`[name="${name}"]`);
+      if (!els.length) continue;
+
+      const unbind = JSswift.store.model(
+        els.length === 1 ? els[0] : els,
+        name,
+        initial,
+        opts
+      );
+      disposers.push(unbind);
+    }
+
+    return () => disposers.forEach(fn => fn());
+  };
+
+  // ===============================
+  // store.inspect (DevTools)
+  // ===============================
+  JSswift.store.inspect = function () {
+    const info = {
+      ...JSswift.store.stats(),
+      keys: Array.from(
+        (function () {
+          const st = JSswift.store.stats().storage === "session"
+            ? sessionStorage
+            : localStorage;
+          const out = [];
+          for (let i = 0; i < st.length; i++) {
+            const k = st.key(i);
+            if (k && k.startsWith(JSswift.store.stats().prefix)) {
+              out.push(k.replace(JSswift.store.stats().prefix, ""));
+            }
+          }
+          return out;
+        })()
+      )
+    };
+
+    console.groupCollapsed("[JSswift.store.inspect]");
+    console.table(info.keys);
+    console.log(info);
+    console.groupEnd();
+
+    return info;
+  };
+
+  // ===============================
+  // store.autoForm (autosave + restore)
+  // ===============================
+  JSswift.store.autoForm = function (formEl, schema = {}, opts = {}) {
+    const unbind = JSswift.store.bindAll(formEl, schema, opts);
+
+    if (JSswift.config?.debug) {
+      console.log("[store.autoForm] autosave attivo:", schema);
+    }
+
+    return unbind;
+  };
+
+  // ===============================
+  // useStore (hook-style, component-aware)
+  // ===============================
+  JSswift.useStore = function (key, initial, ctx, opts = {}) {
+    const [get, set, dispose] = JSswift.store.signal(key, initial, opts);
+
+    // se siamo dentro un component, cleanup automatico
+    if (ctx && typeof ctx.onDispose === "function" && typeof dispose === "function") {
+      ctx.onDispose(dispose);
+    }
+
+    return [get, set];
+  };