@jsswift/core 1.0.41

package/src/42-plugins.js

@@ -0,0 +1,163 @@
+  // ===============================
+  // Plugin system (JSswift.usePlugin)
+  // ===============================
+  JSswift._plugins = new Set();
+
+  JSswift.usePlugin = function (plugin, options) {
+    if (!plugin) return;
+
+    // evita doppia installazione
+    if (JSswift._plugins.has(plugin)) {
+      if (JSswift.config?.debug) {
+        console.warn("[JSswift.usePlugin] plugin già installato:", plugin.name || plugin);
+      }
+      return;
+    }
+
+    // funzione-plugin
+    if (typeof plugin === "function") {
+      plugin(JSswift, options);
+      JSswift._plugins.add(plugin);
+      return;
+    }
+
+    // oggetto-plugin { install(app, opts) }
+    if (plugin && typeof plugin.install === "function") {
+      plugin.install(JSswift, options);
+      JSswift._plugins.add(plugin);
+      return;
+    }
+
+    console.warn("[JSswift.usePlugin] plugin non valido:", plugin);
+  };
+
+  //-- RESTA come esempio --
+  JSswift.plugins = JSswift.plugins || {};
+  JSswift.plugins.debug = {
+    install(app) {
+      app.config.debug = true;
+      console.log("[JSswift] Debug mode ON");
+    }
+  };
+
+  // ===============================
+  // Plugin Forms (validation + UX)
+  // ===============================
+  JSswift.plugins.forms = {
+    install(app) {
+      const forms = {};
+
+      app.forms = {
+        validate(formEl, rules = {}, opts = {}) {
+          if (typeof formEl === "string") formEl = app.dom.q(formEl);
+          if (!formEl || !formEl.querySelectorAll) {
+            console.warn("[forms.validate] form non valido:", formEl);
+            return null;
+          }
+
+          const options = {
+            mode: opts.mode || "input", // input | change | blur
+            showMessages: opts.showMessages ?? true,
+            submitGuard: opts.submitGuard ?? true,
+            errorClass: opts.errorClass || "is-invalid",
+            validClass: opts.validClass || "is-valid",
+            messageClass: opts.messageClass || "form-error"
+          };
+
+          const fieldState = {}; // name -> { getErr, setErr }
+
+          // setup fields
+          for (const [name, rule] of Object.entries(rules)) {
+            const els = formEl.querySelectorAll(`[name="${name}"]`);
+            if (!els.length) continue;
+
+            const [getErr, setErr] = app.reactive.signal(null);
+            fieldState[name] = { getErr, setErr, els };
+
+            // message node (uno per campo)
+            let msgNode = null;
+            if (options.showMessages) {
+              msgNode = document.createElement("div");
+              msgNode.className = options.messageClass;
+              els[els.length - 1].after(msgNode);
+            }
+
+            const validateValue = () => {
+              let value;
+              const el = els[0];
+
+              if (el.type === "checkbox") value = el.checked;
+              else if (el.type === "radio") {
+                const c = Array.from(els).find(r => r.checked);
+                value = c ? c.value : null;
+              } else value = el.value;
+
+              let res = true;
+              try {
+                res = rule(value);
+              } catch (e) {
+                res = e.message || "Errore di validazione";
+              }
+
+              const error = res === true ? null : (typeof res === "string" ? res : "Valore non valido");
+              setErr(error);
+              return !error;
+            };
+
+            // bind events
+            for (const el of els) {
+              el.addEventListener(options.mode, validateValue);
+            }
+
+            // reactive UI
+            app.reactive.effect(() => {
+              const err = getErr();
+              for (const el of els) {
+                el.classList.toggle(options.errorClass, !!err);
+                el.classList.toggle(options.validClass, !err);
+              }
+              if (msgNode) {
+                msgNode.textContent = err || "";
+                msgNode.style.display = err ? "block" : "none";
+              }
+            });
+
+            // initial check
+            validateValue();
+          }
+
+          // computed form validity
+          const isValid = app.store.computed(() => {
+            return Object.values(fieldState).every(f => !f.getErr());
+          });
+
+          // submit guard
+          const onSubmit = (e) => {
+            let ok = true;
+            for (const f of Object.values(fieldState)) {
+              const el = f.els[0];
+              if (el) el.dispatchEvent(new Event(options.mode, { bubbles: true }));
+              if (f.getErr()) ok = false;
+            }
+            if (!ok && options.submitGuard) {
+              e.preventDefault();
+              e.stopPropagation();
+            }
+          };
+
+          if (options.submitGuard) {
+            formEl.addEventListener("submit", onSubmit);
+          }
+
+          const dispose = () => {
+            if (options.submitGuard) {
+              formEl.removeEventListener("submit", onSubmit);
+            }
+          };
+
+          forms[formEl] = { isValid, dispose };
+          return { isValid, dispose };
+        }
+      };
+    }
+  };

package/src/42a-auth-shared.js

@@ -0,0 +1,148 @@
+  // ===============================
+  // Auth shared helpers
+  // ===============================
+  JSswift._authShared = (() => {
+    function createPermissionApi(getUser) {
+      const roles = () => getUser()?.roles || [];
+      const perms = () => getUser()?.permissions || [];
+
+      return {
+        roles,
+        perms,
+        hasRole: (role) => roles().includes(role),
+        can: (permission) => perms().includes(permission),
+        canAny: (list) => list.some((item) => roles().includes(item) || perms().includes(item)),
+        canAll: (list) => list.every((item) => roles().includes(item) || perms().includes(item))
+      };
+    }
+
+    function matchesProtectedPath(path, protectedList) {
+      return protectedList.some((entry) =>
+        typeof entry === "string"
+          ? path.startsWith(entry)
+          : entry instanceof RegExp
+            ? entry.test(path)
+            : false
+      );
+    }
+
+    function attachDevTools(app, auth) {
+      if (!app || !auth) return;
+
+      let tracing = false;
+
+      function safeNow() {
+        return Date.now();
+      }
+
+      function decodeJWT(token) {
+        if (!token || typeof token !== "string") return null;
+        const parts = token.split(".");
+        if (parts.length < 2) return null;
+        try {
+          const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+          const json = decodeURIComponent(
+            atob(b64).split("").map((char) => "%" + char.charCodeAt(0).toString(16).padStart(2, "0")).join("")
+          );
+          return JSON.parse(json);
+        } catch {
+          return null;
+        }
+      }
+
+      function getAuthState() {
+        if (typeof auth._getState === "function") {
+          const state = auth._getState();
+          return state && typeof state === "object"
+            ? state
+            : { user: auth.user?.() ?? null };
+        }
+        return { user: auth.user?.() ?? null };
+      }
+
+      function status() {
+        const state = getAuthState() || {};
+        const user = state.user ?? auth.user?.();
+        const name = user?.name || user?.email || user?.id || "anon";
+        const ok = !!auth.isAuth?.();
+        const expiresAt = state.expiresAt || null;
+        const left = expiresAt ? expiresAt - safeNow() : null;
+        return ok
+          ? `AUTH ✅ user=${name}${expiresAt ? ` expiresIn=${Math.round(left / 1000)}s` : ""}`
+          : `AUTH ❌ user=${name}`;
+      }
+
+      function inspect(label = "auth") {
+        const state = getAuthState() || {};
+        const user = state.user ?? auth.user?.();
+        const roles = user?.roles || [];
+        const perms = user?.permissions || [];
+        const accessToken = state.accessToken || null;
+        const refreshToken = state.refreshToken || null;
+        const jwt = accessToken ? decodeJWT(accessToken) : null;
+        const expiresAt = state.expiresAt || (jwt?.exp ? jwt.exp * 1000 : null);
+        const now = safeNow();
+        const expiresInMs = expiresAt ? (expiresAt - now) : null;
+
+        const info = {
+          label,
+          isAuth: !!auth.isAuth?.(),
+          user,
+          roles,
+          permissions: perms,
+          has: {
+            role: (role) => !!auth.hasRole?.(role),
+            can: (permission) => !!auth.can?.(permission)
+          },
+          token: {
+            hasAccess: !!accessToken,
+            hasRefresh: !!refreshToken,
+            expiresAt,
+            expiresInSec: expiresInMs == null ? null : Math.round(expiresInMs / 1000),
+            decodedJWT: jwt
+          }
+        };
+
+        console.groupCollapsed(`[JSswift.auth.inspect] ${label}`);
+        console.log("status:", status());
+        console.log(info);
+        if (expiresInMs != null) {
+          if (expiresInMs <= 0) console.warn("⚠️ Access token scaduto.");
+          else if (expiresInMs < 60_000) console.warn("⚠️ Access token in scadenza (<60s).");
+        }
+        console.groupEnd();
+
+        return info;
+      }
+
+      function trace(on = true) {
+        tracing = !!on;
+        console.log("[JSswift.auth.trace]", tracing ? "ON" : "OFF");
+      }
+
+      if (typeof auth.fetch === "function" && !auth._fetchWrapped) {
+        const originalFetch = auth.fetch.bind(auth);
+        auth.fetch = async (...args) => {
+          const res = await originalFetch(...args);
+          if (tracing) {
+            try {
+              console.log("[auth.fetch]", res.status, args[0]);
+            } catch { }
+          }
+          return res;
+        };
+        auth._fetchWrapped = true;
+      }
+
+      auth.decodeJWT = decodeJWT;
+      auth.status = status;
+      auth.inspect = inspect;
+      auth.trace = trace;
+    }
+
+    return {
+      createPermissionApi,
+      matchesProtectedPath,
+      attachDevTools
+    };
+  })();

package/src/43-auth.js

@@ -0,0 +1,171 @@
+  // ===============================
+  // Auth Plugin (store + router guard)
+  // Auth Plugin + Roles / Permissions
+  // Auth Plugin (async + refresh token)
+  // ===============================
+  JSswift.plugins.auth = {
+    install(app, opts = {}) {
+      const {
+        createPermissionApi,
+        matchesProtectedPath,
+        attachDevTools
+      } = JSswift._authShared;
+      const options = {
+        key: opts.key || "auth",
+        loginRoute: opts.loginRoute || "/login",
+        protected: opts.protected || [],
+        autoRedirect: opts.autoRedirect ?? true,
+
+        // async config
+        endpoints: opts.endpoints || {
+          login: "/api/login",
+          refresh: "/api/refresh",
+          logout: "/api/logout"
+        },
+
+        fetchOptions: opts.fetchOptions || {},
+        tokenHeader: opts.tokenHeader || "Authorization",
+        tokenPrefix: opts.tokenPrefix || "Bearer ",
+
+        refreshMargin: opts.refreshMargin || 30_000 // ms prima della scadenza
+      };
+
+      // ---------- STORE ----------
+      const [getAuth, setAuth] = app.store.signal(options.key, null);
+
+      const getUser = () => getAuth()?.user || null;
+      const isAuth = () => !!getAuth()?.accessToken;
+
+      // ---------- ROLES / PERMS ----------
+      const {
+        hasRole,
+        can,
+        canAny,
+        canAll
+      } = createPermissionApi(getUser);
+
+      // ---------- INTERNAL STATE ----------
+      let refreshing = false;
+      let refreshQueue = [];
+
+      // ---------- HELPERS ----------
+      function needsRefresh() {
+        const a = getAuth();
+        if (!a?.expiresAt) return false;
+        return Date.now() > (a.expiresAt - options.refreshMargin);
+      }
+
+      async function doRefresh() {
+        if (refreshing) {
+          return new Promise((res, rej) => refreshQueue.push({ res, rej }));
+        }
+
+        refreshing = true;
+
+        try {
+          const r = await fetch(options.endpoints.refresh, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken: getAuth()?.refreshToken })
+          });
+
+          if (!r.ok) throw new Error("Refresh failed");
+
+          const data = await r.json();
+          setAuth({ ...getAuth(), ...data });
+
+          refreshQueue.forEach(q => q.res(true));
+          refreshQueue = [];
+          return true;
+
+        } catch (e) {
+          refreshQueue.forEach(q => q.rej(e));
+          refreshQueue = [];
+          setAuth(null);
+          if (options.autoRedirect) app.router.navigate(options.loginRoute);
+          throw e;
+
+        } finally {
+          refreshing = false;
+        }
+      }
+
+      // ---------- ASYNC AUTH API ----------
+      async function loginAsync(credentials) {
+        const r = await fetch(options.endpoints.login, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(credentials)
+        });
+
+        if (!r.ok) throw new Error("Login failed");
+        const data = await r.json();
+        setAuth(data);
+        return data;
+      }
+
+      async function logoutAsync() {
+        try {
+          await fetch(options.endpoints.logout, { method: "POST" });
+        } catch { }
+        setAuth(null);
+        if (options.autoRedirect) app.router.navigate(options.loginRoute);
+      }
+
+      // ---------- AUTH FETCH ----------
+      async function authFetch(url, opts = {}) {
+        if (needsRefresh()) await doRefresh();
+
+        const a = getAuth();
+        const headers = new Headers(opts.headers || {});
+        if (a?.accessToken) {
+          headers.set(options.tokenHeader, options.tokenPrefix + a.accessToken);
+        }
+
+        const r = await fetch(url, { ...options.fetchOptions, ...opts, headers });
+
+        if (r.status === 401 && getAuth()?.refreshToken && !opts._authRetried) {
+          await doRefresh();
+          return authFetch(url, { ...opts, _authRetried: true });
+        }
+
+        return r;
+      }
+
+      // ---------- ROUTER GUARD ----------
+      app.router.beforeEach((ctx) => {
+        const path = ctx.path;
+        const protectedMatch = matchesProtectedPath(path, options.protected);
+
+        if (protectedMatch && !isAuth()) {
+          return options.loginRoute;
+        }
+        return true;
+      });
+
+      // ---------- PUBLIC API ----------
+      app.auth = {
+        user: getUser,
+        isAuth,
+        hasRole,
+        can,
+        canAny,
+        canAll,
+        loginAsync,
+        logoutAsync,
+        fetch: authFetch,
+        _getState: getAuth
+      };
+
+      // ---------- HOOK ----------
+      app.useAuth = function (ctx) {
+        if (ctx && typeof ctx.onDispose === "function") {
+          // future-proof
+        }
+
+        return app.auth;
+      };
+
+      attachDevTools(JSswift, app.auth);
+    }
+  };

package/src/43a-http-shared.js

@@ -0,0 +1,234 @@
+  // ===============================
+  // HTTP shared helpers
+  // ===============================
+  JSswift._httpShared = (() => {
+    function createReactiveState(JSswift) {
+      const reactive = JSswift.reactive;
+      const [getInFlight, setInFlight] = reactive.signal(0);
+      const [getStatus, setStatus] = reactive.signal("idle");
+      const [getLastRequest, setLastRequest] = reactive.signal(null);
+      const [getLastResponse, setLastResponse] = reactive.signal(null);
+      const [getLastError, setLastError] = reactive.signal(null);
+      const [getLastDuration, setLastDuration] = reactive.signal(0);
+      const [getLastUpdated, setLastUpdated] = reactive.signal(0);
+      let lastStartId = 0;
+
+      function markStart(req) {
+        const id = ++lastStartId;
+        const ts = Date.now();
+        setInFlight(getInFlight() + 1);
+        setStatus("pending");
+        setLastError(null);
+        setLastResponse(null);
+        setLastRequest({
+          id,
+          url: req.url,
+          method: req.method,
+          meta: req.meta,
+          timeout: req.timeout,
+          retry: req.retry,
+          startedAt: ts
+        });
+        setLastUpdated(ts);
+        return id;
+      }
+
+      function markEnd(id, res, err, durationMs) {
+        const ts = Date.now();
+        setInFlight(Math.max(0, getInFlight() - 1));
+        if (id === lastStartId) {
+          if (err) {
+            setStatus("error");
+            setLastError(err);
+            setLastResponse(null);
+          } else if (res) {
+            setStatus("success");
+            setLastError(null);
+            setLastResponse({
+              id,
+              status: res.status,
+              ok: res.ok,
+              headers: res.headers,
+              url: res.url,
+              receivedAt: ts,
+              raw: res
+            });
+          } else {
+            setStatus("idle");
+            setLastError(null);
+            setLastResponse(null);
+          }
+          setLastDuration(Math.max(0, Number(durationMs || 0)));
+        }
+        setLastUpdated(ts);
+      }
+
+      const state = {
+        inFlight: getInFlight,
+        status: getStatus,
+        isLoading: JSswift.store?.computed
+          ? JSswift.store.computed(() => getInFlight() > 0)
+          : () => getInFlight() > 0,
+        lastRequest: getLastRequest,
+        lastResponse: getLastResponse,
+        lastError: getLastError,
+        lastDuration: getLastDuration,
+        lastUpdated: getLastUpdated,
+        reset() {
+          setInFlight(0);
+          setStatus("idle");
+          setLastRequest(null);
+          setLastResponse(null);
+          setLastError(null);
+          setLastDuration(0);
+          setLastUpdated(Date.now());
+        }
+      };
+
+      return { state, markStart, markEnd };
+    }
+
+    function joinURL(base, path) {
+      if (!base) return path;
+      if (/^https?:\/\//i.test(path)) return path;
+      const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+      const normalizedPath = path.startsWith("/") ? path : "/" + path;
+      return normalizedBase + normalizedPath;
+    }
+
+    function sleep(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    function isRetryable(err, res) {
+      if (err) return true;
+      if (!res) return false;
+      return res.status === 429 || (res.status >= 500 && res.status <= 599);
+    }
+
+    function makeAbort(timeoutMs, externalSignal) {
+      if (!timeoutMs && !externalSignal) return { signal: undefined, cancel: () => { } };
+
+      const controller = new AbortController();
+      const signal = controller.signal;
+
+      let timeoutId = null;
+      if (timeoutMs > 0) {
+        timeoutId = setTimeout(() => controller.abort(new Error("timeout")), timeoutMs);
+      }
+
+      const onAbort = () => controller.abort(externalSignal.reason || new Error("aborted"));
+      if (externalSignal) {
+        if (externalSignal.aborted) onAbort();
+        else externalSignal.addEventListener("abort", onAbort, { once: true });
+      }
+
+      const cancel = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        if (externalSignal) externalSignal.removeEventListener?.("abort", onAbort);
+      };
+
+      return { signal, cancel };
+    }
+
+    function normalizeRequest(configHTTP, input, init = {}) {
+      const url = typeof input === "string" ? joinURL(configHTTP.baseURL, input) : input;
+      const method = (init.method || "GET").toUpperCase();
+      const headers = new Headers(configHTTP.headers);
+      if (init.headers) new Headers(init.headers).forEach((value, key) => headers.set(key, value));
+
+      return {
+        url,
+        method,
+        headers,
+        body: init.body,
+        credentials: init.credentials ?? configHTTP.credentials,
+        signal: init.signal,
+        timeout: init.timeout ?? configHTTP.timeout,
+        retry: init.retry ?? configHTTP.retry,
+        meta: init.meta || {}
+      };
+    }
+
+    async function runHooks(set, ...args) {
+      let current = args[0];
+      for (const fn of set) {
+        current = (await fn(current, ...args.slice(1))) ?? current;
+      }
+      return current;
+    }
+
+    function wrapResponse(res, req) {
+      return {
+        ok: res.ok,
+        status: res.status,
+        headers: res.headers,
+        raw: res,
+        req,
+
+        async json() {
+          let data = null;
+          let error = null;
+          try { data = await res.json(); } catch { data = null; }
+          if (!res.ok) error = data ?? { status: res.status };
+          return { data, error, ok: res.ok, status: res.status };
+        },
+
+        async jsonStrict() {
+          const { data, error } = await this.json();
+          if (error) {
+            const e = new Error(`HTTP error ${res.status} ${req?.method || ""} ${req?.url || ""}`.trim());
+            e.status = res.status;
+            e.data = data;
+            e.req = {
+              url: req?.url,
+              method: req?.method,
+              meta: req?.meta
+            };
+            throw e;
+          }
+          return { data, ok: true, status: res.status };
+        },
+
+        async text() {
+          let text = "";
+          try { text = await res.text(); } catch { }
+          return { text, ok: res.ok, status: res.status };
+        },
+
+        async textStrict() {
+          const out = await this.text();
+          if (!out.ok) {
+            const e = new Error("HTTP error " + res.status);
+            e.status = res.status;
+            e.text = out.text;
+            throw e;
+          }
+          return out;
+        }
+      };
+    }
+
+    function withJSON(request, method, url, body, init = {}) {
+      const headers = new Headers(init.headers || {});
+      if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+      return request(url, {
+        ...init,
+        method,
+        headers,
+        body: body == null ? undefined : JSON.stringify(body)
+      });
+    }
+
+    return {
+      createReactiveState,
+      joinURL,
+      sleep,
+      isRetryable,
+      makeAbort,
+      normalizeRequest,
+      runHooks,
+      wrapResponse,
+      withJSON
+    };
+  })();