@web-widget/vue 3.0.0-beta.0 → 3.0.0-beta.3

package/dist/chunk-7BZH43RE.js

@@ -0,0 +1,200 @@
+// 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, _b;
+      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();
+      if (clientOnly && !IS_CLIENT && pendingFallback) {
+        const renderer = new WebWidgetRenderer(loader, {
+          ...options,
+          children: "",
+          data,
+          loading,
+          renderStage,
+          renderTarget: (_b = options.renderTarget) != null ? _b : "light"
+        });
+        return () => h(
+          renderer.localName,
+          renderer.attributes,
+          h(
+            renderer.pendingLocalName,
+            {
+              "aria-busy": "true",
+              style: { display: "contents" }
+            },
+            pendingFallback
+          )
+        );
+      }
+      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/chunk-F3PTQ2OL.js

@@ -0,0 +1,10 @@
+// src/as-react-widget.ts
+function asReactWidget(component) {
+  return component;
+}
+var toReact = asReactWidget;
+
+export {
+  asReactWidget,
+  toReact
+};

package/dist/types-eCw5P8fo.d.ts

@@ -0,0 +1,87 @@
+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 pending and error states.
+     *
+     * Only effective during server-side rendering: pending 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.
+     * For `clientOnly`, pending UI is rendered inside the `<web-widget>` element
+     * and removed immediately before its client mount begins.
+     *
+     * - `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 };

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

@@ -0,0 +1,14 @@
+import * as _web_widget_schema from '@web-widget/schema';
+import { Component } from 'vue';
+import { C as CreateVueRenderOptions } from './types-eCw5P8fo.js';
+export { D as DefineWebWidgetOptions, V as VueWidgetComponent, W as WidgetContainerConfig, a as WidgetFallback, c as container, r as resolveFallback } from './types-eCw5P8fo.js';
+export { asReactWidget, toReact } from './vue.js';
+import '@web-widget/web-widget';
+import '@web-widget/react/adapter';
+
+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 };

package/dist/{vue.client.js → vue.adapter.client.js}

@@ -1,31 +1,32 @@
 import {
-  asReactWidget,
-  defineWebWidget,
+  container,
   installErrorHandler,
+  resolveFallback
+} from "./chunk-7BZH43RE.js";
+import {
+  asReactWidget,
   toReact
-} from "./chunk-GRYUSOXQ.js";
+} from "./chunk-F3PTQ2OL.js";
 
-// src/client.ts
+// src/adapter.client.ts
 import { defineClientRender } from "@web-widget/helpers";
 import { Suspense, createApp, createSSRApp, h } from "vue";
-export * from "@web-widget/helpers";
-import { useWidgetAsyncState } from "@web-widget/helpers/state";
 var createWidgetSuspense = (component) => (props) => h(Suspense, null, [h(component, props)]);
 var createVueRender = ({
   onCreatedApp = async () => {
   }
 } = {}) => {
   return defineClientRender(
-    async (component, data, { recovering, container }) => {
+    async (component, data, { recovering, container: container2 }) => {
       data = data != null ? data : {};
       if (!component) {
         throw new TypeError(`Missing component.`);
       }
-      if (!container) {
+      if (!container2) {
         throw new Error(`Missing container.`);
       }
       let app;
-      const context = { data, recovering, container };
+      const context = { data, recovering, container: container2 };
       const WidgetSuspense = createWidgetSuspense(component);
       return {
         async mount() {
@@ -35,7 +36,7 @@ var createVueRender = ({
             error = err;
           });
           await onCreatedApp(app, context, component, data);
-          app.mount(container);
+          app.mount(container2);
           if (error) {
             throw error;
           }
@@ -52,10 +53,10 @@ var defineVueRender = createVueRender;
 var render = createVueRender();
 export {
   asReactWidget,
+  container,
   createVueRender,
   defineVueRender,
-  defineWebWidget,
   render,
-  toReact,
-  useWidgetAsyncState as useWidgetState
+  resolveFallback,
+  toReact
 };

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

@@ -0,0 +1,24 @@
+import * as _web_widget_schema from '@web-widget/schema';
+import { Component } from 'vue';
+import { SSRContext } from 'vue/server-renderer';
+import { C as CreateVueRenderOptions } from './types-eCw5P8fo.js';
+export { D as DefineWebWidgetOptions, V as VueWidgetComponent, W as WidgetContainerConfig, a as WidgetFallback, c as container, r as resolveFallback } from './types-eCw5P8fo.js';
+export { asReactWidget, toReact } from './vue.js';
+import '@web-widget/web-widget';
+import '@web-widget/react/adapter';
+
+declare module '@web-widget/schema' {
+    interface ServerRenderOptions {
+        vue?: {};
+    }
+}
+
+interface VueRenderOptions {
+    vue?: SSRContext;
+}
+declare const createVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_schema.ServerRender<Component, unknown, _web_widget_schema.ServerRenderOptions, _web_widget_schema.ServerRenderResult>;
+/**@deprecated Please use `createVueRender` instead.*/
+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 };

package/dist/vue.adapter.server.js

@@ -0,0 +1,108 @@
+import {
+  container,
+  installErrorHandler,
+  resolveFallback
+} from "./chunk-7BZH43RE.js";
+import {
+  asReactWidget,
+  toReact
+} from "./chunk-F3PTQ2OL.js";
+
+// src/adapter.server.ts
+import { defineServerRender } from "@web-widget/helpers";
+import { createSSRApp, h, Suspense } from "vue";
+import {
+  renderToString,
+  renderToWebStream
+} from "vue/server-renderer";
+var createWidgetSuspense = (component) => (props) => h(Suspense, null, [h(component, props)]);
+var createVueRender = ({
+  onCreatedApp = async () => {
+  }
+} = {}) => {
+  return defineServerRender(
+    async (component, data, { progressive, vue: options }) => {
+      var _a, _b;
+      data = data != null ? data : {};
+      if (!component) {
+        throw new TypeError(`Missing component.`);
+      }
+      const ssrContext = Object.create(options != null ? options : null);
+      let error;
+      const context = { data, progressive };
+      const WidgetSuspense = createWidgetSuspense(component);
+      const app = createSSRApp(WidgetSuspense, data);
+      installErrorHandler(app, (err) => {
+        error = err;
+      });
+      await onCreatedApp(app, context, component, data);
+      if (progressive) {
+        const stream = renderToWebStream(app, ssrContext);
+        const reader = stream.getReader();
+        const first = await reader.read();
+        try {
+          if (ssrContext == null ? void 0 : ssrContext.teleports) {
+            const file = (_a = Reflect.get(component, "__file")) != null ? _a : "unknown";
+            throw new Error(
+              `Teleports are not supported in SSR: ${JSON.stringify(ssrContext.teleports, null, 2)} in ${file}
+Do conditionally render Teleport when mounted on the client.`
+            );
+          }
+          if (error) {
+            throw error;
+          }
+        } catch (e) {
+          await reader.cancel();
+          throw e;
+        }
+        return new ReadableStream({
+          start(controller) {
+            if (first.done) {
+              controller.close();
+            } else {
+              controller.enqueue(first.value);
+            }
+          },
+          async pull(controller) {
+            try {
+              const { value, done } = await reader.read();
+              if (done) {
+                controller.close();
+              } else {
+                controller.enqueue(value);
+              }
+            } catch (e) {
+              controller.error(e);
+            }
+          },
+          async cancel() {
+            await reader.cancel();
+          }
+        });
+      }
+      const html = await renderToString(app, ssrContext);
+      if (ssrContext == null ? void 0 : ssrContext.teleports) {
+        const file = (_b = Reflect.get(component, "__file")) != null ? _b : "unknown";
+        throw new Error(
+          `Teleports are not supported in SSR: ${JSON.stringify(ssrContext.teleports, null, 2)} in ${file}
+Do conditionally render Teleport when mounted on the client.`
+        );
+      }
+      if (error) {
+        throw error;
+      }
+      return html;
+    }
+  );
+};
+var defineVueRender = createVueRender;
+var render = createVueRender();
+export {
+  asReactWidget,
+  container,
+  createVueRender,
+  defineVueRender,
+  render,
+  resolveFallback,
+  toReact
+};

package/dist/vue.d.ts

@@ -0,0 +1,18 @@
+import { Component, ComponentPublicInstance } from 'vue';
+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.
+ * The build tool automatically infers props types for both static imports
+ * and explicit `container(() => 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. */
+declare const toReact: typeof asReactWidget;
+
+export { asReactWidget, toReact };

package/dist/vue.js

@@ -0,0 +1,8 @@
+import {
+  asReactWidget,
+  toReact
+} from "./chunk-F3PTQ2OL.js";
+export {
+  asReactWidget,
+  toReact
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-widget/vue",
   "description": "Vue adapter",
-  "version": "3.0.0-beta.0",
+  "version": "3.0.0-beta.3",
   "homepage": "https://github.com/web-widget/web-widget#readme",
   "repository": {
     "type": "git",
@@ -13,49 +13,64 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@rollup/pluginutils": "^5.1.4",
-    "@web-widget/helpers": "3.0.0-beta.0",
-    "@web-widget/vite-plugin": "3.0.0-beta.0",
-    "@web-widget/web-widget": "3.0.0-beta.0",
-    "@web-widget/schema": "3.0.0-beta.0",
-    "@web-widget/react": "3.0.0-beta.0"
+    "@web-widget/helpers": "3.0.0-beta.3",
+    "@web-widget/web-widget": "3.0.0-beta.3",
+    "@web-widget/schema": "3.0.0-beta.3",
+    "@web-widget/react": "3.0.0-beta.3"
   },
   "devDependencies": {
     "tsup": "^8.3.4",
-    "typescript": "^5.5.4",
-    "vite": "^8.0.12",
+    "typescript": "^5.9.3",
     "vue": "^3.5.34"
   },
   "exports": {
     ".": {
+      "types": "./dist/vue.d.ts",
+      "default": "./dist/vue.js"
+    },
+    "./adapter": {
       "worker": {
-        "types": "./dist/vue.server.d.ts",
-        "default": "./dist/vue.server.js"
+        "types": "./dist/vue.adapter.server.d.ts",
+        "default": "./dist/vue.adapter.server.js"
       },
       "browser": {
-        "types": "./dist/vue.client.d.ts",
-        "default": "./dist/vue.client.js"
+        "types": "./dist/vue.adapter.client.d.ts",
+        "default": "./dist/vue.adapter.client.js"
       },
       "default": {
-        "types": "./dist/vue.server.d.ts",
-        "default": "./dist/vue.server.js"
+        "types": "./dist/vue.adapter.server.d.ts",
+        "default": "./dist/vue.adapter.server.js"
       }
-    },
-    "./vite": {
-      "types": "./dist/vite.d.ts",
-      "default": "./dist/vite.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"
   ],
   "peerDependencies": {
-    "vite": "^8.0.12",
     "vue": ">3.3.3"
   },
   "publishConfig": {
     "access": "public"
   },
+  "sideEffects": false,
   "type": "module",
   "scripts": {
     "build": "pnpm exec tsup",

package/dist/chunk-GRYUSOXQ.js

@@ -1,145 +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;
-    }
-    callback(err);
-  };
-}
-
-// src/components.ts
-import { WebWidgetRenderer } from "@web-widget/web-widget";
-import { h, defineComponent, Suspense, useAttrs } from "vue";
-import { IS_CLIENT } from "@web-widget/helpers/env";
-var WebWidget = /* @__PURE__ */ defineComponent({
-  name: "WebWidgetRoot",
-  props: {
-    base: {
-      type: String
-    },
-    data: {
-      type: Object,
-      default: () => ({})
-    },
-    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, ...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();
-    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 defineWebWidget(loader, options) {
-  var _a, _b;
-  return defineComponent({
-    name: "WebWidgetSuspense",
-    inheritAttrs: false,
-    props: {
-      fallback: {
-        type: Object
-      },
-      experimental_loading: {
-        type: String,
-        default: (_a = options.loading) != null ? _a : "lazy"
-      },
-      renderStage: {
-        type: String,
-        default: options.renderStage
-      },
-      experimental_renderTarget: {
-        type: String,
-        default: (_b = options.renderTarget) != null ? _b : "light"
-      }
-    },
-    setup({
-      fallback,
-      experimental_loading,
-      renderStage,
-      experimental_renderTarget
-    }, { slots }) {
-      const data = useAttrs();
-      return () => h(
-        Suspense,
-        {},
-        {
-          default: h(
-            WebWidget,
-            {
-              ...options,
-              data,
-              loader,
-              loading: experimental_loading,
-              renderStage,
-              renderTarget: experimental_renderTarget
-            },
-            slots
-          ),
-          fallback
-        }
-      );
-    }
-  });
-}
-function asReactWidget(component) {
-  return component;
-}
-var toReact = asReactWidget;
-
-export {
-  installErrorHandler,
-  defineWebWidget,
-  asReactWidget,
-  toReact
-};

package/dist/types-vVhn4RGy.d.ts

@@ -1,74 +0,0 @@
-import * as vue from 'vue';
-import { Component, ComponentPublicInstance, PropType, VNode, App } from 'vue';
-import { WebWidgetRendererOptions, Loader } from '@web-widget/web-widget';
-import { ReactWidgetComponent } from '@web-widget/react';
-
-interface DefineWebWidgetOptions {
-    base?: WebWidgetRendererOptions['base'];
-    import?: WebWidgetRendererOptions['import'];
-    loading?: WebWidgetRendererOptions['loading'];
-    name?: WebWidgetRendererOptions['name'];
-    renderStage?: WebWidgetRendererOptions['renderStage'];
-    renderTarget?: WebWidgetRendererOptions['renderTarget'];
-}
-declare function defineWebWidget(loader: Loader, options: DefineWebWidgetOptions): vue.DefineComponent<vue.ExtractPropTypes<{
-    fallback: {
-        type: PropType<VNode>;
-    };
-    experimental_loading: {
-        type: PropType<WebWidgetRendererOptions["loading"]>;
-        default: "lazy" | "eager" | "idle";
-    };
-    renderStage: {
-        type: PropType<WebWidgetRendererOptions["renderStage"]>;
-        default: "server" | "client" | undefined;
-    };
-    experimental_renderTarget: {
-        type: PropType<WebWidgetRendererOptions["renderTarget"]>;
-        default: "light" | "shadow";
-    };
-}>, () => VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    fallback: {
-        type: PropType<VNode>;
-    };
-    experimental_loading: {
-        type: PropType<WebWidgetRendererOptions["loading"]>;
-        default: "lazy" | "eager" | "idle";
-    };
-    renderStage: {
-        type: PropType<WebWidgetRendererOptions["renderStage"]>;
-        default: "server" | "client" | undefined;
-    };
-    experimental_renderTarget: {
-        type: PropType<WebWidgetRendererOptions["renderTarget"]>;
-        default: "light" | "shadow";
-    };
-}>> & Readonly<{}>, {
-    renderStage: "server" | "client" | undefined;
-    experimental_loading: "lazy" | "eager" | "idle" | undefined;
-    experimental_renderTarget: "light" | "shadow" | undefined;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-/**
- * Adapt Vue component types to React widget component types.
- *
- * This is a type-level cast only — the actual cross-framework rendering
- * is handled by the `@widget` system. Use this when importing a Vue
- * widget (e.g. `Counter@widget.vue`) into a React/JSX file so that
- * TypeScript treats it as a React component.
- */
-declare function asReactWidget<T>(component: Component<T>): ReactWidgetComponent<Omit<T, keyof ComponentPublicInstance | "$route" | "$router">>;
-/** @deprecated Use `asReactWidget` instead. */
-declare const toReact: typeof asReactWidget;
-
-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, asReactWidget as a, defineWebWidget as d, toReact as t };

package/dist/vite.d.ts

@@ -1,9 +0,0 @@
-import * as vite from 'vite';
-import { WebWidgetUserConfig } from '@web-widget/vite-plugin';
-
-interface VueWebWidgetPluginOptions extends Partial<WebWidgetUserConfig> {
-    workspace?: string;
-}
-declare function vueWebWidgetPlugin(options?: VueWebWidgetPluginOptions): vite.Plugin<any>[];
-
-export { type VueWebWidgetPluginOptions, vueWebWidgetPlugin as default };

package/dist/vite.js

@@ -1,62 +0,0 @@
-// src/vite.ts
-import { webWidgetPlugin } from "@web-widget/vite-plugin";
-import { posix } from "path";
-import { normalizePath } from "@rollup/pluginutils";
-function escapeRegExp(path) {
-  return path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function appendSlash(path) {
-  return path.endsWith(posix.sep) ? path : `${path}${posix.sep}`;
-}
-function vueWebWidgetPlugin(options) {
-  const {
-    manifest,
-    provide = "@web-widget/vue",
-    workspace = "",
-    export: exportWidget = {},
-    import: importWidget = {}
-  } = options != null ? options : {};
-  const workspacePattern = workspace ? escapeRegExp(normalizePath(appendSlash(workspace))) : workspace;
-  const widgetPattern = `[.@]widget`;
-  const routePattern = `[.@]route`;
-  const modulesPattern = `[.@](?:route|widget)`;
-  const extensionPattern = `\\.vue`;
-  const vueBuildModeQueryPattern = `(?:\\?vue&type=script\\b.*)`;
-  const routeRegExp = new RegExp(
-    `^${workspacePattern}.*${routePattern}${extensionPattern}$`
-  );
-  return webWidgetPlugin({
-    manifest,
-    provide,
-    export: {
-      include: new RegExp(
-        `^${workspacePattern}[^?]*${modulesPattern}${extensionPattern}$`
-      ),
-      extractFromExportDefault: [
-        {
-          name: "handler",
-          default: "{GET({html}){return html()}}",
-          include: routeRegExp
-        },
-        {
-          name: "meta",
-          default: "{}",
-          include: routeRegExp
-        }
-      ],
-      ...exportWidget
-    },
-    import: {
-      include: new RegExp(`^[^?]*${widgetPattern}\\.[^?]*$`),
-      includeImporter: new RegExp(
-        // vite dev mode: .vue
-        // vite build mode: .vue?vue&type=script&setup=true&lang.ts
-        `^${workspacePattern}[^?]*${extensionPattern}${vueBuildModeQueryPattern}?$`
-      ),
-      ...importWidget
-    }
-  });
-}
-export {
-  vueWebWidgetPlugin as default
-};

package/dist/vue.client.d.ts

@@ -1,15 +0,0 @@
-import * as _web_widget_helpers from '@web-widget/helpers';
-export * from '@web-widget/helpers';
-import { Component } from 'vue';
-import { C as CreateVueRenderOptions } from './types-vVhn4RGy.js';
-export { D as DefineWebWidgetOptions, a as asReactWidget, d as defineWebWidget, t as toReact } from './types-vVhn4RGy.js';
-export { useWidgetAsyncState as useWidgetState } from '@web-widget/helpers/state';
-import '@web-widget/web-widget';
-import '@web-widget/react';
-
-declare const createVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_helpers.ClientRender<Component, unknown, _web_widget_helpers.ClientRenderOptions, void | _web_widget_helpers.ClientRenderResult<unknown>>;
-/**@deprecated Please use `createVueRender` instead.*/
-declare const defineVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_helpers.ClientRender<Component, unknown, _web_widget_helpers.ClientRenderOptions, void | _web_widget_helpers.ClientRenderResult<unknown>>;
-declare const render: _web_widget_helpers.ClientRender<Component, unknown, _web_widget_helpers.ClientRenderOptions, void | _web_widget_helpers.ClientRenderResult<unknown>>;
-
-export { createVueRender, defineVueRender, render };

package/dist/vue.server.d.ts

@@ -1,25 +0,0 @@
-import * as _web_widget_helpers from '@web-widget/helpers';
-export * from '@web-widget/helpers';
-import { Component } from 'vue';
-import { SSRContext } from 'vue/server-renderer';
-import { C as CreateVueRenderOptions } from './types-vVhn4RGy.js';
-export { D as DefineWebWidgetOptions, a as asReactWidget, d as defineWebWidget, t as toReact } from './types-vVhn4RGy.js';
-export { useWidgetAsyncState as useWidgetState } from '@web-widget/helpers/state';
-import '@web-widget/web-widget';
-import '@web-widget/react';
-
-declare module '@web-widget/schema' {
-    interface ServerRenderOptions {
-        vue?: {};
-    }
-}
-
-interface VueRenderOptions {
-    vue?: SSRContext;
-}
-declare const createVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_helpers.ServerRender<Component, unknown, _web_widget_helpers.ServerRenderOptions, _web_widget_helpers.ServerRenderResult>;
-/**@deprecated Please use `createVueRender` instead.*/
-declare const defineVueRender: ({ onCreatedApp, }?: CreateVueRenderOptions) => _web_widget_helpers.ServerRender<Component, unknown, _web_widget_helpers.ServerRenderOptions, _web_widget_helpers.ServerRenderResult>;
-declare const render: _web_widget_helpers.ServerRender<Component, unknown, _web_widget_helpers.ServerRenderOptions, _web_widget_helpers.ServerRenderResult>;
-
-export { type VueRenderOptions, createVueRender, defineVueRender, render };

package/dist/vue.server.js

@@ -1,63 +0,0 @@
-import {
-  asReactWidget,
-  defineWebWidget,
-  installErrorHandler,
-  toReact
-} from "./chunk-GRYUSOXQ.js";
-
-// src/server.ts
-import { defineServerRender } from "@web-widget/helpers";
-import { createSSRApp, h, Suspense } from "vue";
-import {
-  renderToString,
-  renderToWebStream
-} from "vue/server-renderer";
-export * from "@web-widget/helpers";
-import { useWidgetAsyncState } from "@web-widget/helpers/state";
-var createWidgetSuspense = (component) => (props) => h(Suspense, null, [h(component, props)]);
-var createVueRender = ({
-  onCreatedApp = async () => {
-  }
-} = {}) => {
-  return defineServerRender(
-    async (component, data, { progressive, vue: options }) => {
-      var _a;
-      data = data != null ? data : {};
-      if (!component) {
-        throw new TypeError(`Missing component.`);
-      }
-      const ssrContext = Object.create(options != null ? options : null);
-      let error;
-      const context = { data, progressive };
-      const WidgetSuspense = createWidgetSuspense(component);
-      const app = createSSRApp(WidgetSuspense, data);
-      installErrorHandler(app, (err) => {
-        error = err;
-      });
-      await onCreatedApp(app, context, component, data);
-      const html = progressive ? renderToWebStream(app, ssrContext) : await renderToString(app, ssrContext);
-      if (ssrContext == null ? void 0 : ssrContext.teleports) {
-        const file = (_a = Reflect.get(component, "__file")) != null ? _a : "unknown";
-        throw new Error(
-          `Teleports are not supported in SSR: ${JSON.stringify(ssrContext.teleports, null, 2)} in ${file}
-Do conditionally render Teleport when mounted on the client.`
-        );
-      }
-      if (error) {
-        throw error;
-      }
-      return html;
-    }
-  );
-};
-var defineVueRender = createVueRender;
-var render = createVueRender();
-export {
-  asReactWidget,
-  createVueRender,
-  defineVueRender,
-  defineWebWidget,
-  render,
-  toReact,
-  useWidgetAsyncState as useWidgetState
-};