@web-widget/react 2.3.1 → 3.0.0-beta.2

package/dist/chunk-VQFEYZQS.js

@@ -0,0 +1,131 @@
+// src/components.ts
+import { WebWidgetRenderer } from "@web-widget/web-widget";
+import {
+  Component,
+  Fragment,
+  Suspense,
+  createElement,
+  isValidElement,
+  use,
+  memo
+} from "react";
+var renderWebWidget = function({
+  children,
+  loader,
+  ...props
+}) {
+  if (!loader) {
+    throw new TypeError(`Missing loader.`);
+  }
+  if (children) {
+    throw new TypeError(`Children not supported.`);
+  }
+  const widget = new WebWidgetRenderer(loader, {
+    ...props,
+    // TODO children
+    children: ""
+  });
+  const localName = widget.localName;
+  const attributes = widget.attributes;
+  const innerHTML = widget.renderInnerHTMLToString().catch(
+    (err) => err instanceof Error ? err : new Error(String(err))
+  );
+  return {
+    localName,
+    attributes,
+    innerHTML
+  };
+};
+function WebWidget({
+  localName,
+  attributes,
+  innerHTML,
+  errorFallback
+}) {
+  const html = use(innerHTML);
+  if (html instanceof Error) {
+    console.error("[ReactWidget] Rendering error:", html);
+    return createElement(Fragment, null, errorFallback);
+  }
+  return createElement(localName, {
+    ...attributes,
+    dangerouslySetInnerHTML: { __html: html },
+    // NOTE: Since the innerHTML property of a widget
+    // will inevitably differ between the server and the client,
+    // this turns off hydration mismatch warnings.
+    suppressHydrationWarning: true
+  });
+}
+function resolveFallback(fallback) {
+  var _a;
+  if (fallback !== null && typeof fallback === "object" && !isValidElement(fallback) && !Array.isArray(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
+  };
+}
+var WidgetErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error) {
+    console.error("[ReactWidget] Rendering error:", error);
+  }
+  render() {
+    var _a;
+    if (this.state.hasError) {
+      return (_a = this.props.fallback) != null ? _a : null;
+    }
+    return this.props.children;
+  }
+};
+function container(loader, options = {}) {
+  return memo(function ReactWidget({
+    children,
+    widget: {
+      fallback,
+      loading = ((_a) => (_a = options.loading) != null ? _a : "lazy")(),
+      serverOnly,
+      clientOnly
+    } = {},
+    ...data
+  }) {
+    var _a2;
+    const renderStage = serverOnly ? "server" : clientOnly ? "client" : options.renderStage;
+    const { pendingFallback, errorFallback } = resolveFallback(fallback);
+    return createElement(
+      WidgetErrorBoundary,
+      { fallback: errorFallback },
+      createElement(Suspense, {
+        fallback: pendingFallback,
+        children: createElement(WebWidget, {
+          errorFallback,
+          ...renderWebWidget({
+            ...options,
+            children,
+            data,
+            loader,
+            loading,
+            renderStage,
+            renderTarget: (_a2 = options.renderTarget) != null ? _a2 : "light"
+          })
+        })
+      })
+    );
+  });
+}
+
+export {
+  resolveFallback,
+  container
+};

package/dist/components-BdC3VZlV.d.ts

@@ -0,0 +1,104 @@
+import { WebWidgetRendererOptions, Loader } from '@web-widget/web-widget';
+import { ExtractWidgetProps } from '@web-widget/schema';
+import { FunctionComponent, ReactNode } from 'react';
+
+interface ReactWidgetComponent<T> extends FunctionComponent<T & ReactWidgetProps> {
+}
+/**
+ * Extract the props type `P` from a widget module's default export.
+ *
+ * Handles multiple component paradigms so that cross-framework widgets
+ * (e.g. Vue imported into React) retain their props types:
+ *
+ * - React: `ComponentType<P>`, `FunctionComponent<P>`, etc.
+ * - Vue: components expose `$props` via a constructor signature.
+ * - Fallback: `unknown` when no pattern matches.
+ */
+interface WebWidgetProps {
+    base?: WebWidgetRendererOptions['base'];
+    children?: ReactNode;
+    data?: WebWidgetRendererOptions['data'];
+    import?: WebWidgetRendererOptions['import'];
+    inactive?: WebWidgetRendererOptions['inactive'];
+    loader: Loader;
+    meta?: WebWidgetRendererOptions['meta'];
+    loading?: WebWidgetRendererOptions['loading'];
+    name?: WebWidgetRendererOptions['name'];
+    renderStage?: WebWidgetRendererOptions['renderStage'];
+    renderTarget?: WebWidgetRendererOptions['renderTarget'];
+}
+type DefineWebWidgetOptions = Partial<Pick<WebWidgetRendererOptions, 'base' | 'import' | 'loading' | 'name' | 'renderStage' | 'renderTarget'>>;
+type WidgetFallback = ReactNode | {
+    pending?: ReactNode;
+    error?: ReactNode;
+};
+/**
+ * Resolve a WidgetFallback into separate pending and error UI.
+ * - `ReactNode`: used for both pending and error.
+ * - `{ pending?, error? }`: error defaults to pending if omitted.
+ */
+declare function resolveFallback(fallback: WidgetFallback | undefined): {
+    pendingFallback: ReactNode;
+    errorFallback: ReactNode;
+};
+type 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.
+     *
+     * - `ReactNode` — used for both pending (Suspense) and error (ErrorBoundary).
+     * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
+     *
+     * @example
+     * // Simple: same UI for both states
+     * <Widget widget={{ fallback: <Spinner /> }} />
+     *
+     * // Differentiated: separate pending and error UI
+     * <Widget widget={{ fallback: { pending: <Spinner />, error: <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;
+};
+interface ReactWidgetProps {
+    children?: ReactNode;
+    /** Container configuration, isolated from widget's own props */
+    widget?: WidgetContainerConfig;
+}
+/**
+ * Container function (WebWidgetAdapter protocol).
+ *
+ * Wraps a widget module loader into a React component with full props
+ * type inference from the source module's default export.
+ *
+ * For same-framework imports (React → React), props types are inferred
+ * automatically. Cross-framework imports use explicit `container()` calls;
+ * sources without a structural props contract can use `container<Props>()`.
+ *
+ * @example
+ * ```tsx
+ * import { container } from '@web-widget/react/adapter';
+ *
+ * // Same-framework: full type inference
+ * const Counter = container(() => import('./Counter@widget.tsx'));
+ * //    ^? ReactWidgetComponent<{ count: number }>
+ *
+ * <Counter count={42} />  // type-checked: ✓
+ *
+ * // Cross-framework: explicit container() recommended
+ * const VueCounter = container(() => import('./Counter@widget.vue'));
+ * <VueCounter count={42} />  // type-checked: ✓
+ * ```
+ */
+declare function container<M>(loader: () => Promise<M>, options?: DefineWebWidgetOptions): ReactWidgetComponent<ExtractWidgetProps<M>>;
+declare function container<Props>(loader: Loader, options?: DefineWebWidgetOptions): ReactWidgetComponent<Props>;
+
+export { type DefineWebWidgetOptions as D, type ReactWidgetComponent as R, type WebWidgetProps as W, type ReactWidgetProps as a, type WidgetContainerConfig as b, type WidgetFallback as c, container as d, resolveFallback as r };

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

@@ -0,0 +1,9 @@
+import * as _web_widget_schema from '@web-widget/schema';
+import { FunctionComponent } from 'react';
+export * from '@web-widget/helpers';
+export { D as DefineWebWidgetOptions, R as ReactWidgetComponent, a as ReactWidgetProps, W as WebWidgetProps, b as WidgetContainerConfig, c as WidgetFallback, d as container, r as resolveFallback } from './components-BdC3VZlV.js';
+import '@web-widget/web-widget';
+
+declare const render: _web_widget_schema.ClientRender<FunctionComponent<{}>, unknown, _web_widget_schema.ClientRenderOptions, void | _web_widget_schema.ClientRenderResult<unknown>>;
+
+export { render };

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

@@ -1,20 +1,20 @@
 import {
-  defineWebWidget
-} from "./chunk-RYJ3BJDY.js";
+  container,
+  resolveFallback
+} from "./chunk-VQFEYZQS.js";
 
-// src/client.ts
+// src/adapter.client.ts
 import { defineClientRender } from "@web-widget/helpers";
 import { createElement, StrictMode } from "react";
 import { createRoot, hydrateRoot } from "react-dom/client";
 export * from "@web-widget/helpers";
-import { useWidgetSyncState } from "@web-widget/helpers/state";
 var render = 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 root;
@@ -24,9 +24,9 @@ var render = defineClientRender(
         let vNode = isAsyncFunction ? await component(data) : createElement(component, data);
         vNode = createElement(StrictMode, null, vNode);
         if (recovering) {
-          root = hydrateRoot(container, vNode);
+          root = hydrateRoot(container2, vNode);
         } else {
-          root = createRoot(container);
+          root = createRoot(container2);
           root.render(vNode);
         }
       },
@@ -38,7 +38,7 @@ var render = defineClientRender(
   }
 );
 export {
-  defineWebWidget,
+  container,
   render,
-  useWidgetSyncState as useWidgetState
+  resolveFallback
 };

package/dist/{react.server.d.ts → react.adapter.server.d.ts}

@@ -1,9 +1,8 @@
-import * as _web_widget_helpers from '@web-widget/helpers';
-export * from '@web-widget/helpers';
+import * as _web_widget_schema from '@web-widget/schema';
 import { FunctionComponent } from 'react';
 import { PrerenderOptions } from 'react-dom/static';
-export { useWidgetSyncState as useWidgetState } from '@web-widget/helpers/state';
-export { D as DefineWebWidgetOptions, R as ReactWidgetComponent, W as WebWidgetProps, a as WebWidgetSuspenseProps, d as defineWebWidget } from './components-BlwPaPdf.js';
+export * from '@web-widget/helpers';
+export { D as DefineWebWidgetOptions, R as ReactWidgetComponent, a as ReactWidgetProps, W as WebWidgetProps, b as WidgetContainerConfig, c as WidgetFallback, d as container, r as resolveFallback } from './components-BdC3VZlV.js';
 import { RenderToReadableStreamOptions } from 'react-dom/server';
 import '@web-widget/web-widget';
 
@@ -26,6 +25,6 @@ type StreamOptions = {
 interface ReactRenderOptions {
     react?: StreamOptions;
 }
-declare const render: _web_widget_helpers.ServerRender<FunctionComponent<{}>, unknown, _web_widget_helpers.ServerRenderOptions, _web_widget_helpers.ServerRenderResult>;
+declare const render: _web_widget_schema.ServerRender<FunctionComponent<{}>, unknown, _web_widget_schema.ServerRenderOptions, _web_widget_schema.ServerRenderResult>;
 
 export { type ReactRenderOptions, render };

package/dist/{react.server.js → react.adapter.server.js}

@@ -1,8 +1,9 @@
 import {
-  defineWebWidget
-} from "./chunk-RYJ3BJDY.js";
+  container,
+  resolveFallback
+} from "./chunk-VQFEYZQS.js";
 
-// src/server.ts
+// src/adapter.server.ts
 import { defineServerRender } from "@web-widget/helpers";
 import { createElement, StrictMode } from "react";
 
@@ -26,9 +27,8 @@ async function readableStreamToString(readableStream) {
   return result;
 }
 
-// src/server.ts
+// src/adapter.server.ts
 export * from "@web-widget/helpers";
-import { useWidgetSyncState } from "@web-widget/helpers/state";
 var DEFAULT_TIMEOUT_MS = 1e3 * 10;
 var render = defineServerRender(
   async (component, data, { progressive, react }) => {
@@ -37,32 +37,35 @@ var render = defineServerRender(
       throw new TypeError(`Missing component.`);
     }
     const reactRenderOptions = Object.create(react != null ? react : null);
-    let error;
     const { onError, awaitAllReady, signal } = reactRenderOptions;
     reactRenderOptions.signal = signal != null ? signal : AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+    const preShellErrors = [];
+    let shellRendered = false;
     reactRenderOptions.onError = (e, i) => {
-      error = e;
-      onError == null ? void 0 : onError(e instanceof Error ? e : new Error(String(e)), i);
-      if (!onError && progressive && !awaitAllReady) {
+      if (shellRendered) {
         console.error(e);
+      } else {
+        preShellErrors.push(e);
       }
+      onError == null ? void 0 : onError(e instanceof Error ? e : new Error(String(e)), i);
     };
     const isAsyncFunction = Object.prototype.toString.call(component) === "[object AsyncFunction]";
     let vNode = isAsyncFunction ? await component(data) : createElement(component, data);
     vNode = createElement(StrictMode, null, vNode);
     const renderMethod = progressive ? renderToReadableStream : renderToString;
     const result = await renderMethod(vNode, reactRenderOptions);
+    shellRendered = true;
+    for (const e of preShellErrors) {
+      console.error(e);
+    }
     if (progressive && awaitAllReady && "allReady" in result) {
       await result.allReady;
     }
-    if (error) {
-      throw error;
-    }
     return result;
   }
 );
 export {
-  defineWebWidget,
+  container,
   render,
-  useWidgetSyncState as useWidgetState
+  resolveFallback
 };

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/globals.d.ts

@@ -1,47 +1,50 @@
 /// <reference types="react" />
 
-interface WebWidgetSuspenseProps {
-  fallback?: ReactNode;
-  experimental_loading?: 'lazy' | 'eager' | 'idle';
-  renderStage?: 'server' | 'client';
-  experimental_renderTarget?: 'light' | 'shadow';
+type WebWidgetFallback = ReactNode | { pending?: ReactNode; error?: ReactNode };
+
+/**
+ * Container configuration, isolated from the widget's own props.
+ */
+type 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.
+   *
+   * - `ReactNode` — used for both pending (Suspense) and error (ErrorBoundary).
+   * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
+   */
+  fallback?: WebWidgetFallback;
+  /** Client-side module loading strategy: `'lazy'` loads on first render, `'eager'` on module parse, `'idle'` on browser idle. */
+  loading?: 'lazy' | 'eager' | 'idle';
+  /** 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;
+};
+
+interface ReactWidgetProps {
+  widget?: WidgetContainerConfig;
 }
 
 interface ReactWidgetComponent<T = unknown> extends ComponentProps<any> {
   (
     props: {
       children?: ReactNode;
-    } & WebWidgetSuspenseProps &
+    } & ReactWidgetProps &
       T
   ): ReactNode;
 }
 
 declare namespace JSX {
-  interface IntrinsicAttributes extends WebWidgetSuspenseProps {
+  interface IntrinsicAttributes extends ReactWidgetProps {
     key?: Key | null | undefined;
   }
 }
 
-declare module '*.widget.jsx' {
-  const reactWidgetComponent: ReactWidgetComponent;
-  export default reactWidgetComponent;
-}
-
-declare module '*.widget.tsx' {
-  const reactWidgetComponent: ReactWidgetComponent;
-  export default reactWidgetComponent;
-}
-
-declare module '*?as=jsx' {
-  const reactWidgetComponent: ReactWidgetComponent<any>;
-  export default reactWidgetComponent;
-}
-
-declare module '*?as=tsx' {
-  const reactWidgetComponent: ReactWidgetComponent<any>;
-  export default reactWidgetComponent;
-}
-
 declare module 'react-dom/server.edge' {
   import type { ReactNode } from 'react';
   import type {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-widget/react",
   "description": "React adapter",
-  "version": "2.3.1",
+  "version": "3.0.0-beta.2",
   "homepage": "https://github.com/web-widget/web-widget#readme",
   "repository": {
     "type": "git",
@@ -13,56 +13,66 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@rollup/pluginutils": "^5.1.4",
-    "@web-widget/helpers": "2.3.1",
-    "@web-widget/schema": "2.3.1",
-    "@web-widget/vite-plugin": "2.3.1",
-    "@web-widget/web-widget": "2.3.1"
+    "@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"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
+    "jest": "^29.7.0",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
+    "ts-jest": "29.2.1",
     "tsup": "^8.3.4",
-    "typescript": "^5.5.4",
+    "typescript": "^5.9.3",
     "vite": "^8.0.12"
   },
   "exports": {
     ".": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./adapter": {
       "worker": {
-        "types": "./dist/react.server.d.ts",
-        "default": "./dist/react.server.js"
+        "types": "./dist/react.adapter.server.d.ts",
+        "default": "./dist/react.adapter.server.js"
       },
       "browser": {
-        "types": "./dist/react.client.d.ts",
-        "default": "./dist/react.client.js"
+        "types": "./dist/react.adapter.client.d.ts",
+        "default": "./dist/react.adapter.client.js"
       },
       "default": {
-        "types": "./dist/react.server.d.ts",
-        "default": "./dist/react.server.js"
+        "types": "./dist/react.adapter.server.d.ts",
+        "default": "./dist/react.adapter.server.js"
       }
     },
-    "./vite": {
-      "types": "./dist/vite.d.ts",
-      "default": "./dist/vite.js"
-    },
     "./globals": {
       "types": "./globals.d.ts"
     }
   },
+  "webWidgetAdapter": {
+    "version": "1.0.0",
+    "name": "react",
+    "extensions": [
+      ".tsx",
+      ".jsx"
+    ],
+    "adapter": "./adapter"
+  },
   "files": [
     "dist",
     "globals.d.ts"
   ],
   "peerDependencies": {
     "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "vite": "^8.0.12"
+    "react-dom": "^19.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
+  "sideEffects": false,
   "type": "module",
   "scripts": {
     "build": "pnpm exec tsup",
@@ -70,6 +80,7 @@
     "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": "jest"
   }
 }

package/dist/chunk-RYJ3BJDY.js

@@ -1,69 +0,0 @@
-// src/components.ts
-import { WebWidgetRenderer } from "@web-widget/web-widget";
-import { Suspense, createElement, use, memo } from "react";
-var renderWebWidget = function({
-  children,
-  loader,
-  ...props
-}) {
-  if (!loader) {
-    throw new TypeError(`Missing loader.`);
-  }
-  if (children) {
-    throw new TypeError(`Children not supported.`);
-  }
-  const widget = new WebWidgetRenderer(loader, {
-    ...props,
-    // TODO children
-    children: ""
-  });
-  const localName = widget.localName;
-  const attributes = widget.attributes;
-  const innerHTML = widget.renderInnerHTMLToString();
-  return {
-    localName,
-    attributes,
-    innerHTML
-  };
-};
-function WebWidget({ localName, attributes, innerHTML }) {
-  const html = use(innerHTML);
-  return createElement(localName, {
-    ...attributes,
-    dangerouslySetInnerHTML: { __html: html },
-    // NOTE: Since the innerHTML property of a widget
-    // will inevitably differ between the server and the client,
-    // this turns off hydration mismatch warnings.
-    suppressHydrationWarning: true
-  });
-}
-function defineWebWidget(loader, options) {
-  return memo(function WebWidgetSuspense({
-    children,
-    fallback,
-    experimental_loading = ((_a) => (_a = options.loading) != null ? _a : "lazy")(),
-    renderStage = options.renderStage,
-    experimental_renderTarget = ((_b) => (_b = options.renderTarget) != null ? _b : "light")(),
-    ...data
-  }) {
-    return createElement(Suspense, {
-      fallback,
-      children: createElement(
-        WebWidget,
-        renderWebWidget({
-          ...options,
-          children,
-          data,
-          loader,
-          loading: experimental_loading,
-          renderStage,
-          renderTarget: experimental_renderTarget
-        })
-      )
-    });
-  });
-}
-
-export {
-  defineWebWidget
-};

package/dist/components-BlwPaPdf.d.ts

@@ -1,30 +0,0 @@
-import * as react from 'react';
-import { FunctionComponent, ReactNode } from 'react';
-import { WebWidgetRendererOptions, Loader } from '@web-widget/web-widget';
-
-interface ReactWidgetComponent<T> extends FunctionComponent<T & WebWidgetSuspenseProps> {
-}
-interface WebWidgetProps {
-    base?: WebWidgetRendererOptions['base'];
-    children?: ReactNode;
-    data?: WebWidgetRendererOptions['data'];
-    import?: WebWidgetRendererOptions['import'];
-    inactive?: WebWidgetRendererOptions['inactive'];
-    loader: Loader;
-    meta?: WebWidgetRendererOptions['meta'];
-    loading?: WebWidgetRendererOptions['loading'];
-    name?: WebWidgetRendererOptions['name'];
-    renderStage?: WebWidgetRendererOptions['renderStage'];
-    renderTarget?: WebWidgetRendererOptions['renderTarget'];
-}
-type DefineWebWidgetOptions = Partial<Pick<WebWidgetRendererOptions, 'base' | 'import' | 'loading' | 'name' | 'renderStage' | 'renderTarget'>>;
-interface WebWidgetSuspenseProps {
-    children?: ReactNode;
-    fallback?: ReactNode;
-    experimental_loading?: WebWidgetRendererOptions['loading'];
-    renderStage?: WebWidgetRendererOptions['renderStage'];
-    experimental_renderTarget?: WebWidgetRendererOptions['renderTarget'];
-}
-declare function defineWebWidget(loader: Loader, options: DefineWebWidgetOptions): react.NamedExoticComponent<WebWidgetSuspenseProps>;
-
-export { type DefineWebWidgetOptions as D, type ReactWidgetComponent as R, type WebWidgetProps as W, type WebWidgetSuspenseProps as a, defineWebWidget as d };

package/dist/react.client.d.ts

@@ -1,10 +0,0 @@
-import * as _web_widget_helpers from '@web-widget/helpers';
-export * from '@web-widget/helpers';
-import { FunctionComponent } from 'react';
-export { useWidgetSyncState as useWidgetState } from '@web-widget/helpers/state';
-export { D as DefineWebWidgetOptions, R as ReactWidgetComponent, W as WebWidgetProps, a as WebWidgetSuspenseProps, d as defineWebWidget } from './components-BlwPaPdf.js';
-import '@web-widget/web-widget';
-
-declare const render: _web_widget_helpers.ClientRender<FunctionComponent<{}>, unknown, _web_widget_helpers.ClientRenderOptions, void | _web_widget_helpers.ClientRenderResult<unknown>>;
-
-export { render };

package/dist/vite.d.ts

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

package/dist/vite.js

@@ -1,43 +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 reactWebWidgetPlugin(options) {
-  const {
-    provide = "@web-widget/react",
-    workspace = "",
-    export: exportWidget = {},
-    import: importWidget = {},
-    manifest
-  } = options != null ? options : {};
-  const workspacePattern = workspace ? escapeRegExp(normalizePath(appendSlash(workspace))) : workspace;
-  const widgetPattern = `[.@]widget`;
-  const modulesPattern = `[.@](?:route|widget)`;
-  const extensionPattern = `\\.(?:tsx|jsx)`;
-  return webWidgetPlugin({
-    manifest,
-    provide,
-    export: {
-      include: new RegExp(
-        `^${workspacePattern}[^?]*${modulesPattern}${extensionPattern}$`
-      ),
-      ...exportWidget
-    },
-    import: {
-      include: new RegExp(`^[^?]*${widgetPattern}\\.[^?]*$`),
-      includeImporter: new RegExp(
-        `^${workspacePattern}[^?]*${extensionPattern}$`
-      ),
-      ...importWidget
-    }
-  });
-}
-export {
-  reactWebWidgetPlugin as default
-};