@jsswift/core 1.0.41

package/src/30-rod-core.js

@@ -0,0 +1,270 @@
+  /* ===============================
+     ROD v3 PRO (batch + bindings + dispose hooks + key mapping)
+     =============================== */
+
+  function createMicrotaskScheduler() {
+    let queued = false;
+    const queue = new Set();
+    function flush() {
+      queued = false;
+      JSswift.debug?.inc("rodFlushes");
+      JSswift.perf?.inc("rodFlushes");
+      JSswift.perf?.mark("rod:flush");
+      const jobs = Array.from(queue);
+      queue.clear();
+      for (const fn of jobs) {
+        try { fn(); } catch (e) { console.error("[rod] flush error:", e); }
+      }
+    }
+    return function schedule(fn) {
+      queue.add(fn);
+      if (!queued) {
+        queued = true;
+        queueMicrotask(flush);
+      }
+    };
+  }
+  const rodSchedule = createMicrotaskScheduler();
+
+  function rodApplyBinding(el, key, value) {
+    if (!el) return;
+
+    if (el.nodeType === 3) {
+      el.textContent = value ?? "";
+      return;
+    }
+
+    const domBridge = createDomPropBridge(el, {
+      isSVG: el.namespaceURI === SVG_NS,
+      normalizeClass,
+      isContentProp
+    });
+    domBridge.applyBindingValue(key, value);
+  }
+
+  function rodCreateComponent(initialValue) {
+    const comp = {
+      type: "rod",
+      value: initialValue,
+
+      _bindings: [],
+      _actions: [],
+      _disposeHooks: [],
+
+      _disposed: false,
+      _silentDepth: 0,
+      _pending: false,
+
+      bindings() {
+        return this._bindings.map(b => ({ el: b.el, key: b.key }));
+      },
+
+      onDispose(fn) {
+        if (typeof fn === "function") this._disposeHooks.push(fn);
+        return this;
+      },
+
+      _bind(el, config = { key: "auto" }) {
+        if (this._disposed) return () => { };
+        if (!el) return () => { };
+
+        const b = { el, key: (config?.key ?? "auto") };
+
+        const exists = this._bindings.some(x => x.el === b.el && x.key === b.key);
+        if (!exists) this._bindings.push(b);
+
+        rodApplyBinding(b.el, b.key, this.value);
+
+        return () => {
+          this._bindings = this._bindings.filter(x => !(x.el === b.el && x.key === b.key));
+        };
+      },
+
+      action(fn) {
+        if (!this._disposed && typeof fn === "function") this._actions.push(fn);
+        return this;
+      },
+
+      _setSilent(v) {
+        this._silentDepth++;
+        try { this.value = v; } finally { this._silentDepth--; }
+        return this;
+      },
+
+      _scheduleNotify() {
+        if (this._disposed || this._pending) return;
+        this._pending = true;
+        rodSchedule(() => {
+          this._pending = false;
+          this._notifyNow();
+        });
+      },
+
+      _notifyNow() {
+        if (this._disposed) return;
+        const __t0 = performance.now();
+
+        JSswift.perf?.inc("rodNotifies");
+
+        this._bindings = this._bindings.filter(b => {
+          const el = b.el;
+          if (!el) return false;
+          if (el.nodeType === 3) return !!el.parentNode;
+          return el.isConnected !== false;
+        });
+
+        for (const b of this._bindings) {
+          rodApplyBinding(b.el, b.key, this.value);
+        }
+
+        if (this._silentDepth > 0) return;
+
+        for (const fn of this._actions) {
+          try { fn(this.value); } catch (e) { console.error("[rod] action error:", e); }
+        }
+        JSswift.debug?.inc("rodNotifies");
+        JSswift.perf?.tick("rod:notify", performance.now() - __t0, {
+          bindings: this._bindings?.length || 0,
+          actions: this._actions?.length || 0
+        });
+      },
+
+      dispose() {
+        if (this._disposed) return;
+        this._disposed = true;
+        for (const fn of this._disposeHooks) {
+          try { fn(); } catch (e) { console.error("[rod] dispose hook error:", e); }
+        }
+        this._bindings.length = 0;
+        this._actions.length = 0;
+        this._disposeHooks.length = 0;
+      }
+    };
+    return comp;
+  }
+
+  function rodMakeReactive(obj, key = "value") {
+    let _val = obj[key];
+    let _get = null;
+    let _set = null;
+    let _disposeSignal = null;
+
+    if (JSswift?.reactive?.signal) {
+      [_get, _set, _disposeSignal] = JSswift.reactive.signal(_val);
+      if (_disposeSignal && typeof obj.onDispose === "function") {
+        obj.onDispose(_disposeSignal);
+      }
+    }
+
+    Object.defineProperty(obj, key, {
+      get() { return _get ? _get() : _val; },
+      set(v) {
+        if (_set) _set(v);
+        else _val = v;
+        obj._scheduleNotify();
+      },
+      configurable: true
+    });
+
+    if (typeof obj.val !== "function") {
+      Object.defineProperty(obj, "val", {
+        value(v) {
+          if (arguments.length) {
+            this.value = v;
+            return v;
+          }
+          return this.value;
+        },
+        configurable: true
+      });
+    }
+
+    if (!obj[Symbol.toPrimitive]) {
+      Object.defineProperty(obj, Symbol.toPrimitive, {
+        value(hint) {
+          const v = this.value;
+          if (v == null) return v;
+          const t = typeof v;
+          if (hint === "number") return Number(v);
+          if (t !== "symbol") trackRodInterpolation(this, v);
+          if (t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol") return v;
+          const out = String(v);
+          return out;
+        },
+        configurable: true
+      });
+    }
+
+    if (!obj.valueOf) {
+      Object.defineProperty(obj, "valueOf", {
+        value() { return this.value; },
+        configurable: true
+      });
+    }
+
+    if (!obj.toString) {
+      Object.defineProperty(obj, "toString", {
+        value() { return String(this.value); },
+        configurable: true
+      });
+    }
+
+    return obj;
+  }
+
+  _.rod = function _rod(data, key = "value") {
+    const comp = rodCreateComponent(data);
+    rodMakeReactive(comp, key);
+
+    JSswift.rod._all = JSswift.rod._all || new Set();
+    JSswift.rod._all.add(comp);
+
+    if (typeof comp.onDispose === "function") {
+      comp.onDispose(() => JSswift.rod._all.delete(comp));
+    }
+    return comp;
+  }; // legacy alias, deprecated: use `_.rod`
+
+  JSswift.rodBind = function (el, react, config = { key: "auto" }) {
+    JSswift.debug?.inc("rodBinds");
+
+    if (!el) {
+      JSswift.debug?.inc("rodBindNull");
+      JSswift.debug?.warn("rodBind: target element è null/undefined", config);
+      return () => { };
+    }
+    if (!react || react.type !== "rod") {
+      throw new Error("JSswift.rodBind: react must be a rod object");
+    }
+    return react._bind(el, config);
+  };
+
+
+  JSswift.rodFromSignal = function (get, set) {
+    const r = _.rod(get());
+    let syncing = false;
+
+    const stopRodToSignal = JSswift.reactive.effect(() => {
+      const v = r.value;
+      const currentSignal = JSswift.reactive.untracked(() => get());
+      if (syncing) return;
+      if (currentSignal === v) return;
+      syncing = true;
+      try { set(v); } finally { syncing = false; }
+    });
+
+    const stopEffect = JSswift.reactive.effect(() => {
+      const v = get();
+      const currentRod = JSswift.reactive.untracked(() => r.value);
+      if (currentRod === v) return;
+      syncing = true;
+      try { r._setSilent(v); } finally { syncing = false; }
+    });
+
+    if (typeof r.onDispose === "function") {
+      r.onDispose(stopRodToSignal);
+      r.onDispose(stopEffect);
+    }
+
+    return r;
+  };

package/src/31-rod-model.js

@@ -0,0 +1,157 @@
+  // ===============================
+  // Two-way binding: input <-> rod
+  // ===============================
+  // ===============================
+  // Two-way binding avanzato
+  // input / checkbox / radio / select
+  // ===============================
+
+  function getInputKind(el) {
+    if (!el || !el.tagName) return null;
+
+    const tag = el.tagName.toLowerCase();
+
+    if (tag === "input") {
+      const type = (el.type || "text").toLowerCase();
+      if (type === "checkbox") return "checkbox";
+      if (type === "radio") return "radio";
+      if (type === "number") return "number";
+      return "text";
+    }
+
+    if (tag === "select") {
+      return el.multiple ? "select-multiple" : "select";
+    }
+
+    return null;
+  }
+
+  JSswift.rodModel = function (target, rodObj, opts = {}) {
+    if (!rodObj || rodObj.type !== "rod") {
+      throw new Error("[JSswift.rodModel] rodObj deve essere un rod");
+    }
+
+    // Supporta singolo elemento o lista (radio)
+    const elements = Array.isArray(target) || target instanceof NodeList
+      ? Array.from(target)
+      : [target];
+
+    const eventName = opts.event ?? "change";
+    const parse = opts.parse ?? (v => v);
+    const format = opts.format ?? (v => v);
+
+    let syncing = false;
+    const disposers = [];
+
+    // === ROD → DOM ===
+    const updateDOM = (value) => {
+      for (const el of elements) {
+        if (!el) continue;
+        const kind = getInputKind(el);
+
+        switch (kind) {
+          case "checkbox":
+            el.checked = !!value;
+            break;
+
+          case "radio":
+            el.checked = el.value == value;
+            break;
+
+          case "select":
+            el.value = value ?? "";
+            break;
+
+          case "select-multiple":
+            const arr = Array.isArray(value) ? value.map(String) : [];
+            for (const opt of el.options) {
+              opt.selected = arr.includes(opt.value);
+            }
+            break;
+
+          case "number":
+          case "text":
+          default:
+            el.value = value ?? "";
+        }
+      }
+    };
+
+    // bind rod → DOM (usa rod.action)
+    rodObj.action((v) => {
+      if (syncing) return;
+      syncing = true;
+      try {
+        updateDOM(format(v));
+      } finally {
+        syncing = false;
+      }
+    });
+
+    // sync iniziale
+    updateDOM(format(rodObj.value));
+
+    // === DOM → ROD ===
+    for (const el of elements) {
+      if (!el) continue;
+
+      const kind = getInputKind(el);
+
+      const handler = () => {
+        if (syncing) return;
+
+        let next;
+
+        switch (kind) {
+          case "checkbox":
+            next = el.checked;
+            break;
+
+          case "radio":
+            if (!el.checked) return;
+            next = el.value;
+            break;
+
+          case "select":
+            next = el.value;
+            break;
+
+          case "select-multiple":
+            next = Array.from(el.selectedOptions).map(o => o.value);
+            break;
+
+          case "number":
+            next = parse(el.value === "" ? null : Number(el.value));
+            break;
+
+          case "text":
+          default:
+            next = parse(el.value);
+        }
+
+        syncing = true;
+        try {
+          if (rodObj.value !== next) rodObj.value = next;
+        } finally {
+          syncing = false;
+        }
+      };
+
+      el.addEventListener(eventName, handler);
+      disposers.push(() => el.removeEventListener(eventName, handler));
+    }
+
+    // cleanup automatico
+    if (typeof rodObj.onDispose === "function") {
+      rodObj.onDispose(() => disposers.forEach(fn => fn()));
+    }
+
+    return () => disposers.forEach(fn => fn());
+  };
+
+
+  // input <-> signal (sugar)
+  JSswift.signalModel = function (inputEl, get, set, opts = {}) {
+    const r = JSswift.rodFromSignal(get, set);
+    return JSswift.rodModel(inputEl, r, opts);
+  };

package/src/32-lifecycle-helpers.js

@@ -0,0 +1,84 @@
+  // ===============================
+  // Lifecycle helpers
+  // ===============================
+
+  function cleanupNodeTree(node) {
+    if (!node) return;
+
+    const disposers = JSswift._cleanupRegistry.get(node);
+    if (disposers) {
+      for (const d of disposers) {
+        try { d(); } catch (e) { console.error("[cleanup] error:", e); }
+      }
+      JSswift._cleanupRegistry.delete(node);
+    }
+
+    if (node.childNodes && node.childNodes.length) {
+      for (const child of node.childNodes) {
+        cleanupNodeTree(child);
+      }
+    }
+  }
+
+  function toMountTargets(target) {
+    const toEl = (t) => (typeof t === "string" ? JSswift.dom.q(t) : t);
+    return Array.isArray(target) ? target.map(toEl).filter(Boolean) : [toEl(target)].filter(Boolean);
+  }
+
+  function normalizeMountContent(content) {
+    const nodes = [];
+    const disposers = [];
+
+    const add = (value) => {
+      if (value == null) return;
+
+      if (typeof value === "function") {
+        add(value());
+        return;
+      }
+
+      if (value && typeof value === "object" && "node" in value) {
+        if (typeof value.dispose === "function") disposers.push(value.dispose);
+        add(value.node);
+        return;
+      }
+
+      if (Array.isArray(value)) {
+        for (const item of value) add(item);
+        return;
+      }
+
+      if (typeof value === "string" || typeof value === "number") {
+        nodes.push(document.createTextNode(String(value)));
+        return;
+      }
+
+      if (value.nodeType) {
+        nodes.push(value);
+        return;
+      }
+
+      console.warn("[JSswift.mount] contenuto non supportato:", value);
+    };
+
+    add(content);
+    return { nodes, disposers };
+  }
+
+  function createOnceDisposer(disposers = [], label = "[JSswift.mount] dispose error:") {
+    let done = false;
+    return () => {
+      if (done) return;
+      done = true;
+      for (const d of disposers) {
+        try { d(); } catch (e) { console.error(label, e); }
+      }
+    };
+  }
+
+  function createComponentDisposer(disposers = [], userDispose = null) {
+    return createOnceDisposer([
+      ...(userDispose ? [userDispose] : []),
+      ...disposers
+    ], "[component] dispose error:");
+  }

package/src/32-lifecycle.js

@@ -0,0 +1,131 @@
+  // ===============================
+  // JSswift.mount (Node | array | string | function)
+  // ===============================
+  // ===============================
+  // JSswift.mount (target singolo o array) + component cleanup
+  // content può essere:
+  // - Node | array | string/number
+  // - function -> uno dei precedenti
+  // - { node, dispose }
+  // - function -> { node, dispose }  (component instance)
+  // ===============================
+  JSswift.mount = function (target, content, opts = {}) {
+    const targets = toMountTargets(target);
+
+    const clear = opts.clear ?? true;
+    const isMulti = targets.length > 1;
+
+    if (targets.length === 0) {
+      console.warn("[JSswift.mount] nessun target valido:", target);
+      return () => { };
+    }
+
+    const mounted = []; // [{ root, nodes, disposers }]
+
+    for (const root of targets) {
+      if (clear) {
+        while (root.firstChild) {
+          cleanupNodeTree(root.firstChild);
+          root.removeChild(root.firstChild);
+        }
+      }
+
+      // per multi-target: se non passi una function, cloneremo i nodi (ma NON possiamo clonare cleanup)
+      // quindi: consigliamo content come function quando mounti su più target.
+      const { nodes: rawNodes, disposers } = normalizeMountContent(content);
+
+      let nodes = rawNodes;
+
+      if (isMulti && typeof content !== "function") {
+        nodes = rawNodes.map(n => n.cloneNode(true));
+        if (disposers.length) {
+          console.warn("[JSswift.mount] multi-target con dispose: usa content come function per istanze separate.");
+        }
+      }
+
+      const disposeMounted = createOnceDisposer(disposers);
+
+      for (const n of nodes) root.appendChild(n);
+
+      mounted.push({ root, nodes, dispose: disposeMounted });
+
+      // registra cleanup automatico per ogni nodo root montato
+      for (const n of nodes) {
+        if (!n || !n.nodeType) continue;
+        JSswift._registerCleanup(n, disposeMounted);
+      }
+    }
+
+    // unmount: rimuove DOM e chiama cleanup
+    const unmount = () => {
+      for (const m of mounted) {
+        // remove nodes
+        for (const n of m.nodes) {
+          if (!n) continue;
+          cleanupNodeTree(n);
+          if (n.parentNode === m.root) m.root.removeChild(n);
+        }
+        m.dispose?.();
+      }
+    };
+
+    return unmount;
+  };
+
+  // ===============================
+  // JSswift.component (istanza con cleanup)
+  // ===============================
+  JSswift.component = function (renderFn) {
+    if (typeof renderFn !== "function") throw new Error("JSswift.component: renderFn must be a function");
+
+    // ritorna una factory: props -> { node(s), dispose }
+    return function ComponentInstance(props = {}) {
+      const disposers = [];
+
+      const ctx = {
+        onDispose(fn) {
+          if (typeof fn === "function") disposers.push(fn);
+        }
+      };
+
+      const out = renderFn(props, ctx);
+
+      // supporta:
+      // - Node / array / string/number
+      // - { node, dispose }
+      if (out && typeof out === "object" && "node" in out) {
+        return {
+          node: out.node,
+          dispose: createComponentDisposer(disposers, typeof out.dispose === "function" ? out.dispose : null)
+        };
+      }
+
+      return {
+        node: out,
+        dispose: createComponentDisposer(disposers)
+      };
+    };
+  };
+
+  // ===============================
+  // Auto cleanup observer (opt-in)
+  // ===============================
+  JSswift.enableAutoCleanup = function () {
+    if (JSswift._autoCleanupEnabled) return;
+    JSswift._autoCleanupEnabled = true;
+
+    const observer = new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        for (const node of m.removedNodes) {
+          cleanupNodeTree(node);
+        }
+      }
+    });
+
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+
+    JSswift._cleanupObserver = observer;
+  };