@jsswift/core 1.0.41

package/src/44-http.js

@@ -0,0 +1,157 @@
+  // ===============================
+  // HTTP (fetch wrapper)
+  // ===============================
+  const {
+    createReactiveState: createHttpReactiveState,
+    sleep,
+    isRetryable,
+    makeAbort,
+    normalizeRequest,
+    runHooks,
+    wrapResponse,
+    withJSON
+  } = JSswift._httpShared;
+  const JSswiftHttpSetting =
+    typeof globalThis !== "undefined" && globalThis.JSswift_setting
+      ? globalThis.JSswift_setting
+      : {};
+  const configHTTP = {
+    baseURL: JSswiftHttpSetting.http?.baseURL || "",
+    timeout: JSswiftHttpSetting.http?.timeout ?? 0, // ms, 0 = no timeout
+    retry: JSswiftHttpSetting.http?.retry || { attempts: 0, delay: 250, factor: 2 }, // attempts extra
+    headers: JSswiftHttpSetting.http?.headers || {},
+    credentials: JSswiftHttpSetting.http?.credentials, // "include" etc (optional)
+    debug: JSswiftHttpSetting.debug ?? false
+  };
+  const httpState = createHttpReactiveState(JSswift);
+  const now = () => (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now());
+
+  const hooksHTTP = {
+    beforeRequest: new Set(),  // (req) => req
+    afterResponse: new Set(),  // (res, req) => res
+    onError: new Set()         // (err, req) => void
+  };
+
+  async function coreFetch(req) {
+    // Auth integration: se esiste auth.fetch usa quello
+    const f = (JSswift.auth && typeof JSswift.auth.fetch === "function")
+      ? JSswift.auth.fetch.bind(JSswift.auth)
+      : fetch;
+    const init = {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      credentials: req.credentials,
+      signal: req.signal
+    };
+    return f(req.url, init);
+  }
+
+  async function request(input, init = {}) {
+    let req = normalizeRequest(configHTTP, input, init);
+
+    // hooksHTTP pre
+    req = await runHooks(hooksHTTP.beforeRequest, req);
+    const requestId = httpState.markStart(req);
+    const startAt = now();
+
+    const retryCfg = req.retry || { attempts: 0, delay: 250, factor: 2 };
+    const maxAttempts = Math.max(0, Number(retryCfg.attempts || 0));
+    let delay = Math.max(0, Number(retryCfg.delay || 0));
+    const factor = Math.max(1, Number(retryCfg.factor || 2));
+
+    let lastErr = null;
+    let lastRes = null;
+    let finalRes = null;
+    let finalErr = null;
+
+    try {
+      for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+        lastErr = null;
+        lastRes = null;
+
+        const { signal, cancel } = makeAbort(req.timeout, init.signal);
+        const effectiveReq = { ...req, signal };
+        const attemptAt = now();
+
+        try {
+          if (configHTTP.debug) console.log("[http.request]", effectiveReq.method, effectiveReq.url);
+
+          JSswift.perf?.inc("httpRequests");
+          JSswift.perf?.mark("http:req", { url: req.url, method: req.method });
+
+
+          const res = await coreFetch(effectiveReq);
+          lastRes = res;
+
+          // hooksHTTP post
+          const outRes = await runHooks(hooksHTTP.afterResponse, res, effectiveReq);
+          const dt = now() - attemptAt;
+
+          JSswift.perf?.tick("http:res", dt, { status: res.status, url: req.url });
+
+          // retryable status?
+          if (attempt < maxAttempts && isRetryable(null, outRes)) {
+            cancel();
+            await sleep(delay);
+            delay = Math.round(delay * factor);
+            continue;
+          }
+
+          cancel();
+          finalRes = outRes;
+          return wrapResponse(outRes, effectiveReq);
+
+        } catch (err) {
+          lastErr = err;
+          cancel();
+
+          // hooksHTTP error
+          for (const fn of hooksHTTP.onError) {
+            try { fn(err, effectiveReq); } catch { }
+          }
+
+          // retry?
+          if (attempt < maxAttempts && isRetryable(err, null)) {
+            await sleep(delay);
+            delay = Math.round(delay * factor);
+            continue;
+          }
+
+          finalErr = err;
+          throw err;
+        }
+      }
+    } finally {
+      const totalDt = now() - startAt;
+      httpState.markEnd(requestId, finalRes, finalErr, totalDt);
+    }
+
+    // fallback (non dovrebbe arrivare qui)
+    if (lastErr) throw lastErr;
+    return wrapResponse(lastRes, req);
+  }
+
+  // shortcuts
+  JSswift.http = {};
+  JSswift.http.request = request;
+  JSswift.http.state = () => httpState.state;
+  JSswift.http.get = (url, init) => request(url, { ...init, method: "GET" });
+  JSswift.http.del = (url, init) => request(url, { ...init, method: "DELETE" });
+  JSswift.http.post = (url, body, init) => withJSON(request, "POST", url, body, init);
+  JSswift.http.put = (url, body, init) => withJSON(request, "PUT", url, body, init);
+  JSswift.http.patch = (url, body, init) => withJSON(request, "PATCH", url, body, init);
+
+  JSswift.http.getJSON = async (url, init) => (await request(url, { ...init, method: "GET" })).jsonStrict();
+  JSswift.http.delJSON = async (url, init) => (await request(url, { ...init, method: "DELETE" })).jsonStrict();
+  JSswift.http.postJSON = async (url, body, init) => (await withJSON(request, "POST", url, body, init)).jsonStrict();
+  JSswift.http.putJSON = async (url, body, init) => (await withJSON(request, "PUT", url, body, init)).jsonStrict();
+  JSswift.http.patchJSON = async (url, body, init) => (await withJSON(request, "PATCH", url, body, init)).jsonStrict();
+
+  JSswift.http.onBefore = function (fn) { hooksHTTP.beforeRequest.add(fn); return () => hooksHTTP.beforeRequest.delete(fn); };
+  JSswift.http.onAfter = function (fn) { hooksHTTP.afterResponse.add(fn); return () => hooksHTTP.afterResponse.delete(fn); };
+  JSswift.http.onError = function (fn) { hooksHTTP.onError.add(fn); return () => hooksHTTP.onError.delete(fn); };
+
+  // shortcuts per browser global
+  window._http = JSswift.http;
+  // ===============================

package/src/45-route-hooks.js

@@ -0,0 +1,55 @@
+  // useRouter (hook-style)
+  // ===============================
+  JSswift.useRouter = function (ctx) {
+    const router = JSswift.router;
+
+    // nessun cleanup necessario ora, ma pronto per future estensioni
+    if (ctx && typeof ctx.onDispose === "function") {
+      // placeholder per future listener
+    }
+
+    return {
+      navigate: router.navigate,
+      back: () => history.back(),
+      forward: () => history.forward(),
+      get current() {
+        return router;
+      }
+    };
+  };
+  // ===============================
+  // useRoute (hook-style, reattivo)
+  // ===============================
+  JSswift.useRoute = function (ctx) {
+    const [getPath, setPath] = JSswift.reactive.signal("");
+    const [getParams, setParams] = JSswift.reactive.signal({});
+    const [getQuery, setQuery] = JSswift.reactive.signal({});
+    const [getHash, setHash] = JSswift.reactive.signal("");
+
+    // handler aggiornamento
+    const update = (routeCtx) => {
+      setPath(routeCtx.path || "");
+      setParams(routeCtx.params || {});
+      setQuery(routeCtx.query || {});
+      setHash(routeCtx.hash || "");
+    };
+
+    // subscribe router
+    const unsubscribe = JSswift.router.subscribe(update);
+
+    // cleanup automatico
+    if (ctx && typeof ctx.onDispose === "function") {
+      ctx.onDispose(unsubscribe);
+    }
+
+    return {
+      path: getPath,
+      params: getParams,
+      query: getQuery,
+      hash: getHash
+    };
+  };
+
+  // ===============================
+  // Permission-based rendering helpers
+  // ===============================

package/src/49-router-shared.js

@@ -0,0 +1,99 @@
+  // ===============================
+  // Router shared helpers
+  // ===============================
+  JSswift._routerShared = (() => {
+    function normalizePath(path) {
+      if (!path) return "/";
+      if (!path.startsWith("/")) path = "/" + path;
+      if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+      return path;
+    }
+
+    function stripBase(path, base = "") {
+      if (base && path.startsWith(base)) {
+        const next = path.slice(base.length) || "/";
+        return normalizePath(next);
+      }
+      return normalizePath(path);
+    }
+
+    function compilePattern(pattern) {
+      pattern = normalizePath(pattern);
+      const keys = [];
+      const regexStr = pattern
+        .replace(/([.+*?=^!${}()[\]|/\\])/g, "\\$1")
+        .replace(/\\\/:([A-Za-z0-9_]+)/g, (_, key) => {
+          keys.push(key);
+          return "\\/([^\\/]+)";
+        });
+      return {
+        pattern,
+        regex: new RegExp("^" + regexStr + "$"),
+        keys
+      };
+    }
+
+    function parseQuery(search) {
+      const query = {};
+      const params = new URLSearchParams(search || "");
+      params.forEach((value, key) => {
+        if (query[key] === undefined) query[key] = value;
+        else if (Array.isArray(query[key])) query[key].push(value);
+        else query[key] = [query[key], value];
+      });
+      return query;
+    }
+
+    function flattenRoutes(routes) {
+      const all = [];
+      for (const route of routes) {
+        all.push({ ...route, _parent: null });
+        if (route.children && route.children.length) {
+          for (const child of route.children) {
+            all.push({ ...child, _parent: route });
+          }
+        }
+      }
+      all.sort((a, b) => b.path.length - a.path.length);
+      return all;
+    }
+
+    function matchRoute(pathname, routes) {
+      const path = normalizePath(pathname);
+      const all = flattenRoutes(routes);
+
+      for (const route of all) {
+        const match = route._compiled.regex.exec(path);
+        if (!match) continue;
+
+        const params = {};
+        route._compiled.keys.forEach((key, index) => {
+          params[key] = decodeURIComponent(match[index + 1]);
+        });
+
+        return { route, params, parent: route._parent || null };
+      }
+      return null;
+    }
+
+    function pushHistoryEntry(history, ctx, limit = 50) {
+      history.push({
+        at: Date.now(),
+        path: ctx.path,
+        params: ctx.params,
+        query: ctx.query,
+        hash: ctx.hash
+      });
+      if (history.length > limit) history.shift();
+    }
+
+    return {
+      normalizePath,
+      stripBase,
+      compilePattern,
+      parseQuery,
+      flattenRoutes,
+      matchRoute,
+      pushHistoryEntry
+    };
+  })();

package/src/49a-ui-meta-shared.js

@@ -0,0 +1,116 @@
+  // ===============================
+  // UI meta shared helpers
+  // ===============================
+  JSswift._uiMetaShared = (() => {
+    function resolveDocComponents(_) {
+      return {
+        hasTabPanel: typeof _.TabPanel === "function",
+        Card: typeof _.Card === "function"
+          ? _.Card
+          : (...children) => _.div({ class: "cms-doc-card" }, ...children),
+        Chip: typeof _.Chip === "function"
+          ? _.Chip
+          : (_props, label) => _.span({ class: "cms-chip cms-chip-fallback" }, label)
+      };
+    }
+
+    function formatMetaValues(values) {
+      if (!values) return "—";
+      if (Array.isArray(values)) return values.join(" | ");
+      return String(values);
+    }
+
+    function renderMetaItem(_, item, Chip) {
+      return _.div({ class: "cms-doc-meta" },
+        _.div({ class: "cms-doc-meta-head" },
+          _.div({ class: "cms-doc-meta-name" }, item.name),
+          _.div({ class: "cms-doc-meta-types" },
+            ...(item.type
+              ? String(item.type).split("|").map((token) => Chip({ color: "secondary", dense: true, outline: true }, token))
+              : [_.span("—")])
+          )
+        ),
+        _.div({ class: "cms-doc-meta-grid" },
+          _.div({ class: "cms-doc-meta-block" },
+            _.div({ class: "cms-doc-meta-label" }, "Default"),
+            _.div({ class: "cms-doc-meta-value" }, item.default == null ? "—" : String(item.default))
+          ),
+          _.div({ class: "cms-doc-meta-block" },
+            _.div({ class: "cms-doc-meta-label" }, "Values"),
+            _.div({ class: "cms-doc-meta-value" }, formatMetaValues(item.values))
+          )
+        ),
+        _.div({ class: "cms-doc-meta-block" },
+          _.div({ class: "cms-doc-meta-label" }, "Description"),
+          _.div({ class: "cms-doc-meta-value" }, item.description || "—")
+        )
+      );
+    }
+
+    function renderTabGroupFallback(_, rows) {
+      return _.div({ class: "cms-doc-fallback" },
+        rows.map((row) => _.div({ class: "cms-doc-fallback-item" },
+          _.h4({ class: "cms-doc-fallback-title" }, row.label || row.name),
+          row.content
+        ))
+      );
+    }
+
+    function normalizeEventRows(_, events) {
+      if (!events) return [];
+      if (Array.isArray(events)) {
+        return events.map((eventItem) => ({
+          name: eventItem.name,
+          wrap: true,
+          label: eventItem.name,
+          content: _.div({ class: "cms-p-md" }, eventItem.description)
+        }));
+      }
+      return Object.entries(events).map(([key, value]) => ({
+        name: key,
+        wrap: true,
+        label: key,
+        content: _.div({ class: "cms-p-md" }, value)
+      }));
+    }
+
+    function normalizeSlotRows(_, slots) {
+      if (!slots) return [];
+      if (Array.isArray(slots)) {
+        return slots.map((slot) => ({
+          name: slot.name,
+          wrap: true,
+          label: slot.type,
+          content: slot.description
+        }));
+      }
+      return Object.entries(slots).map(([key, value]) => ({
+        name: key,
+        wrap: true,
+        label: key,
+        content: _.div({ class: "cms-doc-meta" },
+          _.div({ class: "cms-doc-meta-head" },
+            _.div({ class: "cms-doc-meta-name" }, key)
+          ),
+          _.div({ class: "cms-doc-meta-grid" },
+            _.div({ class: "cms-doc-meta-block" },
+              _.div({ class: "cms-doc-meta-label" }, "Type"),
+              _.div({ class: "cms-doc-meta-value" }, value.type || "—")
+            )
+          ),
+          _.div({ class: "cms-doc-meta-block" },
+            _.div({ class: "cms-doc-meta-label" }, "Description"),
+            _.div({ class: "cms-doc-meta-value" }, value.description || "—")
+          )
+        )
+      }));
+    }
+
+    return {
+      resolveDocComponents,
+      renderMetaItem,
+      renderTabGroupFallback,
+      normalizeEventRows,
+      normalizeSlotRows
+    };
+  })();

package/src/50-ui-meta.js

@@ -0,0 +1,189 @@
+  JSswift.ui = JSswift.ui || {};
+  JSswift.ui.meta = JSswift.ui.meta || {};
+
+  JSswift.ui.slot = function slot(value, opts = {}) {
+    const UI = JSswift.ui;
+    const {
+      as = "node",          // "node" | "text" | "icon"
+      wrap = "span",        // "span" | "text" | null
+      iconProps = null,     // props extra per UI.Icon
+      filter = true         // filtra null/false
+    } = opts;
+
+    const makeTextNode = (v) => document.createTextNode(String(v));
+    const makeSpan = (v) => _.span(String(v));
+
+    const normalizeOne = (v) => {
+      if (v == null || v === false) return null;
+
+      // function: IMPORTANT -> non eseguire qui (serve reattività)
+      if (typeof v === "function") return v;
+
+      // array: flatten
+      if (Array.isArray(v)) return v.flatMap(normalizeOne).filter(Boolean);
+
+      // DOM Node
+      if (v && typeof v === "object" && v.nodeType) return v;
+
+      // primitive
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+        const s = String(v);
+
+        if (as === "icon" && UI.Icon) {
+          // se vuoi: allow "tabler:plus" o simili
+          return UI.Icon(s, { class: "cms-slot-icon", ...(iconProps || {}) });
+        }
+
+        if (wrap === "text") return makeTextNode(s);
+        if (wrap === "span") return makeSpan(s);
+        return s; // lascia stringa nativa (se il tuo _h la gestisce)
+      }
+
+      // fallback: stringify
+      if (wrap === "text") return makeTextNode(v);
+      if (wrap === "span") return makeSpan(v);
+      return String(v);
+    };
+
+    const out = normalizeOne(value);
+    if (!filter) return out;
+
+    // out può essere null, function, node, string, oppure array
+    if (Array.isArray(out)) return out.filter(Boolean);
+    return out;
+  };
+  JSswift.ui.slots = function slots(...values) {
+    const out = [];
+    for (const v of values) {
+      const r = JSswift.ui.slot(v);
+      if (!r) continue;
+      if (Array.isArray(r)) out.push(...r);
+      else out.push(r);
+    }
+    return out;
+  };
+
+  // docTable genera una tabella di documentazione
+  JSswift.docTable = (name) => {
+    if (!JSswift.isDev()) return _.div(); // non fa niente in prod
+
+    const {
+      resolveDocComponents,
+      renderMetaItem,
+      renderTabGroupFallback,
+      normalizeEventRows,
+      normalizeSlotRows
+    } = JSswift._uiMetaShared;
+    const meta = JSswift.ui.meta?.[name];
+    if (!meta) return _.div({ class: "cms-muted" }, `Meta non trovata: ${name}`);
+    const { hasTabPanel, Card, Chip } = resolveDocComponents(_);
+
+    const list = {};
+    Object.entries(meta.props || {}).forEach(([k, v]) => {
+      const cat = v.category || "general";
+      if (!list[cat]) list[cat] = [];
+      list[cat].push({
+        name: k,
+        ...v
+      });
+    });
+    const propsTab = Object.keys(list).map((v) => {
+      const rows = list[v].map((p) => {
+        return {
+          name: p.name,
+          wrap: true,
+          label: p.name,
+          content: renderMetaItem(_, p, Chip)
+        };
+      });
+      return {
+        name: v, wrap: true, label: v, content: hasTabPanel ? _.TabPanel({
+          orientation: "vertical",
+          animated: true,
+          radius: "0 0 0 var(--cms-r-default)",
+          tabs: rows
+        }) : renderTabGroupFallback(_, rows)
+      };
+    });
+
+    const eventsRows = normalizeEventRows(_, meta.events);
+    const slotsRows = normalizeSlotRows(_, meta.slots);
+    const tabPanelModel = _.rod(null);
+    const taps = [];
+    if (slotsRows.length) taps.push({
+      name: "Slots",
+      wrap: true,
+      label: "Slots",
+      content: hasTabPanel ? _.TabPanel({
+        animated: true,
+        radius: "0 0 0 var(--cms-r-default)",
+        orientation: "vertical",
+        tabs: slotsRows
+      }) : renderTabGroupFallback(_, slotsRows)
+    });
+    if (propsTab.length) taps.push(...propsTab);
+    if (eventsRows.length) taps.push({
+      name: "Events",
+      wrap: true,
+      label: "Events",
+      content: hasTabPanel ? _.TabPanel({
+        animated: true,
+        radius: "0 0 0 var(--cms-r-default)",
+        orientation: "vertical",
+        tabs: eventsRows
+      }) : renderTabGroupFallback(_, eventsRows)
+    });
+    const first = "general";
+    taps.sort((a, b) => {
+      if (a.name === first) return -1;
+      if (b.name === first) return 1;
+      return a.name.localeCompare(b.name);
+    })
+    return Card({ class: "cms-doc-table" },
+      _.div({ class: "cms-doc-table-header" },
+        _.div({ class: "cms-doc-table-title" }, `_.${name}`),
+        meta.signature ? _.div({ class: "cms-doc-table-signature" }, String(meta.signature).replaceAll("UI.", "_.")) : null
+      ),
+      taps.length
+        ? _.h4({ class: "cms-doc-table-section-title" }, propsTab.length ? "Props" : "Documentation")
+        : _.p({ class: "cms-muted" }, "Nessuna documentazione strutturata disponibile."),
+      taps.length
+        ? (hasTabPanel ? _.TabPanel({
+          border: true,
+          animated: true,
+          orientation: "horizontal",
+          tabs: taps, model: tabPanelModel
+        }) : renderTabGroupFallback(_, taps))
+        : null,
+      meta.returns ? _.p({ class: "cms-muted", style: { marginTop: "14px" } }, `Returns: ${meta.returns}`) : null
+    );
+  };
+
+  JSswift.ui.inspect = (name) => console.log(JSswift.ui.meta?.[name] || "meta not found");
+
+  JSswift.ui.can = function (ctx, permOrRole, render, elseRender = null) {
+    const auth = JSswift.useAuth ? JSswift.useAuth(ctx) : JSswift.auth;
+    if (!auth) return typeof elseRender === "function" ? elseRender() : null;
+
+    const ok =
+      typeof permOrRole === "function"
+        ? !!permOrRole(auth)
+        : (auth.can?.(permOrRole) || auth.hasRole?.(permOrRole));
+
+    if (ok) return typeof render === "function" ? render() : render;
+    return typeof elseRender === "function" ? elseRender() : elseRender;
+  };
+
+  JSswift.ui.canAny = function (ctx, list, render, elseRender = null) {
+    const auth = JSswift.useAuth ? JSswift.useAuth(ctx) : JSswift.auth;
+    const ok = !!auth?.canAny?.(list);
+    return ok ? (typeof render === "function" ? render() : render)
+      : (typeof elseRender === "function" ? elseRender() : elseRender);
+  };
+
+  JSswift.ui.canAll = function (ctx, list, render, elseRender = null) {
+    const auth = JSswift.useAuth ? JSswift.useAuth(ctx) : JSswift.auth;
+    const ok = !!auth?.canAll?.(list);
+    return ok ? (typeof render === "function" ? render() : render)
+      : (typeof elseRender === "function" ? elseRender() : elseRender);
+  };

package/src/51-can.js

@@ -0,0 +1,20 @@
+  // ===============================
+  // Can component (hyperscript-friendly)
+  // ===============================
+  JSswift.Can = function Can(props, ctx) {
+    const auth = JSswift.useAuth ? JSswift.useAuth(ctx) : JSswift.auth;
+
+    const pred = () => {
+      if (!auth) return false;
+      if (props.when && typeof props.when === "function") return !!props.when(auth);
+      if (props.perm) return !!auth.can?.(props.perm);
+      if (props.role) return !!auth.hasRole?.(props.role);
+      if (props.any) return !!auth.canAny?.(props.any);
+      if (props.all) return !!auth.canAll?.(props.all);
+      return false;
+    };
+
+    return pred()
+      ? (typeof props.then === "function" ? props.then() : props.then ?? null)
+      : (typeof props.else === "function" ? props.else() : props.else ?? null);
+  };