vitral 0.7.1 → 0.8.0

package/dist/next.d.ts

@@ -0,0 +1,190 @@
+import * as react from 'react';
+import { ReactNode, ImgHTMLAttributes, AnchorHTMLAttributes, ComponentType } from 'react';
+
+/** `basePath` do `next.config`. O plugin chama ao carregar os módulos `next/*`. */
+declare function setBasePath(path?: string): void;
+type Query = Record<string, string | string[] | undefined>;
+type Url = string | {
+    pathname?: string | null;
+    query?: Query | string | null;
+    hash?: string | null;
+};
+interface NextRouter {
+    pathname: string;
+    route: string;
+    asPath: string;
+    query: Query;
+    basePath: string;
+    isReady: boolean;
+    isFallback: boolean;
+    isPreview: boolean;
+    isLocaleDomain: boolean;
+    locale?: string;
+    push(url: Url, as?: Url, options?: {
+        scroll?: boolean;
+    }): Promise<boolean>;
+    replace(url: Url, as?: Url, options?: {
+        scroll?: boolean;
+    }): Promise<boolean>;
+    back(): void;
+    forward(): void;
+    reload(): void;
+    prefetch(url: string): Promise<void>;
+    beforePopState(cb: unknown): void;
+    events: {
+        on(type: string, fn: (...args: any[]) => void): void;
+        off(type: string, fn: (...args: any[]) => void): void;
+        emit(type: string, ...args: any[]): void;
+    };
+    /** Só no roteador do host (`NextRemote`): o `href` que o `<Link>` mostra, já com a rota pública. */
+    hrefOf?(path: string): string;
+}
+/** O contexto que o `useRouter` do Next lê. O host que manda na rota fornece um. */
+declare const RouterContext: react.Context<NextRouter | null>;
+/** `href` do Next (texto ou objeto) como texto. */
+declare function formatUrl(url: Url): string;
+/** `useRouter` de `next/router`: o do `RouterContext`, se houver, senão o da URL. */
+declare function useRouter(): NextRouter;
+/** `Router` (export default de `next/router`): o do host dentro do `NextRemote`, senão o da URL. */
+declare const Router: NextRouter;
+declare function withRouter<P extends object>(Component: ComponentType<P & {
+    router: NextRouter;
+}>): ComponentType<P>;
+interface AppRouter {
+    push(href: string, options?: {
+        scroll?: boolean;
+    }): void;
+    replace(href: string, options?: {
+        scroll?: boolean;
+    }): void;
+    back(): void;
+    forward(): void;
+    refresh(): void;
+    prefetch(href: string): void;
+}
+/** `useRouter` de `next/navigation`. */
+declare function useAppRouter(): AppRouter;
+declare function usePathname(): string;
+declare function useSearchParams(): URLSearchParams;
+declare function useParams<T extends Record<string, string | string[]> = Record<string, string | string[]>>(): T;
+declare function redirect(url: string): never;
+declare function notFound(): never;
+type LinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {
+    href: Url;
+    as?: Url;
+    replace?: boolean;
+    scroll?: boolean;
+    shallow?: boolean;
+    prefetch?: boolean | null;
+    passHref?: boolean;
+    legacyBehavior?: boolean;
+    locale?: string | false;
+    children?: ReactNode;
+};
+declare const Link: react.ForwardRefExoticComponent<Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    href: Url;
+    as?: Url;
+    replace?: boolean;
+    scroll?: boolean;
+    shallow?: boolean;
+    prefetch?: boolean | null;
+    passHref?: boolean;
+    legacyBehavior?: boolean;
+    locale?: string | false;
+    children?: ReactNode;
+} & react.RefAttributes<HTMLAnchorElement>>;
+type StaticImage = {
+    src: string;
+    width?: number;
+    height?: number;
+};
+type ImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'width' | 'height' | 'loading'> & {
+    src: string | StaticImage;
+    alt: string;
+    width?: number | string;
+    height?: number | string;
+    fill?: boolean;
+    priority?: boolean;
+    loading?: 'eager' | 'lazy';
+    quality?: number | string;
+    placeholder?: string;
+    blurDataURL?: string;
+    unoptimized?: boolean;
+    overrideSrc?: string;
+    loader?: (p: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    onLoadingComplete?: (img: HTMLImageElement) => void;
+};
+declare const Image: react.ForwardRefExoticComponent<Omit<ImgHTMLAttributes<HTMLImageElement>, "loading" | "src" | "width" | "height"> & {
+    src: string | StaticImage;
+    alt: string;
+    width?: number | string;
+    height?: number | string;
+    fill?: boolean;
+    priority?: boolean;
+    loading?: "eager" | "lazy";
+    quality?: number | string;
+    placeholder?: string;
+    blurDataURL?: string;
+    unoptimized?: boolean;
+    overrideSrc?: string;
+    loader?: (p: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    onLoadingComplete?: (img: HTMLImageElement) => void;
+} & react.RefAttributes<HTMLImageElement>>;
+/** O React 19 já leva `<title>`, `<meta>` e `<link>` para o `<head>`. */
+declare function Head({ children }: {
+    children?: ReactNode;
+}): react.FunctionComponentElement<react.FragmentProps>;
+type Loader<P> = () => Promise<ComponentType<P> | {
+    default: ComponentType<P>;
+}>;
+declare function dynamic<P extends object = object>(loader: Loader<P> | Promise<ComponentType<P> | {
+    default: ComponentType<P>;
+}>, options?: {
+    loading?: ComponentType<any>;
+    ssr?: boolean;
+}): ComponentType<P>;
+/** Rota pública do host e o caminho dela na zona (como no `rewrites` do Multi-Zones). */
+interface ZoneRoute {
+    public: string;
+    zone: string;
+}
+/** O que o `NextRemote` do host passa ao remote, na prop `__next`. */
+interface HostRouter {
+    /** `asPath` do host: a URL do navegador. */
+    asPath: string;
+    /** `basePath` do remote, como no `next.config` da zona. */
+    basePath?: string;
+    routes?: ZoneRoute[];
+    push(url: string, options?: {
+        scroll?: boolean;
+    }): void;
+    replace(url: string, options?: {
+        scroll?: boolean;
+    }): void;
+    /** `Router.events` do host: `routeChangeStart`, `routeChangeComplete`… chegam ao remote. */
+    events?: NextRouter['events'];
+}
+/**
+ * O roteador que o remote vê dentro do host: caminhos como numa zona com
+ * `basePath` (a URL pública vira o caminho da zona, sem o `basePath`), e
+ * `push` volta pelo roteador do host, com a rota pública.
+ */
+declare function hostRouter(host: HostRouter): NextRouter;
+/**
+ * Embrulha o `export default` do remote no modo `next` do plugin: com a prop
+ * `__next` (vinda do `NextRemote` do host), os componentes leem o roteador do
+ * host; sem ela, o da URL.
+ */
+declare function nextRemote<P extends object>(Component: ComponentType<P>): ComponentType<P & {
+    __next?: HostRouter;
+}>;
+
+export { type AppRouter, Head, type HostRouter, Image, type ImageProps, Link, type LinkProps, type NextRouter, Router, RouterContext, type Url, type ZoneRoute, dynamic, formatUrl, hostRouter, nextRemote, notFound, redirect, setBasePath, useAppRouter, useParams, usePathname, useRouter, useSearchParams, withRouter };

package/dist/next.js

@@ -0,0 +1,287 @@
+"use client";
+import {
+  navigate
+} from "./chunk-EQZOJU3B.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/next.tsx
+import {
+  Children,
+  cloneElement,
+  createContext,
+  createElement,
+  forwardRef,
+  Fragment,
+  isValidElement,
+  lazy,
+  Suspense,
+  useContext,
+  useEffect,
+  useMemo,
+  useSyncExternalStore
+} from "react";
+var base = "";
+function setBasePath(path = "") {
+  base = path.replace(/\/+$/, "");
+}
+var RouterContext = createContext(null);
+var listeners = /* @__PURE__ */ new Set();
+var changed = () => listeners.forEach((fn) => fn());
+function subscribe(fn) {
+  listeners.add(fn);
+  addEventListener("popstate", fn);
+  return () => {
+    listeners.delete(fn);
+    removeEventListener("popstate", fn);
+  };
+}
+var here = () => typeof location === "undefined" ? "/" : location.pathname + location.search + location.hash;
+var inBase = (path) => !base || path === base || path.startsWith(base + "/");
+function strip(path) {
+  return base && inBase(path) ? path.slice(base.length) || "/" : path;
+}
+function queryString(query) {
+  if (!query) return "";
+  if (typeof query === "string") return query.replace(/^\??/, query ? "?" : "");
+  const params = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (Array.isArray(v)) v.forEach((x) => params.append(k, x));
+    else if (v != null) params.append(k, String(v));
+  }
+  const s = params.toString();
+  return s ? "?" + s : "";
+}
+function formatUrl(url) {
+  if (typeof url === "string") return url;
+  const hash = url.hash ? "#" + url.hash.replace(/^#/, "") : "";
+  return (url.pathname ?? "") + queryString(url.query) + hash;
+}
+function withBase(href, prefix = base) {
+  return prefix && href.startsWith("/") && !href.startsWith("//") ? prefix + (href === "/" ? "" : href) : href;
+}
+var isExternal = (href) => /^[a-z][a-z\d+.-]*:/i.test(href) || href.startsWith("//");
+function go(url, replace) {
+  const target = new URL(withBase(formatUrl(url)), location.href);
+  if (target.origin !== location.origin || !inBase(target.pathname)) {
+    navigate(target.href, { replace });
+    return Promise.resolve(true);
+  }
+  history[replace ? "replaceState" : "pushState"](history.state, "", target.href);
+  changed();
+  return Promise.resolve(true);
+}
+function emitter() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    on: (t, fn) => void (map.get(t) ?? map.set(t, /* @__PURE__ */ new Set()).get(t)).add(fn),
+    off: (t, fn) => void map.get(t)?.delete(fn),
+    emit: (t, ...args) => map.get(t)?.forEach((fn) => fn(...args))
+  };
+}
+var routerEvents = emitter();
+function locationRouter(current) {
+  const url = new URL(current, "http://x");
+  const query = {};
+  url.searchParams.forEach((v, k) => {
+    const prev = query[k];
+    query[k] = prev === void 0 ? v : [].concat(prev, v);
+  });
+  const pathname = strip(url.pathname);
+  return {
+    pathname,
+    route: pathname,
+    asPath: pathname + url.search + url.hash,
+    // shortcut: sem tabela de rotas, os segmentos dinâmicos ([id]) não entram em `query`; passe-os por props ou por RouterContext.
+    query,
+    basePath: base,
+    isReady: true,
+    isFallback: false,
+    isPreview: false,
+    isLocaleDomain: false,
+    push: (u, as) => go(as ?? u, false),
+    replace: (u, as) => go(as ?? u, true),
+    back: () => history.back(),
+    forward: () => history.forward(),
+    reload: () => location.reload(),
+    prefetch: () => Promise.resolve(),
+    beforePopState: () => {
+    },
+    events: routerEvents
+  };
+}
+function useRouter() {
+  const provided = useContext(RouterContext);
+  const current = useSyncExternalStore(subscribe, here, () => "/");
+  const own = useMemo(() => locationRouter(current), [current]);
+  return provided ?? own;
+}
+var mounted = null;
+var Router = new Proxy({}, {
+  get: (_, key) => (mounted ?? locationRouter(here()))[key]
+});
+function withRouter(Component) {
+  return (props) => createElement(Component, { ...props, router: useRouter() });
+}
+function useAppRouter() {
+  const router = useRouter();
+  return useMemo(
+    () => ({
+      push: (href) => void router.push(href),
+      replace: (href) => void router.replace(href),
+      back: () => router.back(),
+      forward: () => router.forward(),
+      refresh: changed,
+      prefetch: () => {
+      }
+    }),
+    [router]
+  );
+}
+function usePathname() {
+  return useRouter().pathname;
+}
+function useSearchParams() {
+  const { asPath } = useRouter();
+  return useMemo(() => new URL(asPath, "http://x").searchParams, [asPath]);
+}
+var noParams = Object.freeze({});
+function useParams() {
+  return noParams;
+}
+function redirect(url) {
+  void (mounted ? mounted.replace(url) : go(url, true));
+  throw new Error(`NEXT_REDIRECT;${url}`);
+}
+function notFound() {
+  throw new Error("NEXT_NOT_FOUND");
+}
+var Link = forwardRef(function Link2({ href, as, replace, scroll, shallow: _s, prefetch: _p, passHref: _ph, legacyBehavior, locale: _l, onClick, children, ...rest }, ref) {
+  const router = useRouter();
+  const target = formatUrl(as ?? href);
+  const external = isExternal(target);
+  const shown = external ? target : router.hrefOf?.(target) ?? withBase(target, router.basePath);
+  const click = (e) => {
+    onClick?.(e);
+    const self = !rest.target || rest.target === "_self";
+    if (e.defaultPrevented || external || !self || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+    e.preventDefault();
+    void (replace ? router.replace(target) : router.push(target));
+    if (scroll !== false && typeof scrollTo === "function") scrollTo(0, 0);
+  };
+  if (legacyBehavior && isValidElement(children)) {
+    const child = Children.only(children);
+    return cloneElement(child, { href: shown, ref, onClick: (e) => (child.props.onClick?.(e), click(e)) });
+  }
+  return createElement("a", { ...rest, href: shown, ref, onClick: click }, children);
+});
+var Image = forwardRef(function Image2({ src, width, height, fill, priority, loading, quality, placeholder: _ph, blurDataURL: _b, unoptimized: _u, overrideSrc, loader, onLoadingComplete, onLoad, style, ...rest }, ref) {
+  const image = typeof src === "object" ? src : void 0;
+  const raw = image?.src ?? src;
+  const w = width ?? image?.width;
+  const h = height ?? image?.height;
+  const url = overrideSrc ?? (loader ? loader({ src: raw, width: Number(w) || 0, quality: quality == null ? void 0 : Number(quality) }) : raw);
+  const fillStyle = fill ? { position: "absolute", inset: 0, width: "100%", height: "100%" } : void 0;
+  return createElement("img", {
+    ...rest,
+    ref,
+    src: url,
+    width: fill ? void 0 : w,
+    height: fill ? void 0 : h,
+    decoding: "async",
+    loading: priority ? "eager" : loading ?? "lazy",
+    fetchPriority: priority ? "high" : void 0,
+    style: fillStyle ? { ...fillStyle, ...style } : style,
+    onLoad: (e) => (onLoad?.(e), onLoadingComplete?.(e.currentTarget))
+  });
+});
+function Head({ children }) {
+  return createElement(Fragment, null, children);
+}
+function dynamic(loader, options = {}) {
+  const Lazy = lazy(async () => {
+    const m = await (typeof loader === "function" ? loader() : loader);
+    return { default: m && typeof m === "object" && "default" in m ? m.default : m };
+  });
+  const fallback = options.loading ? createElement(options.loading, { isLoading: true, pastDelay: true, error: null }) : null;
+  return (props) => createElement(Suspense, { fallback }, createElement(Lazy, props));
+}
+var under = (path, prefix) => path === prefix || path.startsWith(prefix + "/");
+function mapPath(path, routes, from) {
+  const to = from === "public" ? "zone" : "public";
+  let best;
+  for (const r of routes) if (under(path, r[from]) && (!best || r[from].length > best[from].length)) best = r;
+  return best ? best[to] + path.slice(best[from].length) : path;
+}
+function hostRouter(host) {
+  const basePath = (host.basePath ?? base).replace(/\/+$/, "");
+  const routes = host.routes ?? [];
+  const url = new URL(host.asPath, "http://x");
+  const zone = mapPath(url.pathname, routes, "public");
+  const pathname = basePath && under(zone, basePath) ? zone.slice(basePath.length) || "/" : zone;
+  const query = {};
+  url.searchParams.forEach((v, k) => {
+    const prev = query[k];
+    query[k] = prev === void 0 ? v : [].concat(prev, v);
+  });
+  const hrefOf = (path) => path.startsWith("/") && !path.startsWith("//") ? mapPath(withBase(path, basePath) || "/", routes, "zone") : path;
+  const go2 = (target, replace, options) => {
+    const next = formatUrl(target);
+    if (isExternal(next)) navigate(next, { replace });
+    else (replace ? host.replace : host.push)(hrefOf(next), options);
+    return Promise.resolve(true);
+  };
+  return {
+    pathname,
+    route: pathname,
+    asPath: pathname + url.search + url.hash,
+    query,
+    basePath,
+    isReady: true,
+    isFallback: false,
+    isPreview: false,
+    isLocaleDomain: false,
+    push: (u, as, o) => go2(as ?? u, false, o),
+    replace: (u, as, o) => go2(as ?? u, true, o),
+    back: () => history.back(),
+    forward: () => history.forward(),
+    reload: () => location.reload(),
+    prefetch: () => Promise.resolve(),
+    beforePopState: () => {
+    },
+    events: host.events ?? routerEvents,
+    hrefOf
+  };
+}
+function nextRemote(Component) {
+  return function NextRemote({ __next: host, ...props }) {
+    const router = useMemo(() => host && hostRouter(host), [host?.asPath, host?.basePath, host?.routes, host?.push, host?.replace, host?.events]);
+    if (router) mounted = router;
+    useEffect(() => {
+      if (!router) return;
+      mounted = router;
+      return () => void (mounted === router && (mounted = null));
+    }, [router]);
+    const app = createElement(Component, props);
+    return router ? createElement(RouterContext.Provider, { value: router }, app) : app;
+  };
+}
+export {
+  Head,
+  Image,
+  Link,
+  Router,
+  RouterContext,
+  dynamic,
+  formatUrl,
+  hostRouter,
+  nextRemote,
+  notFound,
+  redirect,
+  setBasePath,
+  useAppRouter,
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams,
+  withRouter
+};

package/dist/preact.d.ts

@@ -1,10 +1,10 @@
 import * as preact from 'preact';
 import { VNode, ComponentType } from 'preact';
-import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-EOz1rOHs.js';
-export { R as RemoteContext } from './types-EOz1rOHs.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-wsKR1gfx.js';
+export { R as RemoteContext } from './types-wsKR1gfx.js';
 import { R as RemoteError } from './errors-kjBv6IH_.js';
-import { S as SlotStatus } from './slot-Ddzp7AgL.js';
-export { e as events } from './events-DLdbFqBM.js';
+import { S as SlotStatus } from './slot-Dhczjs1E.js';
+export { e as events } from './events-Cieg_far.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 

package/dist/preact.js

@@ -1,15 +1,17 @@
 import {
   hostSlot
-} from "./chunk-TXSHK3SK.js";
+} from "./chunk-ZJ4IM2PZ.js";
 import {
   defineRemote,
-  events,
   memoSelect,
-  navigate,
   same,
   shared
-} from "./chunk-O7DV3EVB.js";
-import "./chunk-72H4FXMD.js";
+} from "./chunk-NTXMEZIZ.js";
+import {
+  events,
+  navigate
+} from "./chunk-EQZOJU3B.js";
+import "./chunk-6T25WKNK.js";
 import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";

package/dist/prefetch.js

@@ -1,6 +1,6 @@
 import {
   resolveEntry
-} from "./chunk-72H4FXMD.js";
+} from "./chunk-6T25WKNK.js";
 import "./chunk-KU6HF2EW.js";
 import {
   addLink
@@ -151,7 +151,7 @@ function modulepreload(href) {
 }
 async function verifiedOnly(r) {
   const b = r.split ?? { entry: r.entry, chunks: [], sri: { [r.entry]: r.integrity }, priority: "low" };
-  const { verified } = await import("./sri-576GTDIA.js");
+  const { verified } = await import("./sri-TBZ6PYYY.js");
   const url = await verified(b);
   if (!url) await Promise.all([...b.chunks, b.entry].map(heat));
   else if (!document.querySelector(`link[rel=modulepreload][href="${CSS.escape(url)}"]`)) await heat(url);

package/dist/react-server.d.ts

@@ -1,5 +1,5 @@
 import { ComponentType } from 'react';
-import { P as Props } from './types-EOz1rOHs.js';
+import { P as Props } from './types-wsKR1gfx.js';
 import './errors-kjBv6IH_.js';
 
 /**

package/dist/react.d.ts

@@ -1,9 +1,10 @@
 import { ReactNode, ComponentType } from 'react';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 import * as JSXRuntime from 'react/jsx-runtime';
-import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared, R as RemoteContext } from './types-EOz1rOHs.js';
-export { E as EventBus } from './types-EOz1rOHs.js';
-export { e as events } from './events-DLdbFqBM.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared, R as RemoteContext } from './types-wsKR1gfx.js';
+export { E as EventBus } from './types-wsKR1gfx.js';
+import { P as PreloadOptions } from './loader-BIXjuvvp.js';
+export { e as events } from './events-Cieg_far.js';
 import './errors-kjBv6IH_.js';
 
 /**
@@ -64,6 +65,12 @@ interface RemoteProps<P extends Props = Props> {
     /** Ao sair da página, guarda o remote montado (LRU, padrão 5) e na volta só atualiza as props. */
     keepAlive?: boolean | number;
 }
+/**
+ * Começa a baixar um remote antes de algum `<Remote>` montar (no ocioso, no
+ * hover). Já oferece o React do host, para o remote com `dedupe` não baixar
+ * a própria cópia.
+ */
+declare function preload(name: string, options?: PreloadOptions): void;
 /**
  * Renderiza um remote. No servidor (Next SSR) renderiza só o fallback; o
  * remote monta no cliente, então não há erro de hidratação. Com o nome em
@@ -71,4 +78,4 @@ interface RemoteProps<P extends Props = Props> {
  */
 declare function Remote<P extends Props = Props, N extends string = string>({ name, src, props, isolate, fallback, error, onError, className, loading, prefetch, priority, keepAlive, }: RemoteProps<P> & CheckedProps<N>): JSXRuntime.JSX.Element;
 
-export { Remote, type RemoteProps, reactRemote, useEvent, useEventValue, usePortalContainer, useShared, useVitral };
+export { Remote, type RemoteProps, preload, reactRemote, useEvent, useEventValue, usePortalContainer, useShared, useVitral };