@web-widget/vue 3.0.0-beta.2 → 3.0.0-beta.5

package/dist/chunk-ER6EL6Y7.js

@@ -0,0 +1,174 @@
+// src/error-handler.ts
+import { cacheProviderIsLoading } from "@web-widget/helpers/cache";
+function installErrorHandler(app, callback, throwUnhandledErrorInProduction = false) {
+  app.config.throwUnhandledErrorInProduction = throwUnhandledErrorInProduction;
+  app.config.errorHandler = (err, instance, info) => {
+    if (cacheProviderIsLoading(err)) {
+      return;
+    }
+    app.config.warnHandler = () => {
+    };
+    callback(err);
+  };
+}
+
+// src/components.ts
+import { WebWidgetRenderer } from "@web-widget/web-widget";
+import {
+  h,
+  cloneVNode,
+  defineComponent,
+  Suspense,
+  useAttrs,
+  getCurrentInstance,
+  ref,
+  onErrorCaptured
+} from "vue";
+function renderLightChildren(slots) {
+  return Object.entries(slots).flatMap(
+    ([name, render]) => render ? render().map(
+      (node) => name === "default" ? node : cloneVNode(node, { slot: name })
+    ) : []
+  );
+}
+var ServerWebWidget = /* @__PURE__ */ defineComponent({
+  name: "ServerWebWidget",
+  props: {
+    errorFallback: {
+      type: Object,
+      default: null
+    },
+    renderer: {
+      type: Object,
+      required: true
+    },
+    renderChildren: {
+      type: Function,
+      required: true
+    }
+  },
+  async setup({ renderer, errorFallback, renderChildren }, { slots }) {
+    const parent = getCurrentInstance();
+    const children = Object.keys(slots).length ? await renderChildren(renderLightChildren(slots), parent) : "";
+    const tag = renderer.localName;
+    const attrs = renderer.attributes;
+    const innerHTML = await renderer.renderInnerHTMLToString({ children }).catch((err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("[VueWidget] Rendering error:", error);
+      return error;
+    });
+    if (innerHTML instanceof Error) {
+      return () => errorFallback;
+    }
+    return () => h(tag, { ...attrs, innerHTML });
+  }
+});
+function resolveFallback(fallback) {
+  var _a;
+  if (fallback !== null && typeof fallback === "object" && !("__v_isVNode" in fallback) && ("pending" in fallback || "error" in fallback)) {
+    const obj = fallback;
+    return {
+      pendingFallback: obj.pending,
+      errorFallback: (_a = obj.error) != null ? _a : obj.pending
+    };
+  }
+  return {
+    pendingFallback: fallback,
+    errorFallback: fallback
+  };
+}
+function createWidgetAdapter(renderChildren) {
+  return (loader, options = {}) => defineComponent({
+    name: "VueWidget",
+    inheritAttrs: false,
+    props: {
+      widget: {
+        type: Object,
+        default: () => ({})
+      }
+    },
+    setup({ widget }, { slots }) {
+      const { fallback, id, loading = options.loading, clientOnly } = widget;
+      const { pendingFallback, errorFallback } = resolveFallback(fallback);
+      const renderOptions = {
+        ...options,
+        clientOnly: widget.clientOnly,
+        id,
+        loading: loading != null ? loading : options.loading,
+        serverOnly: widget.serverOnly
+      };
+      const attrs = { ...useAttrs() };
+      const slot = typeof attrs.slot === "string" ? attrs.slot : void 0;
+      delete attrs.slot;
+      const data = attrs;
+      const renderer = new WebWidgetRenderer(loader, {
+        ...renderOptions,
+        data,
+        slot
+      });
+      if (renderer.opaqueInnerHTML !== void 0) {
+        return () => {
+          const lightChildren = Object.keys(slots).length ? renderLightChildren(slots) : [];
+          return h(
+            renderer.localName,
+            {
+              ...renderer.attributes,
+              ...lightChildren.length === 0 ? { innerHTML: renderer.opaqueInnerHTML } : null
+            },
+            lightChildren.length ? lightChildren : void 0
+          );
+        };
+      }
+      if (clientOnly && pendingFallback) {
+        return () => h(
+          renderer.localName,
+          renderer.attributes,
+          h(
+            renderer.pendingBoundary.localName,
+            {
+              "aria-busy": renderer.pendingBoundary.ariaBusy,
+              slot: renderer.pendingBoundary.slot,
+              style: { display: renderer.pendingBoundary.display }
+            },
+            pendingFallback
+          )
+        );
+      }
+      if (!renderChildren) {
+        throw new TypeError("Missing server children renderer.");
+      }
+      const error = ref(null);
+      onErrorCaptured((err) => {
+        error.value = err;
+        return false;
+      });
+      return () => {
+        if (error.value && errorFallback) {
+          return errorFallback;
+        }
+        return h(
+          Suspense,
+          {},
+          {
+            default: h(
+              ServerWebWidget,
+              {
+                errorFallback,
+                renderChildren,
+                renderer
+              },
+              slots
+            ),
+            fallback: pendingFallback
+          }
+        );
+      };
+    }
+  });
+}
+
+export {
+  installErrorHandler,
+  resolveFallback,
+  createWidgetAdapter
+};

package/dist/types-Q7wIvDbF.d.ts

@@ -0,0 +1,48 @@
+import { WidgetHostProps, WidgetContainerProps, WidgetContainerOptions, ExtractWidgetProps, WidgetModuleLoader } from '@web-widget/schema';
+import { DefineComponent, VNode, App, Component } from 'vue';
+
+/**
+ * A Vue component wrapping a widget, with props `T` plus container config.
+ */
+type VueWidgetComponent<T = unknown> = DefineComponent<T & WidgetHostProps & {
+    widget?: VueWidgetContainerProps;
+}>;
+type VueWidgetContainerProps = WidgetContainerProps<VNode>;
+/**
+ * Resolve a WidgetFallback into separate pending and error VNodes.
+ * - `VNode` — used for both pending and error.
+ * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
+ */
+declare function resolveFallback(fallback: VueWidgetContainerProps['fallback']): {
+    pendingFallback: VNode;
+    errorFallback: VNode;
+};
+/**
+ * Container function (AdapterModule contract).
+ *
+ * Wraps a widget module loader into a Vue component with props type
+ * inference from the source module's default export.
+ *
+ * @example
+ * ```ts
+ * import { widget } from '@web-widget/vue/adapter';
+ *
+ * const Counter = widget(() => import('./Counter@widget.vue'));
+ * //    ^? VueWidgetComponent<{ count: number }>
+ * ```
+ */
+interface VueWidgetFactory {
+    <M>(loader: () => Promise<M>, options?: WidgetContainerOptions): VueWidgetComponent<ExtractWidgetProps<M>>;
+    <Props>(loader: WidgetModuleLoader, options?: WidgetContainerOptions): VueWidgetComponent<Props>;
+}
+
+interface CreateVueRenderOptions {
+    onCreatedApp?: (app: App<Element>, context: {
+        container?: Element | DocumentFragment;
+        data: any;
+        progressive?: boolean;
+        recovering?: boolean;
+    }, component: Component, props: any) => Promise<void>;
+}
+
+export { type CreateVueRenderOptions as C, type VueWidgetFactory as V, type VueWidgetComponent as a, type VueWidgetContainerProps as b, resolveFallback as r };

package/dist/vue.adapter.client.d.ts

@@ -1,14 +1,15 @@
 import * as _web_widget_schema from '@web-widget/schema';
+export { WidgetContainerOptions } from '@web-widget/schema';
+import { C as CreateVueRenderOptions, V as VueWidgetFactory } from './types-Q7wIvDbF.js';
+export { a as VueWidgetComponent, b as VueWidgetContainerProps, r as resolveFallback } from './types-Q7wIvDbF.js';
 import { Component } from 'vue';
-import { C as CreateVueRenderOptions } from './types-BY8s0m9C.js';
-export { D as DefineWebWidgetOptions, V as VueWidgetComponent, W as WidgetContainerConfig, a as WidgetFallback, c as container, r as resolveFallback } from './types-BY8s0m9C.js';
 export { asReactWidget, toReact } from './vue.js';
-import '@web-widget/web-widget';
 import '@web-widget/react/adapter';
 
+declare const widget: VueWidgetFactory;
 declare const createVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_schema.ClientRender<Component, unknown, _web_widget_schema.ClientRenderOptions, void | _web_widget_schema.ClientRenderResult<unknown>>;
 /**@deprecated Please use `createVueRender` instead.*/
 declare const defineVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_schema.ClientRender<Component, unknown, _web_widget_schema.ClientRenderOptions, void | _web_widget_schema.ClientRenderResult<unknown>>;
 declare const render: _web_widget_schema.ClientRender<Component, unknown, _web_widget_schema.ClientRenderOptions, void | _web_widget_schema.ClientRenderResult<unknown>>;
 
-export { createVueRender, defineVueRender, render };
+export { VueWidgetFactory, createVueRender, defineVueRender, render, widget };

package/dist/vue.adapter.client.js

@@ -1,8 +1,8 @@
 import {
-  container,
+  createWidgetAdapter,
   installErrorHandler,
   resolveFallback
-} from "./chunk-7KXT6LS2.js";
+} from "./chunk-ER6EL6Y7.js";
 import {
   asReactWidget,
   toReact
@@ -11,22 +11,23 @@ import {
 // src/adapter.client.ts
 import { defineClientRender } from "@web-widget/helpers";
 import { Suspense, createApp, createSSRApp, h } from "vue";
+var widget = createWidgetAdapter();
 var createWidgetSuspense = (component) => (props) => h(Suspense, null, [h(component, props)]);
 var createVueRender = ({
   onCreatedApp = async () => {
   }
 } = {}) => {
   return defineClientRender(
-    async (component, data, { recovering, container: container2 }) => {
+    async (component, data, { recovering, container }) => {
       data = data != null ? data : {};
       if (!component) {
         throw new TypeError(`Missing component.`);
       }
-      if (!container2) {
+      if (!container) {
         throw new Error(`Missing container.`);
       }
       let app;
-      const context = { data, recovering, container: container2 };
+      const context = { data, recovering, container };
       const WidgetSuspense = createWidgetSuspense(component);
       return {
         async mount() {
@@ -36,7 +37,7 @@ var createVueRender = ({
             error = err;
           });
           await onCreatedApp(app, context, component, data);
-          app.mount(container2);
+          app.mount(container);
           if (error) {
             throw error;
           }
@@ -53,10 +54,10 @@ var defineVueRender = createVueRender;
 var render = createVueRender();
 export {
   asReactWidget,
-  container,
   createVueRender,
   defineVueRender,
   render,
   resolveFallback,
-  toReact
+  toReact,
+  widget
 };

package/dist/vue.adapter.server.d.ts

@@ -1,10 +1,10 @@
 import * as _web_widget_schema from '@web-widget/schema';
+export { WidgetContainerOptions } from '@web-widget/schema';
+import { C as CreateVueRenderOptions, V as VueWidgetFactory } from './types-Q7wIvDbF.js';
+export { a as VueWidgetComponent, b as VueWidgetContainerProps, r as resolveFallback } from './types-Q7wIvDbF.js';
 import { Component } from 'vue';
 import { SSRContext } from 'vue/server-renderer';
-import { C as CreateVueRenderOptions } from './types-BY8s0m9C.js';
-export { D as DefineWebWidgetOptions, V as VueWidgetComponent, W as WidgetContainerConfig, a as WidgetFallback, c as container, r as resolveFallback } from './types-BY8s0m9C.js';
 export { asReactWidget, toReact } from './vue.js';
-import '@web-widget/web-widget';
 import '@web-widget/react/adapter';
 
 declare module '@web-widget/schema' {
@@ -13,6 +13,7 @@ declare module '@web-widget/schema' {
     }
 }
 
+declare const widget: VueWidgetFactory;
 interface VueRenderOptions {
     vue?: SSRContext;
 }
@@ -21,4 +22,4 @@ declare const createVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _
 declare const defineVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_schema.ServerRender<Component, unknown, _web_widget_schema.ServerRenderOptions, _web_widget_schema.ServerRenderResult>;
 declare const render: _web_widget_schema.ServerRender<Component, unknown, _web_widget_schema.ServerRenderOptions, _web_widget_schema.ServerRenderResult>;
 
-export { type VueRenderOptions, createVueRender, defineVueRender, render };
+export { type VueRenderOptions, VueWidgetFactory, createVueRender, defineVueRender, render, widget };

package/dist/vue.adapter.server.js

@@ -1,8 +1,8 @@
 import {
-  container,
+  createWidgetAdapter,
   installErrorHandler,
   resolveFallback
-} from "./chunk-7KXT6LS2.js";
+} from "./chunk-ER6EL6Y7.js";
 import {
   asReactWidget,
   toReact
@@ -13,8 +13,25 @@ import { defineServerRender } from "@web-widget/helpers";
 import { createSSRApp, h, Suspense } from "vue";
 import {
   renderToString,
-  renderToWebStream
+  renderToWebStream,
+  ssrRenderVNode
 } from "vue/server-renderer";
+async function resolveSSRBuffer(value) {
+  const resolved = await value;
+  if (Array.isArray(resolved)) {
+    let html = "";
+    for (const item of resolved) html += await resolveSSRBuffer(item);
+    return html;
+  }
+  return typeof resolved === "string" ? resolved : "";
+}
+var widget = createWidgetAdapter(async (nodes, parent) => {
+  const buffer = [];
+  for (const node of nodes) {
+    ssrRenderVNode((item) => buffer.push(item), node, parent);
+  }
+  return resolveSSRBuffer(buffer);
+});
 var createWidgetSuspense = (component) => (props) => h(Suspense, null, [h(component, props)]);
 var createVueRender = ({
   onCreatedApp = async () => {
@@ -37,8 +54,8 @@ var createVueRender = ({
       });
       await onCreatedApp(app, context, component, data);
       if (progressive) {
-        const stream = renderToWebStream(app, ssrContext);
-        const reader = stream.getReader();
+        const byteStream = renderToWebStream(app, ssrContext);
+        const reader = byteStream.getReader();
         const first = await reader.read();
         try {
           if (ssrContext == null ? void 0 : ssrContext.teleports) {
@@ -99,10 +116,10 @@ var defineVueRender = createVueRender;
 var render = createVueRender();
 export {
   asReactWidget,
-  container,
   createVueRender,
   defineVueRender,
   render,
   resolveFallback,
-  toReact
+  toReact,
+  widget
 };

package/dist/vue.d.ts

@@ -4,15 +4,15 @@ import { ReactWidgetComponent } from '@web-widget/react/adapter';
 /**
  * Adapt Vue component types to React widget component types.
  *
- * @deprecated Use `container()` from `@web-widget/react/adapter` instead.
+ * @deprecated Use `widget()` from `@web-widget/react/adapter` instead.
  * The build tool automatically infers props types for both static imports
- * and explicit `container(() => import(...))` calls.
+ * and explicit `widget(() => import(...))` calls.
  *
  * This is a type-level cast only — the actual cross-framework rendering
  * is handled by the `@widget` system.
  */
 declare function asReactWidget<T>(component: Component<T>): ReactWidgetComponent<Omit<T, keyof ComponentPublicInstance | "$route" | "$router">>;
-/** @deprecated Use `container()` from `@web-widget/react/adapter` instead. */
+/** @deprecated Use `widget()` from `@web-widget/react/adapter` instead. */
 declare const toReact: typeof asReactWidget;
 
 export { asReactWidget, toReact };

package/dist/vue.transform.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    name: string;
+    extensions: string[];
+    adapter: string;
+    deriveExports: {
+        name: string;
+        default: string;
+    }[];
+};
+
+export { _default as default };

package/dist/vue.transform.js

@@ -0,0 +1,13 @@
+// src/transform.ts
+var transform_default = {
+  name: "vue",
+  extensions: [".vue"],
+  adapter: "@web-widget/vue/adapter",
+  deriveExports: [
+    { name: "handler", default: "{GET({html}){return html()}}" },
+    { name: "meta", default: "{}" }
+  ]
+};
+export {
+  transform_default as default
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-widget/vue",
   "description": "Vue adapter",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.5",
   "homepage": "https://github.com/web-widget/web-widget#readme",
   "repository": {
     "type": "git",
@@ -13,54 +13,47 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@web-widget/helpers": "3.0.0-beta.2",
-    "@web-widget/schema": "3.0.0-beta.2",
-    "@web-widget/web-widget": "3.0.0-beta.2",
-    "@web-widget/react": "3.0.0-beta.2"
+    "@web-widget/helpers": "workspace:*",
+    "@web-widget/web-widget": "workspace:*",
+    "@web-widget/schema": "workspace:*",
+    "@web-widget/react": "workspace:*"
   },
   "devDependencies": {
-    "tsup": "^8.3.4",
-    "typescript": "^5.9.3",
+    "happy-dom": "14.12.3",
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:",
     "vue": "^3.5.34"
   },
   "exports": {
     ".": {
       "types": "./dist/vue.d.ts",
+      "development": "./src/index.ts",
       "default": "./dist/vue.js"
     },
+    "./transform": {
+      "types": "./dist/vue.transform.d.ts",
+      "development": "./src/transform.ts",
+      "default": "./dist/vue.transform.js"
+    },
     "./adapter": {
       "worker": {
         "types": "./dist/vue.adapter.server.d.ts",
+        "development": "./src/adapter.server.ts",
         "default": "./dist/vue.adapter.server.js"
       },
       "browser": {
         "types": "./dist/vue.adapter.client.d.ts",
+        "development": "./src/adapter.client.ts",
         "default": "./dist/vue.adapter.client.js"
       },
       "default": {
         "types": "./dist/vue.adapter.server.d.ts",
+        "development": "./src/adapter.server.ts",
         "default": "./dist/vue.adapter.server.js"
       }
     }
   },
-  "webWidgetAdapter": {
-    "version": "1.0.0",
-    "name": "vue",
-    "extensions": [
-      ".vue"
-    ],
-    "adapter": "./adapter",
-    "deriveExports": [
-      {
-        "name": "handler",
-        "default": "{GET({html}){return html()}}"
-      },
-      {
-        "name": "meta",
-        "default": "{}"
-      }
-    ]
-  },
   "files": [
     "dist"
   ],
@@ -68,16 +61,41 @@
     "vue": ">3.3.3"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/vue.d.ts",
+        "default": "./dist/vue.js"
+      },
+      "./transform": {
+        "types": "./dist/vue.transform.d.ts",
+        "default": "./dist/vue.transform.js"
+      },
+      "./adapter": {
+        "worker": {
+          "types": "./dist/vue.adapter.server.d.ts",
+          "default": "./dist/vue.adapter.server.js"
+        },
+        "browser": {
+          "types": "./dist/vue.adapter.client.d.ts",
+          "default": "./dist/vue.adapter.client.js"
+        },
+        "default": {
+          "types": "./dist/vue.adapter.server.d.ts",
+          "default": "./dist/vue.adapter.server.js"
+        }
+      }
+    }
   },
-  "sideEffects": false,
-  "type": "module",
   "scripts": {
     "build": "pnpm exec tsup",
     "clean:build": "rm -rf dist",
     "clean:node": "rm -rf node_modules",
     "dev": "pnpm exec tsup --watch",
     "lint": "eslint src",
-    "prebuild": "pnpm run clean:build"
-  }
-}
+    "prebuild": "pnpm run clean:build",
+    "test": "vitest run"
+  },
+  "sideEffects": false,
+  "type": "module"
+}

package/dist/chunk-7KXT6LS2.js

@@ -1,178 +0,0 @@
-// src/error-handler.ts
-import { cacheProviderIsLoading } from "@web-widget/helpers/cache";
-function installErrorHandler(app, callback, throwUnhandledErrorInProduction = false) {
-  app.config.throwUnhandledErrorInProduction = throwUnhandledErrorInProduction;
-  app.config.errorHandler = (err, instance, info) => {
-    if (cacheProviderIsLoading(err)) {
-      return;
-    }
-    app.config.warnHandler = () => {
-    };
-    callback(err);
-  };
-}
-
-// src/components.ts
-import { WebWidgetRenderer } from "@web-widget/web-widget";
-import {
-  h,
-  defineComponent,
-  Suspense,
-  useAttrs,
-  ref,
-  onErrorCaptured
-} from "vue";
-import { IS_CLIENT } from "@web-widget/helpers/env";
-var WebWidget = /* @__PURE__ */ defineComponent({
-  name: "WebWidgetRoot",
-  props: {
-    base: {
-      type: String
-    },
-    data: {
-      type: Object,
-      default: () => ({})
-    },
-    errorFallback: {
-      type: Object,
-      default: null
-    },
-    import: {
-      type: String
-    },
-    inactive: {
-      type: Boolean,
-      default: false
-    },
-    loader: {
-      type: Function,
-      required: true
-    },
-    loading: {
-      type: String
-    },
-    meta: {
-      type: Object
-    },
-    name: {
-      type: String
-    },
-    renderStage: {
-      type: String
-    },
-    renderTarget: {
-      type: String,
-      default: "light"
-    }
-  },
-  async setup({ loader, errorFallback, ...props }, { slots }) {
-    if (!loader) {
-      throw new TypeError(`Missing loader.`);
-    }
-    if (Object.keys(slots).length > 0) {
-      throw new TypeError(`Slot not supported.`);
-    }
-    const widget = new WebWidgetRenderer(loader, {
-      ...props,
-      children: ""
-    });
-    const tag = widget.localName;
-    const attrs = widget.attributes;
-    const innerHTML = await widget.renderInnerHTMLToString().catch((err) => {
-      const error = err instanceof Error ? err : new Error(String(err));
-      console.error("[VueWidget] Rendering error:", error);
-      return error;
-    });
-    if (innerHTML instanceof Error) {
-      return () => errorFallback;
-    }
-    if (IS_CLIENT) {
-      await customElements.whenDefined(tag);
-    }
-    const data = attrs.data;
-    delete attrs.data;
-    return () => {
-      const nodeProps = {
-        ...attrs,
-        ...IS_CLIENT ? { "^data": data } : { data },
-        ...!IS_CLIENT ? { innerHTML } : null
-      };
-      return h(tag, nodeProps);
-    };
-  }
-});
-function resolveFallback(fallback) {
-  var _a;
-  if (fallback !== null && typeof fallback === "object" && !("__v_isVNode" in fallback) && ("pending" in fallback || "error" in fallback)) {
-    const obj = fallback;
-    return {
-      pendingFallback: obj.pending,
-      errorFallback: (_a = obj.error) != null ? _a : obj.pending
-    };
-  }
-  return {
-    pendingFallback: fallback,
-    errorFallback: fallback
-  };
-}
-function container(loader, options = {}) {
-  return defineComponent({
-    name: "VueWidget",
-    inheritAttrs: false,
-    props: {
-      widget: {
-        type: Object,
-        default: () => ({})
-      }
-    },
-    setup({ widget }, { slots }) {
-      var _a;
-      const {
-        fallback,
-        loading = (_a = options.loading) != null ? _a : "lazy",
-        serverOnly,
-        clientOnly
-      } = widget;
-      const { pendingFallback, errorFallback } = resolveFallback(fallback);
-      const renderStage = serverOnly ? "server" : clientOnly ? "client" : options.renderStage;
-      const data = useAttrs();
-      const error = ref(null);
-      onErrorCaptured((err) => {
-        error.value = err;
-        return false;
-      });
-      return () => {
-        var _a2;
-        if (error.value && errorFallback) {
-          return errorFallback;
-        }
-        return h(
-          Suspense,
-          {},
-          {
-            default: h(
-              WebWidget,
-              {
-                ...options,
-                data,
-                errorFallback,
-                loader,
-                loading,
-                renderStage,
-                renderTarget: (_a2 = options.renderTarget) != null ? _a2 : "light"
-              },
-              slots
-            ),
-            fallback: pendingFallback
-          }
-        );
-      };
-    }
-  });
-}
-
-export {
-  installErrorHandler,
-  resolveFallback,
-  container
-};

package/dist/types-BY8s0m9C.d.ts

@@ -1,85 +0,0 @@
-import { WebWidgetRendererOptions, Loader } from '@web-widget/web-widget';
-import { ExtractWidgetProps } from '@web-widget/schema';
-import { DefineComponent, VNode, App, Component } from 'vue';
-
-/**
- * A Vue component wrapping a widget, with props `T` plus container config.
- */
-type VueWidgetComponent<T = unknown> = DefineComponent<T & {
-    widget?: WidgetContainerConfig;
-}>;
-interface DefineWebWidgetOptions {
-    base?: WebWidgetRendererOptions['base'];
-    import?: WebWidgetRendererOptions['import'];
-    loading?: WebWidgetRendererOptions['loading'];
-    name?: WebWidgetRendererOptions['name'];
-    renderStage?: WebWidgetRendererOptions['renderStage'];
-    renderTarget?: WebWidgetRendererOptions['renderTarget'];
-}
-type WidgetFallback = VNode | {
-    pending?: VNode;
-    error?: VNode;
-};
-/**
- * Resolve a WidgetFallback into separate pending and error VNodes.
- * - `VNode` — used for both pending and error.
- * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
- */
-declare function resolveFallback(fallback: WidgetFallback | undefined): {
-    pendingFallback: VNode;
-    errorFallback: VNode;
-};
-interface WidgetContainerConfig {
-    /**
-     * Fallback UI for loading and error states.
-     *
-     * Only effective during server-side rendering: loading UI shows while the
-     * widget module renders; error UI shows if rendering fails. Both are
-     * serialized into the HTML stream — no client-side retry exists in the
-     * islands architecture.
-     *
-     * - `VNode` — used for both pending (Suspense) and error.
-     * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
-     *
-     * @example
-     * // Simple: same UI for both states
-     * <Widget :widget="{ fallback: h(Spinner) }" />
-     *
-     * // Differentiated: separate pending and error UI
-     * <Widget :widget="{ fallback: { pending: h(Spinner), error: h(ErrorUI) } }" />
-     */
-    fallback?: WidgetFallback;
-    /** Client-side module loading strategy: `'lazy'` loads on first render, `'eager'` on module parse, `'idle'` on browser idle. */
-    loading?: WebWidgetRendererOptions['loading'];
-    /** Widget renders only on the server (SSR), producing static HTML with no client-side mount. Mutually exclusive with `clientOnly`. */
-    serverOnly?: true;
-    /** Widget renders only on the client, producing no server HTML (empty placeholder until client mount). Mutually exclusive with `serverOnly`. */
-    clientOnly?: true;
-}
-/**
- * Container function (WebWidgetAdapter protocol).
- *
- * Wraps a widget module loader into a Vue component with props type
- * inference from the source module's default export.
- *
- * @example
- * ```ts
- * import { container } from '@web-widget/vue/adapter';
- *
- * const Counter = container(() => import('./Counter@widget.vue'));
- * //    ^? VueWidgetComponent<{ count: number }>
- * ```
- */
-declare function container<M>(loader: () => Promise<M>, options?: DefineWebWidgetOptions): VueWidgetComponent<ExtractWidgetProps<M>>;
-declare function container<Props>(loader: Loader, options?: DefineWebWidgetOptions): VueWidgetComponent<Props>;
-
-interface CreateVueRenderOptions {
-    onCreatedApp?: (app: App<Element>, context: {
-        container?: Element | DocumentFragment;
-        data: any;
-        progressive?: boolean;
-        recovering?: boolean;
-    }, component: Component, props: any) => Promise<void>;
-}
-
-export { type CreateVueRenderOptions as C, type DefineWebWidgetOptions as D, type VueWidgetComponent as V, type WidgetContainerConfig as W, type WidgetFallback as a, container as c, resolveFallback as r };