@web-widget/react 0.0.4 → 0.0.6

package/dist/react.client.d.ts

@@ -1,8 +1,38 @@
 import * as _web_widget_schema from '@web-widget/schema';
 export * from '@web-widget/schema/client-helpers';
-export { C as ClientOptions, D as DefineWebWidgetOptions, W as WebWidget, b as WebWidgetClient, a as WebWidgetClientProps, c as WebWidgetProps, _ as __ENV__, W as default, e as defineClient, f as defineClientOnly, d as defineWebWidget, r as renderServerWidget } from './web-widget-ec342172.js';
-import 'react/jsx-runtime';
-import 'react';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { WebWidgetContainerProps, Loader } from '@web-widget/web-widget';
+
+declare const __ENV__: {
+    server: boolean;
+};
+interface WebWidgetProps {
+    base?: WebWidgetContainerProps["base"];
+    children?: ReactNode;
+    data?: WebWidgetContainerProps["data"];
+    import?: WebWidgetContainerProps["import"];
+    loader: Loader;
+    loading?: WebWidgetContainerProps["loading"];
+    name?: WebWidgetContainerProps["name"];
+    recovering: WebWidgetContainerProps["recovering"];
+    renderTarget?: WebWidgetContainerProps["renderTarget"];
+}
+declare function WebWidget({ children, loader, ...props }: WebWidgetProps): react.FunctionComponentElement<any>;
+interface DefineWebWidgetOptions {
+    base?: WebWidgetContainerProps["base"];
+    import?: WebWidgetContainerProps["import"];
+    loading?: WebWidgetContainerProps["loading"];
+    name?: WebWidgetContainerProps["name"];
+    recovering?: WebWidgetContainerProps["recovering"];
+    renderTarget?: WebWidgetContainerProps["renderTarget"];
+}
+interface WebWidgetSuspenseProps {
+    children?: ReactNode;
+    clientOnly?: boolean;
+    fallback?: ReactNode;
+}
+declare function defineWebWidget(loader: Loader, options: DefineWebWidgetOptions): ({ children, clientOnly, fallback, ...data }: WebWidgetSuspenseProps) => react.FunctionComponentElement<react.SuspenseProps>;
 
 declare const render: (context: _web_widget_schema.ClientWidgetRenderContext<unknown> | _web_widget_schema.ClientRouteRenderContext<unknown, Record<string, string>>) => Promise<void | {
     mount?: (() => void | Promise<void>) | undefined;
@@ -18,4 +48,4 @@ declare const render: (context: _web_widget_schema.ClientWidgetRenderContext<unk
     }) => void | Promise<void>) | undefined;
 }>;
 
-export { render };
+export { DefineWebWidgetOptions, WebWidget, WebWidgetProps, WebWidgetSuspenseProps, __ENV__, WebWidget as default, defineWebWidget, render };

package/dist/react.client.js

@@ -1,168 +1,102 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
 // src/web-widget.tsx
+import { parse } from "@web-widget/web-widget";
 import { Suspense, createElement, lazy } from "react";
-import { jsx } from "react/jsx-runtime";
 var __ENV__ = {
   server: true
 };
-var MODULE_REG = /\b(?:import|__vite_ssr_dynamic_import__)\(["']([^"']*)["']\)/;
-function getFilename(loader) {
-  const match = String(loader).match(MODULE_REG);
-  const id = match?.[1];
-  if (!id) {
-    throw new Error(`The url for the module was not found: ${loader}`);
-  }
-  return id;
-}
-async function readableStreamToString(stream) {
-  const decoder = new TextDecoder();
-  const reader = stream.getReader();
-  let result = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      const chunk = decoder.decode(value, { stream: true });
-      result += chunk;
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return result;
-}
-function WebWidgetClient({
-  base,
-  data,
-  import: url,
-  innerHTML = "",
-  loading,
-  name,
-  recovering
-}) {
-  const attrs = {
-    base,
-    data: JSON.stringify(data),
-    import: url,
-    loading,
-    name,
-    rendertarget: "light"
-  };
-  if (recovering && typeof recovering !== "string") {
-    Object.assign(attrs, {
-      recovering: ""
-    });
-  }
-  return createElement("web-widget", {
-    ...attrs,
-    dangerouslySetInnerHTML: { __html: innerHTML }
-  });
-}
-async function renderServerWidget(loader, data) {
-  const module = await loader();
-  if (typeof module.render !== "function") {
-    const url = getFilename(loader);
-    throw new Error(`The module does not export a 'render' method: ${url}`);
-  }
-  const result = await module.render({
-    meta: module.meta ?? {},
-    // TODO 处理 Meta 中的相对路径资产
-    module,
-    data
-  });
-  if (result instanceof ReadableStream) {
-    return await readableStreamToString(result);
-  } else if (typeof result === "string") {
-    return result;
-  } else {
-    const url = getFilename(loader);
-    throw new Error(`Render results in an unknown format: ${url}`);
-  }
-}
-function WebWidget({
-  base,
-  children,
-  data,
-  fallback,
-  import: url,
-  loader,
-  loading,
-  name,
-  recovering
-}) {
-  if (!base) {
-    throw new Error(`Missing base`);
+function WebWidget(_a) {
+  var _b = _a, {
+    children,
+    loader
+  } = _b, props = __objRest(_b, [
+    "children",
+    "loader"
+  ]);
+  if (props.recovering && !loader) {
+    throw new TypeError(`Missing loader.`);
   }
   if (children) {
-    throw new Error(`No support for 'children'`);
+    throw new TypeError(`No support children.`);
   }
-  if (recovering && !loader) {
-    throw new Error(`Missing loader`);
-  }
-  const WebWidgetClientFactory = lazy(async () => {
-    let innerHTML = "";
-    if (__ENV__.server && recovering && loader) {
-      innerHTML = await renderServerWidget(loader, data);
-    }
-    return {
-      default: function WebWidgetClientFactory2() {
-        return /* @__PURE__ */ jsx(
-          WebWidgetClient,
-          {
-            ...{
-              base,
-              data,
-              import: url,
-              loading,
-              name,
-              innerHTML,
-              recovering
-            }
-          }
-        );
+  return /* @__PURE__ */ createElement(
+    lazy(async () => {
+      const [tag, attrs, innerHTML] = await parse(loader, __spreadProps(__spreadValues({}, props), {
+        // TODO Render children
+        children: ""
+      }));
+      if (!__ENV__.server) {
+        console.warn(`Client components are experimental.`);
+        await customElements.whenDefined(tag);
+        const element = Object.assign(document.createElement(tag), props);
+        await element.bootstrap();
       }
-    };
-  });
-  return /* @__PURE__ */ jsx(Suspense, { fallback, children: /* @__PURE__ */ jsx(WebWidgetClientFactory, {}) });
+      return {
+        default: function WebWidgetContainer() {
+          return createElement(tag, __spreadProps(__spreadValues({}, attrs), {
+            dangerouslySetInnerHTML: {
+              __html: innerHTML
+            }
+          }));
+        }
+      };
+    })
+  );
 }
-function defineWebWidget(loader, base, { loading, name, recovering = true } = {}) {
-  const url = getFilename(loader);
-  return function WebWidgetFactory({
-    children,
-    fallback,
-    ...data
-  }) {
-    return /* @__PURE__ */ jsx(
-      WebWidget,
-      {
-        ...{
-          base,
-          data,
-          fallback,
-          import: url,
-          loader,
-          loading,
-          name,
-          recovering
-        },
-        children
-      }
-    );
+function defineWebWidget(loader, options) {
+  options.renderTarget = "light";
+  return function WebWidgetSuspense(_a) {
+    var _b = _a, {
+      children,
+      clientOnly = !options.recovering,
+      fallback
+    } = _b, data = __objRest(_b, [
+      "children",
+      "clientOnly",
+      "fallback"
+    ]);
+    return createElement(Suspense, {
+      fallback,
+      children: createElement(WebWidget, __spreadProps(__spreadValues({}, options), {
+        children,
+        data,
+        loader,
+        recovering: !clientOnly
+      }))
+    });
   };
 }
-function defineClient(loader, base, { loading, name } = {}) {
-  return defineWebWidget(loader, base, {
-    loading,
-    name,
-    recovering: true
-  });
-}
-function defineClientOnly(loader, base, { loading, name } = {}) {
-  return defineWebWidget(loader, base, {
-    loading,
-    name,
-    recovering: false
-  });
-}
 
 // src/client.ts
 import { createElement as createElement2 } from "react";
@@ -194,19 +128,15 @@ var render = defineRender(async (context, component, props) => {
       }
     },
     async unmount() {
-      root?.unmount();
+      root == null ? void 0 : root.unmount();
       root = null;
     }
   };
 });
 export {
   WebWidget,
-  WebWidgetClient,
   __ENV__,
   WebWidget as default,
-  defineClient,
-  defineClientOnly,
   defineWebWidget,
-  render,
-  renderServerWidget
+  render
 };

package/dist/react.server.d.ts

@@ -1,9 +1,39 @@
 import * as _web_widget_schema from '@web-widget/schema';
 export * from '@web-widget/schema/server-helpers';
-export { C as ClientOptions, D as DefineWebWidgetOptions, W as WebWidget, b as WebWidgetClient, a as WebWidgetClientProps, c as WebWidgetProps, _ as __ENV__, W as default, e as defineClient, f as defineClientOnly, d as defineWebWidget, r as renderServerWidget } from './web-widget-ec342172.js';
-import 'react/jsx-runtime';
-import 'react';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { WebWidgetContainerProps, Loader } from '@web-widget/web-widget';
+
+declare const __ENV__: {
+    server: boolean;
+};
+interface WebWidgetProps {
+    base?: WebWidgetContainerProps["base"];
+    children?: ReactNode;
+    data?: WebWidgetContainerProps["data"];
+    import?: WebWidgetContainerProps["import"];
+    loader: Loader;
+    loading?: WebWidgetContainerProps["loading"];
+    name?: WebWidgetContainerProps["name"];
+    recovering: WebWidgetContainerProps["recovering"];
+    renderTarget?: WebWidgetContainerProps["renderTarget"];
+}
+declare function WebWidget({ children, loader, ...props }: WebWidgetProps): react.FunctionComponentElement<any>;
+interface DefineWebWidgetOptions {
+    base?: WebWidgetContainerProps["base"];
+    import?: WebWidgetContainerProps["import"];
+    loading?: WebWidgetContainerProps["loading"];
+    name?: WebWidgetContainerProps["name"];
+    recovering?: WebWidgetContainerProps["recovering"];
+    renderTarget?: WebWidgetContainerProps["renderTarget"];
+}
+interface WebWidgetSuspenseProps {
+    children?: ReactNode;
+    clientOnly?: boolean;
+    fallback?: ReactNode;
+}
+declare function defineWebWidget(loader: Loader, options: DefineWebWidgetOptions): ({ children, clientOnly, fallback, ...data }: WebWidgetSuspenseProps) => react.FunctionComponentElement<react.SuspenseProps>;
 
 declare const render: (context: _web_widget_schema.ServerWidgetRenderContext<unknown> | _web_widget_schema.ServerRouteRenderContext<unknown, Record<string, string>>) => Promise<string | ReadableStream<any>>;
 
-export { render };
+export { DefineWebWidgetOptions, WebWidget, WebWidgetProps, WebWidgetSuspenseProps, __ENV__, WebWidget as default, defineWebWidget, render };

package/dist/react.server.js

@@ -1,168 +1,102 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
 // src/web-widget.tsx
+import { parse } from "@web-widget/web-widget";
 import { Suspense, createElement, lazy } from "react";
-import { jsx } from "react/jsx-runtime";
 var __ENV__ = {
   server: true
 };
-var MODULE_REG = /\b(?:import|__vite_ssr_dynamic_import__)\(["']([^"']*)["']\)/;
-function getFilename(loader) {
-  const match = String(loader).match(MODULE_REG);
-  const id = match?.[1];
-  if (!id) {
-    throw new Error(`The url for the module was not found: ${loader}`);
-  }
-  return id;
-}
-async function readableStreamToString(stream) {
-  const decoder = new TextDecoder();
-  const reader = stream.getReader();
-  let result = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      const chunk = decoder.decode(value, { stream: true });
-      result += chunk;
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return result;
-}
-function WebWidgetClient({
-  base,
-  data,
-  import: url,
-  innerHTML = "",
-  loading,
-  name,
-  recovering
-}) {
-  const attrs = {
-    base,
-    data: JSON.stringify(data),
-    import: url,
-    loading,
-    name,
-    rendertarget: "light"
-  };
-  if (recovering && typeof recovering !== "string") {
-    Object.assign(attrs, {
-      recovering: ""
-    });
-  }
-  return createElement("web-widget", {
-    ...attrs,
-    dangerouslySetInnerHTML: { __html: innerHTML }
-  });
-}
-async function renderServerWidget(loader, data) {
-  const module = await loader();
-  if (typeof module.render !== "function") {
-    const url = getFilename(loader);
-    throw new Error(`The module does not export a 'render' method: ${url}`);
-  }
-  const result = await module.render({
-    meta: module.meta ?? {},
-    // TODO 处理 Meta 中的相对路径资产
-    module,
-    data
-  });
-  if (result instanceof ReadableStream) {
-    return await readableStreamToString(result);
-  } else if (typeof result === "string") {
-    return result;
-  } else {
-    const url = getFilename(loader);
-    throw new Error(`Render results in an unknown format: ${url}`);
-  }
-}
-function WebWidget({
-  base,
-  children,
-  data,
-  fallback,
-  import: url,
-  loader,
-  loading,
-  name,
-  recovering
-}) {
-  if (!base) {
-    throw new Error(`Missing base`);
+function WebWidget(_a) {
+  var _b = _a, {
+    children,
+    loader
+  } = _b, props = __objRest(_b, [
+    "children",
+    "loader"
+  ]);
+  if (props.recovering && !loader) {
+    throw new TypeError(`Missing loader.`);
   }
   if (children) {
-    throw new Error(`No support for 'children'`);
-  }
-  if (recovering && !loader) {
-    throw new Error(`Missing loader`);
+    throw new TypeError(`No support children.`);
   }
-  const WebWidgetClientFactory = lazy(async () => {
-    let innerHTML = "";
-    if (__ENV__.server && recovering && loader) {
-      innerHTML = await renderServerWidget(loader, data);
-    }
-    return {
-      default: function WebWidgetClientFactory2() {
-        return /* @__PURE__ */ jsx(
-          WebWidgetClient,
-          {
-            ...{
-              base,
-              data,
-              import: url,
-              loading,
-              name,
-              innerHTML,
-              recovering
-            }
-          }
-        );
+  return /* @__PURE__ */ createElement(
+    lazy(async () => {
+      const [tag, attrs, innerHTML] = await parse(loader, __spreadProps(__spreadValues({}, props), {
+        // TODO Render children
+        children: ""
+      }));
+      if (!__ENV__.server) {
+        console.warn(`Client components are experimental.`);
+        await customElements.whenDefined(tag);
+        const element = Object.assign(document.createElement(tag), props);
+        await element.bootstrap();
       }
-    };
-  });
-  return /* @__PURE__ */ jsx(Suspense, { fallback, children: /* @__PURE__ */ jsx(WebWidgetClientFactory, {}) });
+      return {
+        default: function WebWidgetContainer() {
+          return createElement(tag, __spreadProps(__spreadValues({}, attrs), {
+            dangerouslySetInnerHTML: {
+              __html: innerHTML
+            }
+          }));
+        }
+      };
+    })
+  );
 }
-function defineWebWidget(loader, base, { loading, name, recovering = true } = {}) {
-  const url = getFilename(loader);
-  return function WebWidgetFactory({
-    children,
-    fallback,
-    ...data
-  }) {
-    return /* @__PURE__ */ jsx(
-      WebWidget,
-      {
-        ...{
-          base,
-          data,
-          fallback,
-          import: url,
-          loader,
-          loading,
-          name,
-          recovering
-        },
-        children
-      }
-    );
+function defineWebWidget(loader, options) {
+  options.renderTarget = "light";
+  return function WebWidgetSuspense(_a) {
+    var _b = _a, {
+      children,
+      clientOnly = !options.recovering,
+      fallback
+    } = _b, data = __objRest(_b, [
+      "children",
+      "clientOnly",
+      "fallback"
+    ]);
+    return createElement(Suspense, {
+      fallback,
+      children: createElement(WebWidget, __spreadProps(__spreadValues({}, options), {
+        children,
+        data,
+        loader,
+        recovering: !clientOnly
+      }))
+    });
   };
 }
-function defineClient(loader, base, { loading, name } = {}) {
-  return defineWebWidget(loader, base, {
-    loading,
-    name,
-    recovering: true
-  });
-}
-function defineClientOnly(loader, base, { loading, name } = {}) {
-  return defineWebWidget(loader, base, {
-    loading,
-    name,
-    recovering: false
-  });
-}
 
 // src/server.ts
 import { createElement as createElement2 } from "react";
@@ -183,12 +117,8 @@ var render = defineRender(async (context, component, props) => {
 });
 export {
   WebWidget,
-  WebWidgetClient,
   __ENV__,
   WebWidget as default,
-  defineClient,
-  defineClientOnly,
   defineWebWidget,
-  render,
-  renderServerWidget
+  render
 };

package/globals.d.ts

@@ -1,11 +1,30 @@
-import type { ReactNode } from "react";
+import type { ReactNode, ComponentProps } from "react";
 
 type _IntrinsicAttributes = IntrinsicAttributes;
 
 declare namespace JSX {
   interface IntrinsicAttributes extends _IntrinsicAttributes {
     as?: "web-widget" | "web-widget:server" | "web-widget:client" | any;
+    clientOnly?: boolean;
     loading?: "lazy" | any;
     fallback?: ReactNode;
   }
 }
+
+interface ReactWidgetComponent extends ComponentProps<any> {
+  (props: {
+    children?: ReactNode;
+    clientOnly?: boolean;
+    fallback?: ReactNode;
+  }): ReactNode;
+}
+
+declare module "*.widget.jsx" {
+  const reactWidgetComponent: ReactWidgetComponent;
+  export default reactWidgetComponent;
+}
+
+declare module "*.widget.tsx" {
+  const reactWidgetComponent: ReactWidgetComponent;
+  export default reactWidgetComponent;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-widget/react",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "exports": {
     ".": {
@@ -17,14 +17,6 @@
         "default": "./dist/react.server.js"
       }
     },
-    "./babel-plugin": {
-      "types": "./dist/babel-plugin.d.ts",
-      "default": "./dist/babel-plugin.js"
-    },
-    "./vite-plugin": {
-      "types": "./dist/vite-plugin.d.ts",
-      "default": "./dist/vite-plugin.js"
-    },
     "./globals": "./globals.d.ts"
   },
   "files": [
@@ -36,7 +28,8 @@
     "@babel/helper-module-imports": "^7.22.5",
     "@babel/helper-plugin-utils": "^7.22.5",
     "@babel/traverse": "^7.22.5",
-    "@web-widget/schema": "0.0.7"
+    "@web-widget/schema": "0.0.8",
+    "@web-widget/web-widget": "1.0.0-alpha.6"
   },
   "peerDependencies": {
     "@vitejs/plugin-react": "^4.0.2",
@@ -53,7 +46,7 @@
     "@types/react-dom": "^18.0.6",
     "tsup": "^7.0.0",
     "typescript": "^5.0.4",
-    "vite": "^4.3.9"
+    "vite": "^4.4.9"
   },
   "publishConfig": {
     "access": "public"

package/dist/babel-plugin.d.ts

@@ -1,34 +0,0 @@
-import { PluginPass } from '@babel/core';
-import { Visitor } from '@babel/traverse';
-
-/**
- * This adds web-widget source path to JSX tags.
- *
- * == JSX Literals ==
- *
- * import MyComponent from "../widgets/my-component.jsx";
- * ...
- * <MyComponent as="web-widget" title="My component" />
- *
- * becomes:
- *
- * import { defineWebWidget } from "@web-widget/react/web-widget";
- * const MyComponent = defineWebWidget(() => import("../widgets/my-component.jsx"), "/routes/", {
- *   name: "MyComponent",
- *   recovering: true
- * });
- * ...
- * <MyComponent title="My component" />
- */
-
-type Config = {
-    base: string;
-    root: string;
-    isServer: boolean;
-};
-declare const _default: (api: object, options: Record<string, any> | null | undefined, dirname: string) => {
-    name: string;
-    visitor: Visitor<PluginPass>;
-};
-
-export { Config, _default as default };

package/dist/babel-plugin.js

@@ -1,132 +0,0 @@
-// src/babel-plugin.ts
-import { addNamed } from "@babel/helper-module-imports";
-import { declare } from "@babel/helper-plugin-utils";
-import { types as t } from "@babel/core";
-var TAGNAME = "web-widget";
-function createWebWidgetVariableDeclaration(definer, component, source, base, options) {
-  const getType = (object) => Object.prototype.toString.call(object).slice(8, -1).toLocaleLowerCase();
-  return t.variableDeclaration("const", [
-    t.variableDeclarator(
-      t.identifier(component),
-      t.callExpression(t.identifier(definer), [
-        t.arrowFunctionExpression(
-          [],
-          t.callExpression(t.import(), [t.stringLiteral(source)])
-        ),
-        t.stringLiteral(base),
-        t.objectExpression(
-          Object.keys(options).map((key) => {
-            const value = options[key];
-            const type = getType(value);
-            switch (type) {
-              case "string":
-                return t.objectProperty(
-                  t.identifier(key),
-                  t.stringLiteral(value)
-                );
-              case "number":
-                return t.objectProperty(
-                  t.identifier(key),
-                  t.numericLiteral(value)
-                );
-              case "boolean":
-                return t.objectProperty(
-                  t.identifier(key),
-                  t.booleanLiteral(value)
-                );
-              case "null":
-                return t.objectProperty(t.identifier(key), t.nullLiteral());
-            }
-            throw new Error(`Type not supported: ${key}=${value}`);
-          })
-        )
-      ])
-    )
-  ]);
-}
-var babel_plugin_default = declare((api) => {
-  api.assertVersion(7);
-  let config;
-  const visitor = {
-    Program: {
-      enter(path, { opts }) {
-        config = opts;
-      }
-    },
-    JSXOpeningElement(path, state) {
-      if (!state.filename) {
-        return;
-      }
-      const name = path.node.name;
-      let bindingName;
-      if (t.isJSXIdentifier(name)) {
-        bindingName = name.name;
-      } else if (t.isJSXMemberExpression(name)) {
-        let object = name.object;
-        while (t.isJSXMemberExpression(object)) {
-          object = object.object;
-        }
-        bindingName = object.name;
-      } else if (t.isJSXNamespacedName(name)) {
-        bindingName = name.namespace.name;
-      } else {
-        return;
-      }
-      const binding = path.scope.getBinding(bindingName);
-      if (binding && t.isImportDeclaration(binding.path.parent)) {
-        const container = path.container;
-        if (!t.isJSXElement(container)) {
-          return;
-        }
-        if (!t.isJSXIdentifier(container.openingElement.name)) {
-          return;
-        }
-        const attributes = container.openingElement.attributes;
-        const widgetAttr = attributes.find(
-          (attr) => t.isJSXAttribute(attr) && attr.name.name === "as" && t.isStringLiteral(attr.value) && attr.value.value.startsWith(TAGNAME)
-        );
-        if (!widgetAttr) {
-          return;
-        }
-        const mode = t.isStringLiteral(widgetAttr.value) ? widgetAttr.value.value.replace(TAGNAME + ":", "") : "";
-        const loadingAttr = attributes.find(
-          (attr) => t.isJSXAttribute(attr) && attr.name.name === "loading"
-        ) || void 0;
-        container.openingElement.attributes = container.openingElement.attributes.filter(
-          (attr) => attr !== widgetAttr && attr !== loadingAttr
-        );
-        const options = {
-          name: container.openingElement.name.name,
-          recovering: config.isServer && mode !== "client"
-        };
-        if (loadingAttr && loadingAttr.value && t.isStringLiteral(loadingAttr.value)) {
-          options.loading = loadingAttr.value.value;
-        }
-        const importDeclaration = binding.path.parent;
-        const source = importDeclaration.source.value;
-        const importName = addNamed(
-          path,
-          "defineWebWidget",
-          "@web-widget/react"
-        );
-        const base = config.base;
-        binding.path.parentPath?.replaceWith(
-          createWebWidgetVariableDeclaration(
-            importName.name,
-            container.openingElement.name.name,
-            source,
-            base,
-            options
-          )
-        );
-      }
-    }
-  };
-  return {
-    name: "@web-widget/react:web-widget",
-    visitor
-  };
-});
-export {
-  babel_plugin_default as default
-};

package/dist/vite-plugin.d.ts

@@ -1,6 +0,0 @@
-import { Plugin, PluginOption } from 'vite';
-import { Options } from '@vitejs/plugin-react';
-
-declare function ReactWebWidgetVitePlugin(options?: Options): Plugin | PluginOption;
-
-export { ReactWebWidgetVitePlugin as default };

package/dist/vite-plugin.js

@@ -1,57 +0,0 @@
-// src/vite-plugin.ts
-import react from "@vitejs/plugin-react";
-function ReactWebWidgetVitePlugin(options = {}) {
-  let config;
-  return [
-    {
-      name: "@web-widget/react:get-config",
-      enforce: "pre",
-      config(config2) {
-        var _a;
-        config2.resolve || (config2.resolve = {});
-        (_a = config2.resolve).alias || (_a.alias = {});
-        const aliases = [
-          { find: "react-dom/server", replacement: "react-dom/server.browser" }
-        ];
-        if (Array.isArray(config2.resolve.alias)) {
-          config2.resolve.alias = [...config2.resolve.alias, ...aliases];
-        } else {
-          for (const alias of aliases) {
-            config2.resolve.alias[alias.find] = alias.replacement;
-          }
-        }
-      },
-      configResolved(resolvedConfig) {
-        config = resolvedConfig;
-      }
-    },
-    ...react({
-      ...options,
-      babel: {
-        ...options?.babel,
-        plugins: [
-          // @ts-expect-error
-          ...options?.babel?.plugins || [],
-          [
-            "@web-widget/react/babel-plugin",
-            {
-              get base() {
-                const isServer = !!config.build.ssr;
-                return isServer ? config.base + config.build.assetsDir + "/" : config.base;
-              },
-              get root() {
-                return config.root;
-              },
-              get isServer() {
-                return !!config.build.ssr || config.command === "serve";
-              }
-            }
-          ]
-        ]
-      }
-    })
-  ];
-}
-export {
-  ReactWebWidgetVitePlugin as default
-};

package/dist/web-widget-ec342172.d.ts

@@ -1,60 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as react from 'react';
-import { ReactNode } from 'react';
-import { WidgetModule } from '@web-widget/schema';
-
-declare const __ENV__: {
-    server: boolean;
-};
-type JSONValue = string | number | boolean | {
-    [x: string]: JSONValue;
-} | Array<JSONValue>;
-type JSONProps = {
-    [x: string]: JSONValue;
-};
-type Loader = () => Promise<WidgetModule>;
-interface WebWidgetClientProps {
-    base: string;
-    data: JSONProps;
-    import: string;
-    innerHTML?: string;
-    loading?: string;
-    name?: string;
-    recovering: boolean;
-}
-declare function WebWidgetClient({ base, data, import: url, innerHTML, loading, name, recovering, }: WebWidgetClientProps): react.DOMElement<{
-    dangerouslySetInnerHTML: {
-        __html: string;
-    };
-    base: string;
-    data: string;
-    import: string;
-    loading: string | undefined;
-    name: string | undefined;
-    rendertarget: string;
-}, Element>;
-declare function renderServerWidget(loader: Loader, data: any): Promise<string>;
-interface WebWidgetProps extends WebWidgetClientProps {
-    fallback?: ReactNode;
-    children?: ReactNode | undefined;
-    loader?: Loader;
-}
-declare function WebWidget({ base, children, data, fallback, import: url, loader, loading, name, recovering, }: WebWidgetProps): react_jsx_runtime.JSX.Element;
-type WebWidgetFactoryProps = JSONProps & {
-    children?: ReactNode;
-    fallback?: ReactNode;
-};
-interface DefineWebWidgetOptions {
-    loading?: string;
-    name?: string;
-    recovering?: boolean;
-}
-declare function defineWebWidget(loader: Loader, base: string, { loading, name, recovering }?: DefineWebWidgetOptions): ({ children, fallback, ...data }: WebWidgetFactoryProps) => react_jsx_runtime.JSX.Element;
-interface ClientOptions {
-    loading?: "lazy";
-    name?: string;
-}
-declare function defineClient(loader: Loader, base: string, { loading, name }?: ClientOptions): ({ children, fallback, ...data }: WebWidgetFactoryProps) => react_jsx_runtime.JSX.Element;
-declare function defineClientOnly(loader: Loader, base: string, { loading, name }?: ClientOptions): ({ children, fallback, ...data }: WebWidgetFactoryProps) => react_jsx_runtime.JSX.Element;
-
-export { ClientOptions as C, DefineWebWidgetOptions as D, WebWidget as W, __ENV__ as _, WebWidgetClientProps as a, WebWidgetClient as b, WebWidgetProps as c, defineWebWidget as d, defineClient as e, defineClientOnly as f, renderServerWidget as r };