vitral 0.4.0 → 0.5.0

package/dist/angular.d.ts

@@ -1,6 +1,6 @@
 import { InjectionToken, Type, ApplicationConfig, Signal, Provider, EnvironmentProviders } from '@angular/core';
-import { R as RemoteContext, P as Props, a as RemoteModule, S as Shared, V as VitralConfig } from './types-CA2p9KHC.js';
-export { e as events } from './events-Dkpkw_Sv.js';
+import { R as RemoteContext, P as Props, a as RemoteModule, S as Shared, V as VitralConfig } from './types-DUtcF3HO.js';
+export { e as events } from './events-0rxFlWJJ.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import './errors-kjBv6IH_.js';
 

package/dist/angular.js

@@ -1,7 +1,7 @@
 import {
   defineVitralElement
-} from "./chunk-BCC25ANK.js";
-import "./chunk-W6322KGP.js";
+} from "./chunk-K6EG7DMO.js";
+import "./chunk-4Z77XNBR.js";
 import {
   defineRemote,
   events,
@@ -9,11 +9,11 @@ import {
   navigate,
   same,
   shared
-} from "./chunk-WD4CDGDZ.js";
+} from "./chunk-KZBH5MPD.js";
 import {
   configure
-} from "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";

package/dist/auto.js

@@ -1,10 +1,10 @@
 import {
   defineVitralElement
-} from "./chunk-BCC25ANK.js";
-import "./chunk-W6322KGP.js";
-import "./chunk-WD4CDGDZ.js";
-import "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-K6EG7DMO.js";
+import "./chunk-4Z77XNBR.js";
+import "./chunk-KZBH5MPD.js";
+import "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";

package/dist/{chunk-W6322KGP.js → chunk-4Z77XNBR.js}

@@ -1,10 +1,10 @@
 import {
   createSlot
-} from "./chunk-WD4CDGDZ.js";
+} from "./chunk-KZBH5MPD.js";
 import {
   preload,
   registerSrc
-} from "./chunk-EMSB2NVX.js";
+} from "./chunk-5JNV45BB.js";
 
 // src/core/host-slot.ts
 var noop = () => {

package/dist/{chunk-EMSB2NVX.js → chunk-5JNV45BB.js}

@@ -1,6 +1,6 @@
 import {
   prefetchCss
-} from "./chunk-6EX5KYT5.js";
+} from "./chunk-KU6HF2EW.js";
 import {
   absolute,
   addLink,
@@ -79,7 +79,7 @@ function loadRemote(name) {
   return load(name).then((r) => r.module);
 }
 function loadModule(name) {
-  return import("./expose-OVWTPHH5.js").then((m) => m.resolveModule(name, (n) => loadFile(n))).catch(fail);
+  return import("./expose-IAKYHJXF.js").then((m) => m.resolveModule(name, (n) => loadFile(n))).catch(fail);
 }
 function preload(name) {
   load(name).catch(() => {
@@ -88,12 +88,12 @@ function preload(name) {
 var paths;
 function load(name, isolate, priority) {
   const file = (n) => loadFile(n, isolate, priority);
-  return (protocol().entry(name) || !name.includes("/") ? file(name).then((r) => mountable(name, r)) : import("./expose-OVWTPHH5.js").then((m) => m.resolveTarget(name, file))).catch(fail);
+  return (protocol().entry(name) || !name.includes("/") ? file(name).then((r) => mountable(name, r)) : import("./expose-IAKYHJXF.js").then((m) => m.resolveTarget(name, file))).catch(fail);
 }
 function loadFile(name, isolate, priority) {
   const p = protocol();
   return p.load(name, async () => {
-    paths ??= import("./sri-M7ZRU57G.js").catch(() => null);
+    paths ??= import("./sri-576GTDIA.js").catch(() => null);
     let resolved;
     try {
       await p.pending();

package/dist/{chunk-IH3ZT3QU.js → chunk-C3QOBAUE.js}

@@ -1,6 +1,6 @@
 import {
   mountable
-} from "./chunk-EMSB2NVX.js";
+} from "./chunk-5JNV45BB.js";
 import {
   RemoteError
 } from "./chunk-463H6B56.js";

package/dist/chunk-DAESKNQ6.js

@@ -0,0 +1,207 @@
+// src/harness.ts
+var CONTRACT_SCHEMA = "https://joaogabriel15.github.io/vitral/schema/vitral-contract.json";
+function encode(value, seen = /* @__PURE__ */ new Set()) {
+  if (typeof value === "function") return { $fn: true };
+  if (value === void 0 || value === null || typeof value !== "object") {
+    return typeof value === "bigint" || typeof value === "symbol" ? { $unknown: typeof value } : value;
+  }
+  if (value instanceof Date) return { $date: value.toISOString() };
+  if (seen.has(value)) return { $unknown: "circular" };
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) return { $unknown: proto?.constructor?.name ?? "Object" };
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((v) => encode(v, seen) ?? null);
+    const out = {};
+    for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = encode(v, seen);
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function decode(value, fn = () => () => void 0, path = "") {
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v2, i) => decode(v2, fn, `${path}[${i}]`));
+  const v = value;
+  if (v.$fn === true) return fn(path);
+  if (typeof v.$date === "string") return new Date(v.$date);
+  if (typeof v.$unknown === "string") return void 0;
+  return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, decode(x, fn, path ? `${path}.${k}` : k)]));
+}
+async function harness(mod, options) {
+  const remote = typeof mod.mount === "function" ? mod : mod.default;
+  if (typeof remote?.mount !== "function") throw new Error("[vitral] o m\xF3dulo n\xE3o exporta mount()");
+  const name = options.name ?? "remote";
+  const target = options.target ?? document.body.appendChild(document.createElement("div"));
+  const shadowRoot = options.shadow ? target.attachShadow({ mode: "open" }) : null;
+  const el = document.createElement("div");
+  el.setAttribute("data-vitral-root", name);
+  (shadowRoot ?? target).appendChild(el);
+  const portal = shadowRoot ? shadowRoot.appendChild(document.createElement("div")) : document.body;
+  const errors = [];
+  const emitted = [];
+  const navigations = [];
+  const handlers = /* @__PURE__ */ new Map();
+  const last = new Map(Object.entries(options.last ?? {}));
+  const dispatch = (type, payload) => {
+    last.set(type, payload);
+    for (const h of [...handlers.get(type) ?? []]) {
+      try {
+        h(payload);
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+  };
+  const events = {
+    emit(type, payload) {
+      emitted.push({ type, payload });
+      dispatch(type, payload);
+    },
+    on(type, handler) {
+      let set = handlers.get(type);
+      if (!set) handlers.set(type, set = /* @__PURE__ */ new Set());
+      set.add(handler);
+      return () => set.delete(handler);
+    },
+    last: (type) => last.get(type)
+  };
+  const activate = /* @__PURE__ */ new Set();
+  const deactivate = /* @__PURE__ */ new Set();
+  const hook = (set) => (fn) => (set.add(fn), () => set.delete(fn));
+  const ctx = {
+    name,
+    baseUrl: typeof location !== "undefined" ? new URL(".", location.href).href : "http://localhost/",
+    events,
+    shadowRoot,
+    portalContainer: portal,
+    customElements,
+    reportError: (e) => errors.push(e),
+    navigate: (url, opts) => navigations.push({ url, options: opts }),
+    protocol: 1,
+    onActivate: hook(activate),
+    onDeactivate: hook(deactivate),
+    shared: memoryShared(options.shared ?? {}),
+    ...options.ctx
+  };
+  const mounted = await remote.mount(el, options.props, ctx);
+  let alive = true;
+  return {
+    el,
+    ctx,
+    events: emitted,
+    errors,
+    navigations,
+    listens: () => [...handlers].filter(([, s]) => s.size).map(([t]) => t),
+    emit: dispatch,
+    update(props) {
+      if (alive) mounted.update?.(props);
+    },
+    activate: () => activate.forEach((f) => f()),
+    deactivate: () => deactivate.forEach((f) => f()),
+    unmount() {
+      if (!alive) return;
+      alive = false;
+      try {
+        mounted.unmount();
+      } finally {
+        el.remove();
+        if (!options.target) target.remove();
+      }
+    }
+  };
+}
+function memoryShared(initial) {
+  const values = new Map(Object.entries(initial));
+  const subs = /* @__PURE__ */ new Map();
+  const handle = (key) => {
+    const set = (v) => {
+      values.set(key, v);
+      for (const fn of [...subs.get(key) ?? []]) fn(v);
+    };
+    return {
+      key,
+      get: () => values.get(key),
+      set,
+      update: (fn) => set(fn(values.get(key))),
+      subscribe(fn) {
+        fn(values.get(key));
+        let s = subs.get(key);
+        if (!s) subs.set(key, s = /* @__PURE__ */ new Set());
+        s.add(fn);
+        return () => s.delete(fn);
+      }
+    };
+  };
+  const api = handle;
+  api.provide = ((key, value) => {
+    if (!values.has(key)) values.set(key, value);
+    return handle(key);
+  });
+  api.batch = (fn) => fn();
+  return api;
+}
+var message = (e) => String(e?.message ?? e);
+async function verify(contract, mod, options = {}) {
+  const failures = [];
+  const warnings = [];
+  const pause = () => new Promise((r) => setTimeout(r, options.wait ?? 0));
+  const cases = contract.cases ?? [];
+  for (const [i, c] of cases.entries()) {
+    const at = `caso ${i + 1}`;
+    const fail = (msg) => failures.push(`${at}: ${msg}`);
+    let h;
+    try {
+      h = await harness(mod, {
+        name: contract.remote,
+        props: decode(c.props),
+        shared: decode(c.shared ?? {}),
+        last: decode(c.last ?? {})
+      });
+    } catch (e) {
+      fail(`erro no mount: ${message(e)}`);
+      continue;
+    }
+    await pause();
+    for (const [j, u] of (c.updates ?? []).entries()) {
+      try {
+        h.update(decode(u));
+      } catch (e) {
+        fail(`erro no update ${j + 1}: ${message(e)}`);
+      }
+    }
+    if (c.updates?.length) await pause();
+    const deaf = /* @__PURE__ */ new Set();
+    for (const input of c.inputs ?? []) {
+      if (!h.listens().includes(input.type)) {
+        if (!deaf.has(input.type)) warnings.push(`${at}: o host emite "${input.type}" e o remote n\xE3o escuta mais`);
+        deaf.add(input.type);
+        continue;
+      }
+      h.emit(input.type, decode(input.payload));
+    }
+    await pause();
+    const seen = new Set(h.events.map((e) => e.type));
+    for (const e of c.emits ?? []) {
+      if (seen.has(e.type)) continue;
+      if (e.phase !== "later") fail(`o host escuta "${e.type}" e o remote n\xE3o emitiu (na grava\xE7\xE3o saiu no ${e.phase})`);
+      else if (!options.sources) warnings.push(`${at}: "${e.type}" sai depois do mount; sem o c\xF3digo do remote, n\xE3o deu para conferir`);
+      else if (!options.sources.some((s) => s.includes(e.type))) fail(`o host escuta "${e.type}" e o c\xF3digo do remote n\xE3o tem mais esse evento`);
+    }
+    try {
+      h.unmount();
+    } catch (e) {
+      fail(`erro no unmount: ${message(e)}`);
+    }
+    for (const e of h.errors) fail(`erro reportado: ${message(e)}`);
+  }
+  if (!cases.length) warnings.push("contrato sem casos");
+  return { cases: cases.length, failures, warnings };
+}
+
+export {
+  CONTRACT_SCHEMA,
+  encode,
+  harness,
+  verify
+};

package/dist/{chunk-BCC25ANK.js → chunk-K6EG7DMO.js}

@@ -1,16 +1,16 @@
 import {
   hostSlot,
   timings
-} from "./chunk-W6322KGP.js";
+} from "./chunk-4Z77XNBR.js";
 import {
   defineRemote,
   memoSelect,
   same,
   shared
-} from "./chunk-WD4CDGDZ.js";
+} from "./chunk-KZBH5MPD.js";
 import {
   registerSrc
-} from "./chunk-EMSB2NVX.js";
+} from "./chunk-5JNV45BB.js";
 
 // src/element.ts
 var Base = typeof HTMLElement === "undefined" ? class {
@@ -40,7 +40,7 @@ var VitralRemoteElement = class extends Base {
     if (!name) return;
     if (this.hasAttribute("props") && !Object.keys(this.#props).length) this.#props = parseProps(this.getAttribute("props"));
     const keep = this.getAttribute("keep-alive");
-    this.#slot = hostSlot(this, {
+    const options = {
       name,
       props: this.#props,
       isolate: this.getAttribute("isolate") || void 0,
@@ -66,7 +66,10 @@ var VitralRemoteElement = class extends Base {
         if (status === "ready") this.dispatchEvent(new CustomEvent("vitral-ready", { bubbles: true, detail: { timings: timings(name) } }));
         if (status === "error") this.dispatchEvent(new CustomEvent("vitral-error", { bubbles: true, detail: { error } }));
       }
-    });
+    };
+    const ssr = true ? this.querySelector(":scope>[data-vitral-ssr]") : null;
+    if (ssr) import("./hydrate-YVZDJ2V7.js").then((m) => this.isConnected && !this.#slot && (this.#slot = m.hydrateSlot(this, ssr, { ...options, props: this.#props })));
+    else this.#slot = hostSlot(this, options);
   }
   /**
    * Nome para montar. `src` em atributo é registrado sem entrar na allowlist:

package/dist/{chunk-6EX5KYT5.js → chunk-KU6HF2EW.js}

@@ -23,11 +23,11 @@ function fetchCssText(href, integrity, priority) {
   return p;
 }
 function prefetchCss(r, shadow, priority = "auto") {
-  if (shadow && adopts()) import("./shadow-PVSETNMZ.js").then((m) => m.prefetch(r, priority), noop);
+  if (shadow && adopts()) import("./shadow-S4SKHTA7.js").then((m) => m.prefetch(r, priority), noop);
   else for (const href of r.css) if (!document.querySelector(`link[href="${href}"]`)) addLink("preload", href, { as: "style", integrity: r.sri?.[href] ?? "", fetchPriority: priority });
 }
 function injectStyles(r, shadow, make, styles) {
-  return shadow ? import("./shadow-PVSETNMZ.js").then((m) => m.attachShadowRoot(shadow, make, r, protocol().settings().styles, styles)) : injectCss(r.css, null, r.sri).then(() => [noop]);
+  return shadow ? import("./shadow-S4SKHTA7.js").then((m) => m.attachShadowRoot(shadow, make, r, protocol().settings().styles, styles)) : injectCss(r.css, null, r.sri).then(() => [noop]);
 }
 function injectCss(urls, root, sri = {}) {
   const owner = root ?? document;

package/dist/{chunk-WD4CDGDZ.js → chunk-KZBH5MPD.js}

@@ -3,10 +3,10 @@ import {
   loadFile,
   registerSrc,
   resolveEntry
-} from "./chunk-EMSB2NVX.js";
+} from "./chunk-5JNV45BB.js";
 import {
   injectStyles
-} from "./chunk-6EX5KYT5.js";
+} from "./chunk-KU6HF2EW.js";
 import {
   metric
 } from "./chunk-TW7KYJQ6.js";
@@ -119,7 +119,7 @@ var noop = () => {
 async function checkUpdates() {
   const p = protocol();
   const found = [];
-  const { splitName } = await import("./expose-OVWTPHH5.js");
+  const { splitName } = await import("./expose-IAKYHJXF.js");
   const remotes = /* @__PURE__ */ new Map();
   for (const name of live.keys()) {
     const root = splitName(name)[0];
@@ -163,14 +163,11 @@ function setFrameMounter(mounter) {
 async function mountOnce(target, name, props, options) {
   const p = protocol();
   await p.pending();
-  if ((options.isolate ?? registered(name)?.isolate ?? p.settings().isolate) === "iframe") {
-    if (!frames) throw report(new RemoteError("MOUNT_FAILED", name, 'isolate="iframe" precisa de enableIframe(), de vitral/iframe'));
-    return frames(target, name, props, options).catch(fail);
-  }
-  const { module: mod, ...resolved } = await load(name, options.isolate, options.priority);
+  const isolate = options.isolate ?? registered(name)?.isolate ?? p.settings().isolate;
+  if (isolate === "iframe") return (frames ?? (await import("./reframe-LQL4DZYP.js")).noFrames)(target, name, props, options).catch(fail);
+  const { module: mod, ...resolved } = await (isolate == "reframe" ? (await import("./reframe-LQL4DZYP.js")).load : load)(name, isolate, options.priority);
   const untrack = track(name, resolved);
   ctxHooks.watch?.(name);
-  const isolate = options.isolate ?? resolved.isolate ?? protocol().settings().isolate;
   const label = resolved.name ?? name;
   const make = (options2) => {
     const el2 = document.createElement("div", options2);
@@ -182,7 +179,7 @@ async function mountOnce(target, name, props, options) {
   let t = performance.now();
   const [release, portal = document.body, shadowRoot = null, registry = customElements, el = target.appendChild(make())] = await injectStyles(
     resolved,
-    isolate === "shadow" && target,
+    isolate > "q" && target,
     make,
     options.styles
   );
@@ -203,7 +200,7 @@ async function mountOnce(target, name, props, options) {
       else console.error(err);
     },
     navigate,
-    protocol: protocol().protocol,
+    protocol: p.protocol,
     onActivate: on("vitral:activate"),
     onDeactivate: on("vitral:deactivate")
   };
@@ -611,13 +608,17 @@ function serializeShared(values) {
 
 export {
   events,
+  scopedEvents,
   navigate,
   track,
   refresh,
+  refreshable,
   checkUpdates,
   watchUpdates,
   mountRemote,
   setFrameMounter,
+  mountOnce,
+  registered,
   createSlot,
   defineRemote,
   html,

package/dist/chunk-NZEQGRBL.js

@@ -0,0 +1,93 @@
+// src/dict.ts
+var VARY = "Accept-Encoding, Available-Dictionary";
+var HASH = /-[\w-]{8}(\.[a-z]+)$/;
+var ESPECIAIS = /[\\+*?:{}()]/g;
+function dictMatch(pathname) {
+  const i = pathname.lastIndexOf("/") + 1;
+  const dir = pathname.slice(0, i).replace(ESPECIAIS, "\\$&");
+  const name = pathname.slice(i);
+  const m = HASH.exec(name);
+  if (!m) return dir + name.replace(ESPECIAIS, "\\$&");
+  return dir + name.slice(0, m.index).replace(ESPECIAIS, "\\$&") + "-*" + m[1];
+}
+function accepted(header) {
+  const out = /* @__PURE__ */ new Set();
+  for (const part of (header ?? "").split(",")) {
+    const [name, ...params] = part.trim().toLowerCase().split(";");
+    if (!name || params.some((p) => /^\s*q\s*=\s*0(\.0*)?\s*$/.test(p))) continue;
+    out.add(name.trim());
+  }
+  return out;
+}
+function createDict(o) {
+  const base = (o.base ?? "/").replace(/\/?$/, "/");
+  const cacheControl = o.cacheControl ?? "public, max-age=31536000, immutable";
+  const lookup = (pathname) => {
+    if (!pathname.startsWith(base)) return void 0;
+    let rel;
+    try {
+      rel = decodeURIComponent(pathname.slice(base.length));
+    } catch {
+      return void 0;
+    }
+    return Object.prototype.hasOwnProperty.call(o.index.files, rel) ? o.index.files[rel] : void 0;
+  };
+  const headers = (pathname) => lookup(pathname) ? { "Use-As-Dictionary": `match="${dictMatch(pathname)}"`, Vary: VARY } : void 0;
+  const choose = (pathname, method, available, encoding) => {
+    if (method && method !== "GET" && method !== "HEAD") return void 0;
+    const file = lookup(pathname);
+    const hash = available?.trim();
+    if (!file || !hash || !Object.prototype.hasOwnProperty.call(file.deltas, hash)) return void 0;
+    const variant = file.deltas[hash];
+    const ok = accepted(encoding);
+    const enc = variant.dcz && ok.has("dcz") ? "dcz" : variant.dcb && ok.has("dcb") ? "dcb" : void 0;
+    if (!enc) return void 0;
+    return {
+      path: variant[enc],
+      head: {
+        "Content-Type": file.type,
+        "Content-Encoding": enc,
+        "Cache-Control": cacheControl,
+        "Use-As-Dictionary": `match="${dictMatch(pathname)}"`,
+        Vary: VARY
+      }
+    };
+  };
+  return {
+    headers,
+    async fetch(request) {
+      const url = new URL(request.url);
+      const hit = choose(url.pathname, request.method, request.headers.get("available-dictionary"), request.headers.get("accept-encoding"));
+      if (!hit) return void 0;
+      const body = await o.read(hit.path);
+      if (body == null) return void 0;
+      const init = { headers: hit.head, encodeBody: "manual" };
+      return new Response(request.method === "HEAD" ? null : body, init);
+    },
+    node(req, res, next) {
+      const pathname = new URL(req.url ?? "/", "http://x").pathname;
+      const one = (v) => Array.isArray(v) ? v.join(",") : v;
+      const hit = choose(pathname, req.method, one(req.headers["available-dictionary"]), one(req.headers["accept-encoding"]));
+      if (!hit) {
+        const h = headers(pathname);
+        if (h) for (const [k, v] of Object.entries(h)) res.setHeader(k, v);
+        return next();
+      }
+      Promise.resolve(o.read(hit.path)).then(async (body) => {
+        if (body == null) {
+          const h = headers(pathname);
+          for (const [k, v] of Object.entries(h)) res.setHeader(k, v);
+          return next();
+        }
+        const bytes = typeof body === "string" || body instanceof Uint8Array ? body : new Uint8Array(await new Response(body).arrayBuffer());
+        res.writeHead(200, hit.head);
+        res.end(req.method === "HEAD" ? void 0 : bytes);
+      }).catch(next);
+    }
+  };
+}
+
+export {
+  dictMatch,
+  createDict
+};