vitral 0.1.0 → 0.3.0

package/dist/angular.js

@@ -1,21 +1,33 @@
 import {
   defineVitralElement
-} from "./chunk-IZK6ITIJ.js";
+} from "./chunk-3YXI3G34.js";
+import "./chunk-IHTUM6LT.js";
 import {
-  configure,
   defineRemote,
   events,
-  navigate
-} from "./chunk-TTL52BF2.js";
+  memoSelect,
+  navigate,
+  same,
+  shared
+} from "./chunk-I3VSKSAZ.js";
+import {
+  configure
+} from "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import "./chunk-AKNNHQ2H.js";
+import "./chunk-GNPFWISJ.js";
 
 // src/angular.ts
 import {
+  DestroyRef,
   InjectionToken,
   createComponent,
   inject,
   provideAppInitializer,
   provideZonelessChangeDetection,
-  reflectComponentType
+  reflectComponentType,
+  signal
 } from "@angular/core";
 import { createApplication } from "@angular/platform-browser";
 var VITRAL_CONTEXT = new InjectionToken("vitral.context");
@@ -51,6 +63,14 @@ function angularRemote(component, config = {}) {
 function injectVitral() {
   return inject(VITRAL_CONTEXT, { optional: true });
 }
+function injectShared(key, select = same) {
+  const destroy = inject(DestroyRef);
+  const handle = shared(key);
+  const pick = memoSelect();
+  const value = signal(pick(handle.get(), select), { equal: Object.is });
+  destroy.onDestroy(handle.subscribe((v) => value.set(pick(v, select))));
+  return value.asReadonly();
+}
 function provideVitral(config = {}) {
   return [
     provideAppInitializer(() => {
@@ -64,6 +84,7 @@ export {
   VITRAL_CONTEXT,
   angularRemote,
   events,
+  injectShared,
   injectVitral,
   navigate,
   provideVitral

package/dist/auto.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/auto.js

@@ -0,0 +1,13 @@
+import {
+  defineVitralElement
+} from "./chunk-3YXI3G34.js";
+import "./chunk-IHTUM6LT.js";
+import "./chunk-I3VSKSAZ.js";
+import "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import "./chunk-AKNNHQ2H.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/auto.ts
+defineVitralElement();

package/dist/capture-JYFERAPL.js

@@ -0,0 +1,42 @@
+import {
+  RemoteError,
+  isRemoteError,
+  mounted,
+  report,
+  reported
+} from "./chunk-AKNNHQ2H.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/capture.ts
+var on = false;
+function capture() {
+  if (on || typeof addEventListener == "undefined") return;
+  on = true;
+  addEventListener("error", (e) => attribute(e.error, e.filename));
+  addEventListener("unhandledrejection", (e) => attribute(e.reason));
+}
+function owner(error, file) {
+  const url = file || String(error?.stack ?? "").match(/(?:https?|file):\/\/[^\s)'"]+/)?.[0];
+  if (!url) return;
+  const host = [...document.querySelectorAll("script[src],link[rel=modulepreload]")].map(
+    (el) => el.src || el.href
+  );
+  let best;
+  let size = 0;
+  for (const [name, { entry }] of mounted) {
+    const dir = new URL(".", entry).href;
+    if (dir.length > size && url.startsWith(dir) && !host.some((u) => u.startsWith(dir))) best = name, size = dir.length;
+  }
+  return best;
+}
+function attribute(error, file) {
+  if (!protocol().settings().captureGlobalErrors || isRemoteError(error) || error instanceof Object && reported.has(error)) return;
+  const name = owner(error, file);
+  if (name) report(new RemoteError("RENDER_FAILED", name, String(error?.message ?? error), error), mounted.get(name));
+}
+export {
+  capture,
+  owner
+};

package/dist/chunk-3YXI3G34.js

@@ -0,0 +1,181 @@
+import {
+  hostSlot,
+  timings
+} from "./chunk-IHTUM6LT.js";
+import {
+  defineRemote,
+  memoSelect,
+  same,
+  shared
+} from "./chunk-I3VSKSAZ.js";
+import {
+  registerSrc
+} from "./chunk-TD4S3IHA.js";
+
+// src/element.ts
+var Base = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+var VitralRemoteElement = class extends Base {
+  static {
+    this.observedAttributes = ["name", "src", "props", "isolate"];
+  }
+  #slot = null;
+  #props = {};
+  get props() {
+    return this.#props;
+  }
+  set props(value) {
+    this.#props = value ?? {};
+    this.#slot?.update(this.#props);
+  }
+  get status() {
+    return this.#slot?.status ?? "loading";
+  }
+  retry() {
+    this.#slot?.retry();
+  }
+  connectedCallback() {
+    if (this.#slot) return;
+    const name = this.#name();
+    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, {
+      name,
+      props: this.#props,
+      isolate: this.getAttribute("isolate") || void 0,
+      loading: this.getAttribute("loading"),
+      prefetch: this.getAttribute("prefetch"),
+      priority: this.getAttribute("priority") || void 0,
+      keepAlive: keep === null ? false : Number(keep) || true,
+      styles: { inherit: this.getAttribute("inherit-styles")?.split(/\s+/).filter(Boolean) },
+      onStatus: (status, error) => {
+        this.setAttribute("data-vitral-status", status);
+        if (status === "loading") this.setAttribute("aria-busy", "true");
+        else this.removeAttribute("aria-busy");
+        const has = (slot) => {
+          const els = this.querySelectorAll(`:scope > [slot="${slot}"]`);
+          for (const el of els) el.hidden = status !== (slot === "fallback" ? "loading" : "error");
+          return els.length > 0;
+        };
+        queueMicrotask(() => {
+          if (this.#slot?.status !== status) return;
+          const custom = { loading: has("fallback"), error: has("error"), ready: true };
+          this.#showDefault(custom[status] ? null : status);
+        });
+        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 } }));
+      }
+    });
+  }
+  /**
+   * Nome para montar. `src` em atributo é registrado sem entrar na allowlist:
+   * HTML injetado não pode liberar uma origem nova quando há `allowedOrigins`.
+   */
+  #name() {
+    const src = this.getAttribute("src");
+    const name = this.getAttribute("name");
+    return src ? registerSrc(src, name ?? void 0, false) : name;
+  }
+  #default = null;
+  /** Carregando e erro padrão, só quando não há slot próprio. */
+  #showDefault(status) {
+    this.#default?.remove();
+    this.#default = null;
+    if (!status) return;
+    const box = document.createElement("div");
+    box.setAttribute("data-vitral-default", status);
+    if (status === "loading") {
+      box.setAttribute("role", "status");
+      box.textContent = "Carregando\u2026";
+    } else {
+      box.setAttribute("role", "alert");
+      const button = document.createElement("button");
+      button.type = "button";
+      button.textContent = "Tentar de novo";
+      button.onclick = () => this.retry();
+      box.append("N\xE3o foi poss\xEDvel carregar. ", button);
+    }
+    this.prepend(this.#default = box);
+  }
+  disconnectedCallback() {
+    queueMicrotask(() => {
+      if (!this.isConnected) {
+        this.#slot?.destroy();
+        this.#slot = null;
+        this.#showDefault(null);
+      }
+    });
+  }
+  attributeChangedCallback(attr, _old, value) {
+    if (attr === "props") return void (this.props = parseProps(value));
+    if (!this.#slot) return void (this.isConnected && this.connectedCallback());
+    if (attr === "name" || attr === "src") {
+      const name = this.#name();
+      if (name) this.#slot.set({ name });
+    }
+    if (attr === "isolate") this.#slot.set({ isolate: value || void 0 });
+  }
+};
+function parseProps(value) {
+  if (!value) return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    console.error("[vitral] atributo props n\xE3o \xE9 JSON v\xE1lido:", value);
+    return {};
+  }
+}
+function defineVitralElement(tag = "vitral-remote") {
+  if (typeof customElements !== "undefined" && !customElements.get(tag)) {
+    customElements.define(tag, class extends VitralRemoteElement {
+    });
+  }
+}
+function elementRemote(tag, setup) {
+  return defineRemote({
+    mount(el, props, ctx) {
+      setup?.();
+      const node = document.createElement(tag);
+      node.vitral = ctx;
+      Object.assign(node, props);
+      el.appendChild(node);
+      return {
+        update: (next) => Object.assign(node, next),
+        unmount: () => node.remove()
+      };
+    }
+  });
+}
+var SharedController = class {
+  #host;
+  #handle;
+  #select;
+  #pick = memoSelect();
+  #off;
+  constructor(host, key, select) {
+    this.#host = host;
+    this.#handle = shared(key);
+    this.#select = select ?? same;
+    this.value = this.#pick(this.#handle.get(), this.#select);
+    host.addController(this);
+  }
+  hostConnected() {
+    this.#off = this.#handle.subscribe((v) => {
+      const next = this.#pick(v, this.#select);
+      if (Object.is(next, this.value)) return;
+      this.value = next;
+      this.#host.requestUpdate();
+    });
+  }
+  hostDisconnected() {
+    this.#off?.();
+  }
+};
+
+export {
+  VitralRemoteElement,
+  defineVitralElement,
+  elementRemote,
+  SharedController
+};

package/dist/chunk-AH7KNMBW.js

@@ -0,0 +1,20 @@
+import {
+  RemoteError
+} from "./chunk-AKNNHQ2H.js";
+
+// src/core/integrity.ts
+var clean = (b64) => b64.replace(/-/g, "+").replace(/_/g, "/").replace(/=/g, "");
+async function verifyIntegrity(name, bytes, integrity) {
+  const hashes = integrity.split(/\s+/).map((token) => /^sha(256|384|512)-([\w+/=-]+)/.exec(token)).filter((m) => !!m);
+  if (!hashes.length) throw new RemoteError("INTEGRITY", name, `formato de integrity inv\xE1lido: ${integrity}`);
+  const bits = Math.max(...hashes.map((m) => +m[1]));
+  const actual = btoa(String.fromCharCode(...new Uint8Array(await crypto.subtle.digest("SHA-" + bits, bytes))));
+  const expected = hashes.filter((m) => +m[1] === bits).map((m) => m[2]);
+  if (!expected.some((h) => clean(h) === clean(actual))) {
+    throw new RemoteError("INTEGRITY", name, `o hash n\xE3o confere: esperado sha${bits}-${expected.join(" ou ")}, obtido sha${bits}-${actual}`);
+  }
+}
+
+export {
+  verifyIntegrity
+};

package/dist/chunk-AKNNHQ2H.js

@@ -0,0 +1,45 @@
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/errors.ts
+var ERROR_DOCS = "https://joaogabriel15.github.io/vitral/erros/";
+var RemoteError = class extends Error {
+  constructor(code, remote, message, cause) {
+    super(`[vitral] ${remote}: ${message} (${ERROR_DOCS}${code})`);
+    this.code = code;
+    this.remote = remote;
+    this.cause = cause;
+    this.name = "RemoteError";
+    this.docs = `${ERROR_DOCS}${code}`;
+    if (typeof location != "undefined") this.route = location.pathname;
+  }
+};
+var isRemoteError = (e) => e?.name === "RemoteError";
+var mounted = /* @__PURE__ */ new Map();
+var reported = /* @__PURE__ */ new WeakSet();
+function report(e, from) {
+  if (isRemoteError(e) && !reported.has(e)) {
+    reported.add(e);
+    if (e.cause instanceof Object) reported.add(e.cause);
+    e.entry ??= from?.entry ?? protocol().entry(e.remote)?.url;
+    e.version ??= from?.version;
+    try {
+      protocol().settings().onError?.(e);
+    } catch {
+    }
+  }
+  return e;
+}
+var fail = (e) => {
+  throw report(e);
+};
+
+export {
+  RemoteError,
+  isRemoteError,
+  mounted,
+  reported,
+  report,
+  fail
+};

package/dist/chunk-DXORSF4X.js

@@ -0,0 +1,42 @@
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/overrides.ts
+var OVERRIDES_KEY = "vitral:overrides";
+function overridesEnabled() {
+  return !!protocol().settings().devOverrides || typeof location !== "undefined" && /^(localhost|127\.0\.0\.1|\[::1\])$/.test(location.hostname);
+}
+var manifestUrl = (url) => /\.(json|m?js)(\?|$)/.test(url) ? url : url.replace(/\/?$/, "/vitral.json");
+function storedOverrides() {
+  try {
+    return JSON.parse(localStorage.getItem(OVERRIDES_KEY) ?? "{}") ?? {};
+  } catch {
+    return {};
+  }
+}
+var warned = /* @__PURE__ */ new Set();
+function overrideFor(name) {
+  if (!overridesEnabled()) return;
+  const all = storedOverrides();
+  for (const pair of new URLSearchParams(location.search).getAll("vitral").join(",").split(",")) {
+    const at = pair.indexOf("@");
+    if (at > 0) all[pair.slice(0, at)] = pair.slice(at + 1);
+  }
+  if (!all[name]) return;
+  const url = new URL(manifestUrl(all[name]), location.href).href;
+  const p = protocol();
+  const trusted = p.settings().trusted ?? [];
+  const origin = new URL(url).origin;
+  if (!trusted.includes(origin)) p.configure({ trusted: [...trusted, origin] });
+  if (!warned.has(name)) console.warn(`[vitral] override ativo: ${name} \u2192 ${url}`), warned.add(name);
+  return { url };
+}
+
+export {
+  OVERRIDES_KEY,
+  overridesEnabled,
+  manifestUrl,
+  storedOverrides,
+  overrideFor
+};

package/dist/chunk-GNHCZRQP.js

@@ -0,0 +1,79 @@
+import {
+  RemoteError,
+  isRemoteError
+} from "./chunk-AKNNHQ2H.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/util.ts
+function pageOrigin() {
+  return typeof location !== "undefined" ? location.origin : null;
+}
+function absolute(url, base) {
+  return new URL(url, base ?? (typeof location !== "undefined" ? location.href : void 0)).href;
+}
+async function withRetry(retries, fn) {
+  for (let i = 0; ; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      const retryable = isRemoteError(e) && (e.code === "LOAD_FAILED" || e.code === "TIMEOUT");
+      if (!retryable || i >= retries) throw e;
+      await new Promise((r) => setTimeout(r, 200 * 2 ** i));
+    }
+  }
+}
+function withTimeout(ms, name, p) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new RemoteError("TIMEOUT", name, `n\xE3o respondeu em ${ms}ms`)), ms);
+    p.then(resolve, reject).finally(() => clearTimeout(t));
+  });
+}
+function fetchBytes(url, timeout, name, init) {
+  const ctrl = new AbortController();
+  const got = fetch(url, { signal: ctrl.signal, credentials: "omit", ...init }).then(
+    (res) => {
+      if (!res.ok) throw new RemoteError("LOAD_FAILED", name, `HTTP ${res.status} em ${url}`);
+      return res.arrayBuffer();
+    },
+    (e) => {
+      throw new RemoteError("LOAD_FAILED", name, `falha ao baixar ${url}`, e);
+    }
+  );
+  return withTimeout(timeout, name, got).catch((e) => {
+    ctrl.abort();
+    throw e;
+  });
+}
+async function fetchJson(url, timeout, name, init) {
+  const text = new TextDecoder().decode(await fetchBytes(url, timeout, name, init));
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new RemoteError("INVALID_MODULE", name, `JSON inv\xE1lido em ${url}`, e);
+  }
+}
+function addLink(rel, href, props = {}, parent = document.head) {
+  return parent.appendChild(Object.assign(document.createElement("link"), { rel, crossOrigin: "anonymous", href }, props));
+}
+function metric(name, stage, start) {
+  try {
+    const label = `vitral:${name}:${stage}`;
+    performance.clearMeasures(label);
+    performance.measure(label, { start });
+    protocol().settings().onMetric?.({ name, stage, start, duration: performance.now() - start });
+  } catch {
+  }
+}
+
+export {
+  pageOrigin,
+  absolute,
+  withRetry,
+  withTimeout,
+  fetchBytes,
+  fetchJson,
+  addLink,
+  metric
+};

package/dist/chunk-GNPFWISJ.js

@@ -0,0 +1,80 @@
+// src/core/bus.ts
+function createEventBus() {
+  const handlers = /* @__PURE__ */ new Map();
+  const lastValues = /* @__PURE__ */ new Map();
+  return {
+    emit(type, payload) {
+      lastValues.set(type, payload);
+      for (const h of [...handlers.get(type) ?? []]) {
+        try {
+          h(payload);
+        } catch (e) {
+          console.error(`[vitral] handler de "${type}" falhou`, e);
+        }
+      }
+    },
+    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) {
+      return lastValues.get(type);
+    }
+  };
+}
+
+// src/core/state.ts
+var PROTOCOL = 1;
+var KEY = /* @__PURE__ */ Symbol.for("vitral");
+var g = globalThis;
+function createProtocol() {
+  const settings = { timeout: 15e3, retries: 1, isolate: "none", allowedOrigins: null };
+  const entries = /* @__PURE__ */ new Map();
+  const modules = /* @__PURE__ */ new Map();
+  let ready = Promise.resolve();
+  return {
+    protocol: PROTOCOL,
+    events: createEventBus(),
+    settings: () => settings,
+    configure(patch) {
+      Object.assign(settings, patch);
+    },
+    register(name, entry) {
+      entries.set(name, entry);
+      modules.delete(name);
+    },
+    entry: (name) => entries.get(name),
+    origins: () => [...entries.values()].filter((e) => e.url).map((e) => new URL(e.url).origin),
+    pending(p) {
+      if (p) ready = Promise.all([ready, p]);
+      return ready.then(() => {
+      });
+    },
+    load(name, fetcher) {
+      let p = modules.get(name);
+      if (!p) {
+        p = fetcher();
+        const mine = p;
+        mine.catch(() => modules.get(name) === mine && modules.delete(name));
+        modules.set(name, p);
+      }
+      return p;
+    }
+  };
+}
+function protocol() {
+  const found = g[KEY];
+  if (found && typeof found.protocol === "number" && found.protocol >= PROTOCOL) return found;
+  return g[KEY] = createProtocol();
+}
+function resetProtocol() {
+  delete g[KEY];
+}
+
+export {
+  createEventBus,
+  protocol,
+  resetProtocol
+};