vitral 0.1.0 → 0.2.0

package/dist/angular.js

@@ -1,21 +1,32 @@
 import {
   defineVitralElement
-} from "./chunk-IZK6ITIJ.js";
+} from "./chunk-6Y3VMWHH.js";
+import "./chunk-UTYAX6MU.js";
 import {
-  configure,
   defineRemote,
   events,
-  navigate
-} from "./chunk-TTL52BF2.js";
+  memoSelect,
+  navigate,
+  same,
+  shared
+} from "./chunk-NCONW6WS.js";
+import {
+  configure
+} from "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import "./chunk-PX7PBCCT.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 +62,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 +83,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,12 @@
+import {
+  defineVitralElement
+} from "./chunk-6Y3VMWHH.js";
+import "./chunk-UTYAX6MU.js";
+import "./chunk-NCONW6WS.js";
+import "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import "./chunk-PX7PBCCT.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/auto.ts
+defineVitralElement();

package/dist/chunk-2XF5BKV3.js

@@ -0,0 +1,190 @@
+import {
+  prefetchCss
+} from "./chunk-SFL6LTP3.js";
+import {
+  RemoteError,
+  absolute,
+  addLink,
+  fetchJson,
+  isRemoteError,
+  metric,
+  pageOrigin,
+  withRetry,
+  withTimeout
+} from "./chunk-PX7PBCCT.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/registry.ts
+function configure(config) {
+  const p = protocol();
+  const { remotes, dedupe, ...rest } = config;
+  p.configure(rest);
+  if (dedupe) p.pending(import("./dedupe-IWFIXRWG.js").then((m) => m.offer(p, dedupe)).catch(() => {
+  }));
+  if (typeof remotes === "string") {
+    const url = absolute(remotes);
+    p.pending(
+      fetchJson(url, p.settings().timeout, "remotes", { cache: "no-cache" }).then((map) => registerAll(map, url))
+    ).catch(() => {
+    });
+  } else if (remotes) {
+    registerAll(remotes);
+  }
+}
+function register(name, entry) {
+  const e = typeof entry === "string" ? { url: entry } : entry;
+  if (!e.url && !e.module) throw new RemoteError("NOT_REGISTERED", name, "informe url ou module");
+  if (!e.url) return protocol().register(name, e);
+  const url = absolute(e.url);
+  protocol().register(name, { ...e, url });
+  const { origin } = new URL(url);
+  if (typeof document !== "undefined" && origin !== pageOrigin() && origin !== "null" && !document.querySelector(`link[href="${origin}"]`)) {
+    addLink("preconnect", origin);
+  }
+}
+function registerSrc(src, name, trusted = true) {
+  const p = protocol();
+  const url = absolute(src);
+  const key = name || url;
+  if (p.entry(key)?.url !== url) p.register(key, { url });
+  const origin = new URL(url).origin;
+  const list = p.settings().trusted ?? [];
+  if (trusted && !list.includes(origin)) p.configure({ trusted: [...list, origin] });
+  return key;
+}
+function registerAll(map, base) {
+  for (const [name, entry] of Object.entries(map)) {
+    const e = typeof entry === "string" ? { url: entry } : entry;
+    register(name, e.url ? { ...e, url: absolute(e.url, base) } : e);
+  }
+}
+function checkOrigin(name, url) {
+  const p = protocol();
+  const origin = new URL(url).origin;
+  const { allowedOrigins, trusted = [] } = p.settings();
+  const allowed = [...allowedOrigins ?? [pageOrigin(), ...p.origins()].filter(Boolean), ...trusted];
+  if (allowed.includes("*") || allowed.includes(origin) || url.startsWith("blob:")) return;
+  throw new RemoteError("ORIGIN_BLOCKED", name, `origem ${origin} n\xE3o est\xE1 em allowedOrigins`);
+}
+
+// src/core/loader.ts
+function loadRemote(name) {
+  return load(name).then((r) => r.module);
+}
+function loadModule(name) {
+  return import("./expose-53BEJB34.js").then((m) => m.resolveModule(name, (n) => loadFile(n)));
+}
+function preload(name) {
+  load(name).catch(() => {
+  });
+}
+var paths;
+function load(name, isolate, priority) {
+  const file = (n) => loadFile(n, isolate, priority);
+  if (protocol().entry(name) || !name.includes("/")) return file(name).then((r) => mountable(name, r));
+  return import("./expose-53BEJB34.js").then((m) => m.resolveTarget(name, file));
+}
+function loadFile(name, isolate, priority) {
+  const p = protocol();
+  return p.load(name, async () => {
+    paths ??= import("./sri-BVKZNX5Q.js").catch(() => null);
+    try {
+      await p.pending();
+      const override = await devOverride(name);
+      const entry = override ? { isolate: p.entry(name)?.isolate, ...override } : p.entry(name);
+      if (!entry) throw new RemoteError("NOT_REGISTERED", name, "remote n\xE3o registrado. Use configure({ remotes }).");
+      if (entry.module) return await loadLocal(name, entry);
+      let t = performance.now();
+      const resolved = await resolveEntry(name, entry, priority);
+      metric(name, "manifest", t);
+      prefetchCss(resolved.css, (isolate ?? resolved.isolate ?? p.settings().isolate) === "shadow", resolved.sri, priority);
+      t = performance.now();
+      const ns = await withRetry(p.settings().retries, () => importModule(name, resolved));
+      metric(name, "js", t);
+      return { ...resolved, module: ns?.default ?? ns, exports: ns };
+    } catch (e) {
+      throw isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, String(e?.message ?? e), e);
+    }
+  });
+}
+function devOverride(name) {
+  try {
+    if (/vitral/.test(location.search + localStorage.getItem("vitral:overrides"))) return import("./overrides-NZAIUGK5.js").then((m) => m.overrideFor(name));
+  } catch {
+  }
+}
+async function loadLocal(name, entry) {
+  let ns = entry.module;
+  if (typeof ns === "function") ns = await ns();
+  return { module: ns?.default ?? ns, exports: ns, entry: typeof location !== "undefined" ? location.href : "http://localhost/", css: entry.css ?? [], isolate: entry.isolate };
+}
+async function resolveEntry(name, entry, priority) {
+  checkOrigin(name, entry.url);
+  const m = entry.manifest ?? (new URL(entry.url).pathname.endsWith(".json") ? await fetchJson(entry.url, protocol().settings().timeout, name, { cache: "no-cache", priority }) : { name, entry: entry.url });
+  if (typeof m?.entry !== "string") throw new RemoteError("INVALID_MODULE", name, `manifesto inv\xE1lido em ${entry.url}`);
+  const abs = (u) => absolute(u, entry.url);
+  const sri = {};
+  for (const file in m.files ?? {}) sri[abs(file)] = m.files[file];
+  const resolved = {
+    entry: abs(m.entry),
+    css: [...m.css ?? [], ...entry.css ?? []].map(abs),
+    // A integridade declarada pelo host vence a do manifesto, e aí só o
+    // arquivo único (o que ela descreve) é usado.
+    integrity: entry.integrity ?? m.integrity,
+    isolate: entry.isolate,
+    scope: m.scope,
+    sri,
+    priority,
+    split: m.split && !entry.integrity ? {
+      entry: abs(m.split.entry),
+      chunks: (m.split.chunks ?? []).map(abs),
+      sri,
+      priority,
+      dedupe: m.dedupe?.map((d) => ({ ...d, file: abs(d.file), chunks: d.chunks?.map(abs) }))
+    } : void 0
+  };
+  checkOrigin(name, resolved.entry);
+  for (const u of [resolved.split?.entry, ...(resolved.split?.dedupe ?? []).map((d) => d.file)]) if (u) checkOrigin(name, u);
+  if (name === entry.url && m.name) {
+    const override = await devOverride(m.name);
+    if (override) return { ...await resolveEntry(name, override), name: m.name };
+    resolved.name = m.name;
+    if (!protocol().entry(m.name)) protocol().register(m.name, entry);
+  }
+  return resolved;
+}
+async function importModule(name, r) {
+  const { timeout } = protocol().settings();
+  const run = (url) => withTimeout(timeout, name, import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    url
+  )).catch((e) => {
+    throw isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, `falha ao importar ${r.entry}`, e);
+  });
+  if (!r.integrity) return run(r.entry);
+  const sri = await paths;
+  if (!sri) throw new RemoteError("LOAD_FAILED", name, "n\xE3o foi poss\xEDvel carregar o verificador de integrity");
+  return sri.importVerified(name, r, run, timeout);
+}
+function mountable(name, r) {
+  if (typeof r.module?.mount != "function") {
+    throw new RemoteError("INVALID_MODULE", name, "o m\xF3dulo n\xE3o exporta mount(). Use defineRemote(), ou loadModule() para m\xF3dulo sem UI.");
+  }
+  return r;
+}
+
+export {
+  configure,
+  register,
+  registerSrc,
+  loadRemote,
+  loadModule,
+  preload,
+  load,
+  loadFile,
+  resolveEntry,
+  mountable
+};

package/dist/chunk-6Y3VMWHH.js

@@ -0,0 +1,181 @@
+import {
+  hostSlot,
+  timings
+} from "./chunk-UTYAX6MU.js";
+import {
+  defineRemote,
+  memoSelect,
+  same,
+  shared
+} from "./chunk-NCONW6WS.js";
+import {
+  registerSrc
+} from "./chunk-2XF5BKV3.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-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-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
+};

package/dist/chunk-HP6QWU6K.js

@@ -0,0 +1,51 @@
+import {
+  mountable
+} from "./chunk-2XF5BKV3.js";
+import {
+  RemoteError
+} from "./chunk-PX7PBCCT.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/expose.ts
+function splitName(name) {
+  const p = protocol();
+  let i = name.length;
+  if (!p.entry(name)) while ((i = name.lastIndexOf("/", i - 1)) > 0 && !p.entry(name.slice(0, i))) ;
+  return i > 0 && i < name.length ? [name.slice(0, i), "." + name.slice(i)] : [name, null];
+}
+function resolveTarget(name, loadFile) {
+  return resolveAny(name, loadFile).then((r) => mountable(name, r));
+}
+function resolveAny(name, loadFile) {
+  const p = protocol();
+  if (p.entry(name) || !name.includes("/")) return loadFile(name);
+  return p.pending().then(async () => {
+    const [remote, key] = splitName(name);
+    if (!key) return loadFile(name);
+    const r = await loadFile(remote);
+    const table = r.exports?.exposes;
+    if (!table?.[key]) throw new RemoteError("NOT_EXPOSED", name, `${remote} n\xE3o exp\xF5e ${key}. Expostos: ${Object.keys(table ?? {}).join(", ")}`);
+    try {
+      const value = table[key];
+      const ns = await (typeof value == "function" ? value() : value);
+      return { ...r, module: ns?.default ?? ns, exports: ns };
+    } catch (e) {
+      throw new RemoteError("LOAD_FAILED", name, String(e), e);
+    }
+  });
+}
+async function resolveModule(name, loadFile) {
+  const r = await resolveAny(name, loadFile);
+  if (!r.exports) {
+    throw new RemoteError("INVALID_MODULE", name, "o remote foi carregado por uma c\xF3pia antiga da lib, que n\xE3o guarda os exports");
+  }
+  return r.exports;
+}
+
+export {
+  splitName,
+  resolveTarget,
+  resolveModule
+};