vitral 0.1.0 → 0.3.0

package/dist/solid.d.ts

@@ -1,6 +1,10 @@
-import { JSX, Component } from 'solid-js';
-import { Props, Isolation, RemoteError, RemoteModule } from './index.js';
-export { RemoteContext, events, navigate } from './index.js';
+import { JSX, Component, Accessor } from 'solid-js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-Czvm-siZ.js';
+export { R as RemoteContext } from './types-Czvm-siZ.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+export { e as events } from './events-D5gs7rff.js';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 
 /**
  * Adaptador Solid (e SolidStart).
@@ -12,13 +16,32 @@ export { RemoteContext, events, navigate } from './index.js';
 /** Transforma um componente Solid em um remote. O contexto chega na prop `vitral`. */
 declare function solidRemote<P extends Props>(Comp: Component<any>): RemoteModule<P>;
 interface RemoteProps<P extends Props = Props> {
-    name: string;
+    name?: string;
+    /** URL do `vitral.json`. Dispensa `configure()`. */
+    src?: string;
     props?: P;
     isolate?: Isolation;
     fallback?: JSX.Element;
     error?: (error: RemoteError, retry: () => void) => JSX.Element;
     class?: string;
+    /** `'lazy'`: monta perto de aparecer na tela; `'idle'`: com o navegador ocioso. */
+    loading?: Loading;
+    /** Baixa antes de montar: `'hover'`, `'visible'` ou `'idle'`. */
+    prefetch?: Prefetch;
+    /** `'high'` para o remote que aparece logo ao abrir a página. */
+    priority?: RequestPriority;
+    /** Ao sair da página, guarda o remote montado (LRU, padrão 5) e na volta só atualiza as props. */
+    keepAlive?: boolean | number;
 }
-declare function Remote<P extends Props = Props>(p: RemoteProps<P>): JSX.Element;
+declare function Remote<P extends Props = Props, N extends string = string>(p: RemoteProps<P> & CheckedProps<N>): JSX.Element;
+/**
+ * Accessor de uma chave compartilhada (`provide`/`shared`). Com seletor, só
+ * muda quando o resultado do seletor muda (`Object.is`). A assinatura acaba
+ * junto com o dono reativo (componente ou `createRoot`).
+ *
+ *   const nome = useShared('usuario', (u) => u?.nome)
+ */
+declare function useShared<K extends keyof Shared, S = Shared[K] | undefined>(key: K, select?: (value: Shared[K] | undefined) => S): Accessor<S>;
+declare function useShared<T = unknown, S = T | undefined>(key: string, select?: (value: T | undefined) => S): Accessor<S>;
 
-export { Remote, type RemoteProps, solidRemote };
+export { Remote, type RemoteProps, solidRemote, useShared };

package/dist/solid.js

@@ -1,12 +1,22 @@
 import {
-  createSlot,
+  hostSlot
+} from "./chunk-IHTUM6LT.js";
+import {
   defineRemote,
   events,
-  navigate
-} from "./chunk-TTL52BF2.js";
+  memoSelect,
+  navigate,
+  same,
+  shared
+} from "./chunk-I3VSKSAZ.js";
+import "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import "./chunk-AKNNHQ2H.js";
+import "./chunk-GNPFWISJ.js";
 
 // src/solid.ts
-import { createComponent, createEffect, createSignal, mergeProps, on, onCleanup, onMount } from "solid-js";
+import { createComponent, createEffect, createSignal, getOwner, mergeProps, on, onCleanup, onMount } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { isServer, render } from "solid-js/web";
 function solidRemote(Comp) {
@@ -26,15 +36,20 @@ function Remote(p) {
   const [status, setStatus] = createSignal("loading");
   const [error, setError] = createSignal(null);
   const host = document.createElement("div");
-  host.setAttribute("data-vitral", p.name);
+  host.setAttribute("data-vitral", p.name ?? p.src ?? "");
   if (p.class) host.className = p.class;
   const target = document.createElement("div");
   let slot = null;
   onMount(() => {
-    slot = createSlot(target, {
+    slot = hostSlot(target, {
       name: p.name,
+      src: p.src,
       props: p.props ?? {},
       isolate: p.isolate,
+      loading: p.loading,
+      prefetch: p.prefetch,
+      priority: p.priority,
+      keepAlive: p.keepAlive,
       onStatus: (s, e) => {
         host.setAttribute("data-vitral-status", s);
         setError(() => e);
@@ -42,7 +57,7 @@ function Remote(p) {
       }
     });
   });
-  createEffect(on(() => [p.name, p.isolate], ([name, isolate]) => slot?.set({ name, isolate }), { defer: true }));
+  createEffect(on(() => [p.name, p.src, p.isolate], ([name, src, isolate]) => slot?.set({ name, src, isolate }), { defer: true }));
   createEffect(on(() => ({ ...p.props ?? {} }), (props) => slot?.update(props), { defer: true }));
   onCleanup(() => slot?.destroy());
   const retry = () => slot?.retry();
@@ -52,9 +67,18 @@ function Remote(p) {
     (host.appendChild(target), host)
   ];
 }
+function useShared(key, select = same) {
+  const handle = shared(key);
+  const pick = memoSelect();
+  const [value, setValue] = createSignal(pick(handle.get(), select), { equals: Object.is });
+  const off = handle.subscribe((v) => setValue(() => pick(v, select)));
+  if (getOwner()) onCleanup(off);
+  return value;
+}
 export {
   Remote,
   events,
   navigate,
-  solidRemote
+  solidRemote,
+  useShared
 };

package/dist/sri-JMX6JLQP.js

@@ -0,0 +1,116 @@
+import {
+  verifyIntegrity
+} from "./chunk-AH7KNMBW.js";
+import {
+  addLink,
+  fetchBytes,
+  withTimeout
+} from "./chunk-GNHCZRQP.js";
+import {
+  RemoteError
+} from "./chunk-AKNNHQ2H.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/core/sri.ts
+var failed = /* @__PURE__ */ new Set();
+async function importVerified(name, r, run, timeout) {
+  const { entry, integrity, priority } = r;
+  if (!failed.has(entry)) {
+    try {
+      const go = async () => {
+        const url2 = await verified(r.split ?? { entry, chunks: [], sri: { [entry]: integrity }, priority }, run);
+        return url2 && { ns: await run(url2) };
+      };
+      const done = await withTimeout(timeout, name, go());
+      if (done) return done.ns;
+    } catch (e) {
+      failed.add(entry);
+      if (e instanceof RemoteError && e.code === "TIMEOUT") throw e;
+    }
+  }
+  const bytes = await fetchBytes(entry, timeout, name, failed.has(entry) ? { priority, cache: "reload" } : { priority });
+  await verifyIntegrity(name, bytes, integrity);
+  const url = URL.createObjectURL(new Blob([bytes], { type: "text/javascript" }));
+  try {
+    return await run(url);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+var STRICT = /^(sha(256|384|512)-[A-Za-z0-9+/]+={0,2}( +|$))+$/;
+var PROBE = "data:text/javascript,export{}";
+var PROBE_SRI = "sha256-d3bjIZdvLjBurwdLwkSVOnEBPFFly+T1SR9r3VVHBGg=";
+var maps;
+var preloads;
+var tick = () => new Promise((resolve) => {
+  const c = new MessageChannel();
+  c.port1.onmessage = () => resolve();
+  c.port2.postMessage(0);
+});
+async function verified(build, run) {
+  const { entry, chunks, sri, priority = "auto", dedupe = [] } = build;
+  const own = dedupe.flatMap((d) => [...d.chunks ?? [], d.file]);
+  if (![entry, ...chunks, ...own].every((u) => STRICT.test(sri[u] ?? ""))) return;
+  const p = globalThis[/* @__PURE__ */ Symbol.for("vitral")];
+  const share = async (pre) => {
+    if (!run || !dedupe.length) return;
+    const { shared } = await import("./dedupe-S7BHQMOZ.js");
+    for (const d of dedupe)
+      shared(p)(d.name, d.range, {
+        version: d.version,
+        url: d.file,
+        load: async () => {
+          if (pre) await Promise.all([...d.chunks ?? [], d.file].map((u) => preload(u, sri[u], priority)));
+          return (await run(d.file)).default;
+        }
+      });
+  };
+  if (maps !== false && (maps = await addMap(sri))) {
+    await share();
+    for (const u of chunks) fetch(u, { priority }).catch(() => {
+    });
+    return entry;
+  }
+  if (await (preloads ??= checkPreloads())) {
+    p.sri = { ...p.sri, ...sri };
+    await share(true);
+    await Promise.all([...chunks, entry].map((u) => preload(u, sri[u], priority)));
+    return entry;
+  }
+}
+async function addMap(integrity) {
+  let ok = true;
+  try {
+    const s = document.createElement("script");
+    s.type = "importmap";
+    s.nonce = document.querySelector("script[nonce]")?.nonce ?? "";
+    s.onerror = () => ok = false;
+    s.addEventListener("securitypolicyviolation", () => ok = false);
+    s.textContent = JSON.stringify({ integrity });
+    document.head.append(s);
+  } catch {
+    return false;
+  }
+  await tick();
+  await tick();
+  return ok;
+}
+function preload(href, integrity, fetchPriority = "auto") {
+  return new Promise((resolve, reject) => {
+    const link = addLink("modulepreload", href, { integrity, fetchPriority });
+    link.onload = resolve;
+    link.onerror = reject;
+  });
+}
+function checkPreloads() {
+  if (!document.createElement("link").relList.supports("modulepreload")) return Promise.resolve(false);
+  const run = (href, good) => preload(href, PROBE_SRI).then(() => good, () => !good);
+  return Promise.race([
+    Promise.all([run(PROBE, true), run(PROBE + "//", false)]).then(([a, b]) => a && b),
+    new Promise((resolve) => setTimeout(resolve, 3e3, false))
+  ]);
+}
+export {
+  importVerified,
+  verified
+};

package/dist/state-BDdCwc21.d.ts

@@ -0,0 +1,4 @@
+/** Só para testes: apaga o protocolo global. */
+declare function resetProtocol(): void;
+
+export { resetProtocol as r };

package/dist/svelte.d.ts

@@ -1,22 +1,38 @@
 import { Component } from 'svelte';
-import { Props, Isolation, SlotStatus, RemoteError, RemoteModule } from './index.js';
-export { RemoteContext, events, navigate } from './index.js';
+import { P as Props, I as Isolation, a as RemoteModule } from './types-Czvm-siZ.js';
+export { R as RemoteContext } from './types-Czvm-siZ.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+import { S as SlotStatus } from './slot-DqXTwGbs.js';
+export { e as events } from './events-D5gs7rff.js';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 
 /**
  * Adaptador Svelte 5 (e SvelteKit).
  *
  * Remote: export default svelteRemote(App)
  * Host:   <div use:remote={{ name: 'carrinho', props: { userId } }}></div>
+ *         <div use:remote={{ src: 'https://cdn.exemplo.com/carrinho/vitral.json' }}></div>
  *         ou o Web Component <vitral-remote> de 'vitral/element'.
  */
 
 /** Transforma um componente Svelte em um remote. O contexto chega na prop `vitral`. */
 declare function svelteRemote<P extends Props>(component: Component<any>): RemoteModule<P>;
 interface RemoteActionParams<P extends Props = Props> {
-    name: string;
+    name?: string;
+    /** URL do `vitral.json`. Dispensa `configure()`. */
+    src?: string;
     props?: P;
     isolate?: Isolation;
     onStatus?: (status: SlotStatus, error: RemoteError | null) => void;
+    /** `'lazy'`: monta perto de aparecer na tela; `'idle'`: com o navegador ocioso. */
+    loading?: Loading;
+    /** Baixa antes de montar: `'hover'`, `'visible'` ou `'idle'`. */
+    prefetch?: Prefetch;
+    /** `'high'` para o remote que aparece logo ao abrir a página. */
+    priority?: RequestPriority;
+    /** Ao sair da página, guarda o remote montado (LRU, padrão 5) e na volta só atualiza as props. */
+    keepAlive?: boolean | number;
 }
 /** Action Svelte: `<div use:remote={{ name, props }}>`. Funciona também em SvelteKit (só roda no cliente). */
 declare function remote<P extends Props = Props>(node: HTMLElement, params: RemoteActionParams<P>): {

package/dist/svelte.js

@@ -1,9 +1,16 @@
 import {
-  createSlot,
+  hostSlot
+} from "./chunk-IHTUM6LT.js";
+import {
   defineRemote,
   events,
   navigate
-} from "./chunk-TTL52BF2.js";
+} from "./chunk-I3VSKSAZ.js";
+import "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import "./chunk-AKNNHQ2H.js";
+import "./chunk-GNPFWISJ.js";
 
 // src/svelte.ts
 import { createClassComponent } from "svelte/legacy";
@@ -19,10 +26,10 @@ function svelteRemote(component) {
   });
 }
 function remote(node, params) {
-  const slot = createSlot(node, params);
+  const slot = hostSlot(node, params);
   return {
     update(next) {
-      slot.set({ name: next.name, isolate: next.isolate });
+      slot.set({ name: next.name, src: next.src, isolate: next.isolate });
       slot.update(next.props ?? {});
     },
     destroy: () => slot.destroy()

package/dist/testing.d.ts

@@ -1,5 +1,6 @@
-import { Props, RemoteContext } from './index.js';
-export { __reset as resetVitral } from './index.js';
+import { P as Props, R as RemoteContext } from './types-Czvm-siZ.js';
+export { r as resetVitral } from './state-BDdCwc21.js';
+import './errors-kjBv6IH_.js';
 
 /**
  * Utilidades de teste: monte o host sem subir nenhum remote de verdade.

package/dist/testing.js

@@ -1,7 +1,13 @@
+import "./chunk-I3VSKSAZ.js";
 import {
-  __reset,
   register
-} from "./chunk-TTL52BF2.js";
+} from "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import "./chunk-AKNNHQ2H.js";
+import {
+  resetProtocol
+} from "./chunk-GNPFWISJ.js";
 
 // src/testing.ts
 function mockRemote(name, render = (el) => {
@@ -43,5 +49,5 @@ function failingRemote(name, message = "falha simulada") {
 export {
   failingRemote,
   mockRemote,
-  __reset as resetVitral
+  resetProtocol as resetVitral
 };