skybridge 0.0.0-dev.d9ee984 → 0.0.0-dev.dc4ed16

package/README.md

@@ -1,3 +1,415 @@
+<div align="center">
+
 # Skybridge
 
-Skybridge is a framework for building ChatGPT apps
+**Skybridge is the TypeScript framework for building ChatGPT apps**
+
+[![By Alpic](https://img.shields.io/badge/Made%20by%20Alpic-f6ffed?logo=alpic)](https://alpic.ai)
+
+![NPM Downloads](https://img.shields.io/npm/dm/skybridge?color=e90060)
+![NPM Version](https://img.shields.io/npm/v/skybridge?color=e90060)
+![GitHub License](https://img.shields.io/github/license/alpic-ai/skybridge?color=e90060)
+
+</div>
+
+Skybridge comes with 2 packages:
+
+- `skybridge/server`: A drop-in replacement of the `@modelcontextprotocol/sdk` official `McpServer` class with extra features for widget development.
+- `skybridge/web`: A react library with hooks and components to build widgets on the underlying _OpenAI iFrame skybridge_ runtime.
+
+## Quick start
+
+To get started in less than a minute, you can [create a new repository](https://github.com/new?template_name=apps-sdk-template&template_owner=alpic-ai) using our [ChatGPT SDK template](https://github.com/alpic-ai/apps-sdk-template). This template includes a basic setup for both the server and the widgets.
+
+## Installation
+
+```bash
+pnpm add skybridge
+```
+
+## Concepts
+
+### Widgets
+
+> A widget is a UI component that turns structured tool results into a human-friendly UI. Those are built using React components. They are rendered inside an iframe inline with the conversation on ChatGPT.
+
+Each widget in your app must have a unique name. The name is used to bridge the tool invocation result with the widget React component.
+
+For example, in order to register a new widget named `pokemon` on your ChatGPT app. You should have the following file structure and file contents:
+
+_Project structure_
+
+```
+server/
+└── src/
+    └── index.ts // Register the widget with McpServer.widget()
+web/
+└── src/
+    └── widgets/
+        └── pokemon.tsx // Use the same widget name as the file name
+```
+
+_server/src/index.ts_
+
+```ts
+import { McpServer } from "skybridge/server";
+
+const server = new McpServer();
+
+server.widget(
+  "pokemon"
+  // Remaining arguments...
+);
+```
+
+_web/src/widgets/pokemon.tsx_
+
+```ts
+import { mountWidget } from "skybridge/web";
+
+const Pokemon: React.FunctionComponent = () => {
+  // Your React component code goes here...
+};
+
+mountWidget(<Pokemon />);
+```
+
+## Packages
+
+### skybridge/server
+
+The `skybridge/server` package is a drop-in replacement of the `@modelcontextprotocol/sdk` official `McpServer` class with extra features for widget development. If you're already using the `@modelcontextprotocol/sdk`, you can simply replace your `McpServer` import with `skybridge/server` and you're good to go.
+
+### skybridge/web
+
+The `skybridge/web` package is a react library with hooks and components to build widgets on the underlying _OpenAI iFrame skybridge_ runtime.
+
+**Vite plugin**
+
+The `skybridge/web` package comes with a Vite plugin that allows you to build your widgets as regular Vite apps.
+
+```ts
+import { defineConfig } from "vite";
+import { skybridge } from "skybridge/web";
+
+export default defineConfig({
+  plugins: [skybridge()],
+});
+```
+
+**Typed Hooks**
+
+Skybridge provides fully typed hooks that give you autocomplete for tool names and type inference for inputs/outputs - similar to tRPC. This is opt-in and requires exporting your server type.
+
+> **Tip:** For the best TypeScript experience, use typed hooks throughout your application. They provide autocomplete, type safety, and better IDE support.
+
+> **Important:** For `generateHelpers` to work correctly, your MCP server must be defined using method chaining (e.g., `server.widget(...).widget(...).registerTool(...)`). This ensures TypeScript can properly infer the tool registry type from the chained calls.
+
+**Examples:**
+
+✅ **Works** - Using method chaining:
+
+```ts
+import { McpServer } from "skybridge/server";
+import { z } from "zod";
+
+const server = new McpServer({ name: "my-app", version: "1.0" }, {})
+  .widget("search-voyage", {}, {
+    inputSchema: { destination: z.string() },
+  }, async ({ destination }) => {
+    return { content: [{ type: "text", text: `Found trips to ${destination}` }] };
+  })
+  .registerTool("calculate-price", {
+    inputSchema: { tripId: z.string() },
+  }, async ({ tripId }) => {
+    return { content: [{ type: "text", text: `Price for ${tripId}` }] };
+  });
+
+export type AppType = typeof server; // ✅ Type inference works correctly
+```
+
+❌ **Doesn't work** - Without method chaining:
+
+```ts
+import { McpServer } from "skybridge/server";
+import { z } from "zod";
+
+const server = new McpServer({ name: "my-app", version: "1.0" }, {});
+
+server.widget("search-voyage", {}, {
+  inputSchema: { destination: z.string() },
+}, async ({ destination }) => {
+  return { content: [{ type: "text", text: `Found trips to ${destination}` }] };
+});
+
+server.registerTool("calculate-price", {
+  inputSchema: { tripId: z.string() },
+}, async ({ tripId }) => {
+  return { content: [{ type: "text", text: `Price for ${tripId}` }] };
+});
+
+export type AppType = typeof server; // ❌ Type inference fails - tool registry is empty
+```
+
+_Server setup (server/src/index.ts)_
+
+```ts
+import { McpServer } from "skybridge/server";
+import { z } from "zod";
+
+const server = new McpServer({ name: "my-app", version: "1.0" }, {})
+  .widget("search-voyage", {}, {
+    description: "Search for trips",
+    inputSchema: {
+      destination: z.string(),
+      departureDate: z.string().optional(),
+    },
+    outputSchema: {
+      results: z.array(z.object({ id: z.string(), name: z.string() })),
+      totalCount: z.number(),
+    },
+  }, async ({ destination }) => {
+    // Your tool logic here...
+    return { content: [{ type: "text", text: `Found trips to ${destination}` }] };
+  })
+  .widget("get-details", {}, {
+    inputSchema: { tripId: z.string() },
+  }, async ({ tripId }) => {
+    return { content: [{ type: "text", text: `Details for ${tripId}` }] };
+  });
+
+// Export the server type for the client
+export type AppType = typeof server;
+```
+
+_One-time setup (web/src/skybridge.ts)_
+
+Create typed hooks once and export them for use across your app. This file acts as a bridge between your server types and your widgets:
+
+```ts
+import type { AppType } from "../server"; // type-only import
+import { generateHelpers } from "skybridge/web";
+
+export const { useCallTool, useToolInfo } = generateHelpers<AppType>();
+```
+
+_Usage in widgets (web/src/widgets/search.tsx)_
+
+```tsx
+import { useCallTool, useToolInfo } from "../skybridge"; // import typed hooks
+
+export function SearchWidget() {
+  const { callTool, data, isPending } = useCallTool("search-voyage");
+  //                                                 ^ autocomplete for tool names
+  const toolInfo = useToolInfo<"search-voyage">();
+  //                              ^ autocomplete for widget names
+
+  const handleSearch = () => {
+    callTool({ destination: "Spain" });
+    //         ^ autocomplete for input fields
+  };
+
+  return (
+    <div>
+      <button onClick={handleSearch} disabled={isPending}>
+        Search
+      </button>
+      {toolInfo.isSuccess && (
+        <div>Found {toolInfo.output.structuredContent.totalCount} results</div>
+        //                      ^ typed output
+      )}
+    </div>
+  );
+}
+```
+
+**Hooks**
+
+The `skybridge/web` package comes with a set of hooks to help you build your widgets :
+
+- `useOpenAiGlobal`: A generic hook to get any global data from the OpenAI iFrame skybridge runtime (in `window.openai`).
+- `useToolOutput`: A hook to get the initial tool `structuredContent` returned when rendering the widget for the first time. The data inside this hook is not updated when the tool is called again.
+- `useToolResponseMetadata`: A hook to get the initial tool `meta` returned when rendering the widget for the first time. The data inside this hook is not updated when the tool is called again.
+- `useToolInfo`: A hook to get the tool input, output, and response metadata with type inference. Provides a discriminated union based on status (pending/success).
+- `useCallTool`: A @tanstack/react-query inspired hook to send make additional tool calls inside a widget.
+- `generateHelpers`: A factory that creates typed versions of `useCallTool` and `useToolInfo` with full type inference from your server type.
+
+_useOpenAiGlobal_
+
+```ts
+import { useOpenAiGlobal } from "skybridge/web";
+
+const theme = useOpenAiGlobal("theme");
+```
+
+_useToolOutput_
+
+```ts
+import { useToolOutput } from "skybridge/web";
+
+const toolOutput = useToolOutput();
+```
+
+_useToolResponseMetadata_
+
+```ts
+import { useToolResponseMetadata } from "skybridge/web";
+
+const toolResponseMetadata = useToolResponseMetadata();
+```
+
+_useToolInfo_
+
+```ts
+import { useToolInfo } from "skybridge/web";
+
+const toolInfo = useToolInfo<{
+  input: { query: string };
+  output: { results: string[] };
+  responseMetadata: { id: number };
+}>();
+
+// toolInfo.input is typed based on the input type
+// toolInfo.output.structuredContent is typed based on the output type (undefined when pending)
+// toolInfo.status narrows correctly: "pending" | "success"
+
+if (toolInfo.isPending) {
+  // toolInfo.output is undefined here (pending state)
+  console.log(toolInfo.input.query);
+}
+
+if (toolInfo.isSuccess) {
+  // toolInfo.output.structuredContent is typed here
+  console.log(toolInfo.output.structuredContent.results);
+}
+```
+
+_useToolInfo_ with typed hooks (recommended)
+
+```tsx
+import { useToolInfo } from "../skybridge"; // import typed hooks
+
+export function SearchWidget() {
+  const toolInfo = useToolInfo<"search-voyage">();
+  //                              ^ autocomplete for widget names
+  // toolInfo.input is typed as { destination: string; departureDate?: string; ... }
+  // toolInfo.output.structuredContent is typed as { results: Array<...>; totalCount: number; }
+
+  if (toolInfo.isSuccess) {
+    return <div>Found {toolInfo.output.structuredContent.totalCount} results</div>;
+  }
+
+  return <div>Searching for {toolInfo.input.destination}...</div>;
+}
+```
+
+_useCallTool_ in synchronous mode
+
+```ts
+import { useCallTool } from "skybridge/web";
+
+export const TestTool: React.FunctionComponent = () => {
+  const { callTool, isPending } = useCallTool("myToolName");
+
+  return (
+    <div>
+      <button
+        disabled={isPending}
+        onClick={() => {
+          callTool({ input: "test input" }, {
+            onSuccess: (data) => {
+              alert("Tool returned: " + data);
+            },
+          });
+      >
+        Call Tool inside a widget
+      </button>
+    </div>
+  );
+};
+```
+
+_useCallTool_ in asynchronous mode
+
+```ts
+import { useCallTool } from "skybridge/web";
+
+export const TestTool: React.FunctionComponent = () => {
+  const { callToolAsync, isPending } = useCallTool("myToolName");
+
+  return (
+    <div>
+      <button
+        disabled={isPending}
+        onClick={async () => {
+          const data = await callToolAsync({ input: "test input" });
+          alert("Tool returned: " + data);
+        }}
+      >
+        Call Tool inside a widget
+      </button>
+    </div>
+  );
+};
+```
+
+**State Management**
+
+The `skybridge/web` package provides `createStore` for creating Zustand stores with automatic persistence to `window.openai.widgetState`. This is useful when you need more advanced state management than what `useWidgetState` provides.
+
+_createStore_
+
+```ts
+import { createStore } from "skybridge/web";
+
+type CounterState = {
+  count: number;
+  increment: () => void;
+  decrement: () => void;
+};
+
+const useCounterStore = createStore<CounterState>(
+  (set) => ({
+    count: 0,
+    increment: () => set((state) => ({ count: state.count + 1 })),
+    decrement: () => set((state) => ({ count: state.count - 1 })),
+  }),
+  { count: 0 } // Optional default state
+);
+
+// Use in your component
+function CounterWidget() {
+  const { count, increment, decrement } = useCounterStore();
+
+  return (
+    <div>
+      <p>Count: {count}</p>
+      <button onClick={increment}>Increment</button>
+      <button onClick={decrement}>Decrement</button>
+    </div>
+  );
+}
+```
+
+The `createStore` function:
+
+- Automatically persists state to `window.openai.widgetState`
+- Syncs with external state changes from the host
+- Only serializes state data, not methods
+
+## Migrate your existing MCP server to a ChatGPT app
+
+If you're already using the `@modelcontextprotocol/sdk` to build a MCP server, you can migrate to a ChatGPT app by following these steps:
+
+1. Replace your `McpServer` import from `@modelcontextprotocol/sdk` with the same import from `skybridge/server`
+2. Create a new vite project in a folder named `web` and install the `skybridge` package
+3. Replace the `vite.config.ts` file with the following:
+
+```ts
+import { defineConfig } from "vite";
+import { skybridge } from "skybridge/web";
+
+export default defineConfig({
+  plugins: [skybridge()],
+});
+```

package/dist/src/server/index.d.ts

@@ -0,0 +1,4 @@
+export { McpServer } from "./server.js";
+export { widgetsDevServer } from "./widgetsDevServer.js";
+export type { ToolDef, McpServerTypes } from "./server.js";
+export type { InferTools, AnyToolRegistry, ToolNames, ToolInput, ToolOutput, } from "./inferUtilityTypes.js";

package/dist/{server/index.d.ts → src/server/index.js}

@@ -1,3 +1,3 @@
 export { McpServer } from "./server.js";
 export { widgetsDevServer } from "./widgetsDevServer.js";
-export { mcp } from "./middleware.js";
+//# sourceMappingURL=index.js.map

package/dist/src/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/server/inferUtilityTypes.d.ts

@@ -0,0 +1,54 @@
+import type { McpServerTypes, ToolDef } from "./server.js";
+/**
+ * Any tool registry shape (includes both widgets and regular tools).
+ * Used as a constraint for type parameters that accept tool registries.
+ */
+export type AnyToolRegistry = Record<string, ToolDef>;
+/**
+ * Extract the tool registry type from an McpServer instance.
+ * This includes both widgets (registered via widget()) and regular tools (registered via registerTool()).
+ *
+ * Uses the `$types` property pattern for cross-package type inference.
+ * This works across package boundaries because TypeScript uses structural typing
+ * on the shape of `$types`, rather than nominal typing on the McpServer class itself.
+ *
+ * @example
+ * ```ts
+ * type MyTools = InferTools<MyServer>;
+ * // { "search": ToolDef<...>, "calculate": ToolDef<...> }
+ * ```
+ */
+export type InferTools<ServerType> = ServerType extends {
+    $types: McpServerTypes<infer W>;
+} ? W : never;
+type ExtractTool<ServerType, K extends ToolNames<ServerType>> = InferTools<ServerType>[K];
+/**
+ * Get a union of all tool names from an McpServer instance.
+ * This includes both widgets and regular tools.
+ *
+ * @example
+ * ```ts
+ * type Names = ToolNames<MyServer>;
+ * // "search" | "calculate" | "details"
+ * ```
+ */
+export type ToolNames<ServerType> = keyof InferTools<ServerType> & string;
+/**
+ * Get the input type for a specific tool (widget or regular tool).
+ *
+ * @example
+ * ```ts
+ * type SearchInput = ToolInput<MyServer, "search">;
+ * ```
+ */
+export type ToolInput<ServerType, ToolName extends ToolNames<ServerType>> = ExtractTool<ServerType, ToolName>["input"];
+/**
+ * Get the output type for a specific tool (widget or regular tool).
+ *
+ * @example
+ * ```ts
+ * type SearchOutput = ToolOutput<MyServer, "search">;
+ * ```
+ */
+export type ToolOutput<ServerType, ToolName extends ToolNames<ServerType>> = ExtractTool<ServerType, ToolName>["output"];
+export {};

package/dist/src/server/inferUtilityTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inferUtilityTypes.js.map

package/dist/src/server/inferUtilityTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inferUtilityTypes.js","sourceRoot":"","sources":["../../../src/server/inferUtilityTypes.ts"],"names":[],"mappings":""}

package/dist/src/server/server.d.ts

@@ -0,0 +1,48 @@
+import { McpServer as McpServerBase, type RegisteredTool } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Resource, ToolAnnotations, CallToolResult, ServerRequest, ServerNotification } from "@modelcontextprotocol/sdk/types.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { ZodRawShape, ZodObject, infer as Infer } from "zod";
+export type ToolDef<TInput = unknown, TOutput = unknown> = {
+    input: TInput;
+    output: TOutput;
+};
+type McpServerOriginalResourceConfig = Omit<Resource, "uri" | "name" | "mimeType">;
+type McpServerOriginalToolConfig = Omit<Parameters<McpServerBase["registerTool"]>[1], "inputSchema" | "outputSchema">;
+type ExtractStructuredContent<T> = T extends {
+    structuredContent: infer SC;
+} ? SC : never;
+/**
+ * Type-level marker interface for cross-package type inference.
+ * This enables TypeScript to infer tool types across package boundaries
+ * using structural typing on the $types property, rather than relying on
+ * class generic inference which fails when McpServer comes from different
+ * package installations.
+ *
+ * Inspired by tRPC's _def pattern and Hono's type markers.
+ */
+export interface McpServerTypes<TTools extends Record<string, ToolDef> = {}> {
+    readonly tools: TTools;
+}
+type AddTool<TTools, TName extends string, TInput extends ZodRawShape, TOutput> = McpServer<TTools & {
+    [K in TName]: ToolDef<Infer<ZodObject<TInput>>, TOutput>;
+}>;
+type ToolConfig<TInput extends ZodRawShape> = {
+    title?: string;
+    description?: string;
+    inputSchema?: TInput;
+    outputSchema?: ZodRawShape;
+    annotations?: ToolAnnotations;
+    _meta?: Record<string, unknown>;
+};
+type ToolHandler<TInput extends ZodRawShape, TReturn extends CallToolResult = CallToolResult> = (args: Infer<ZodObject<TInput>>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => TReturn | Promise<TReturn>;
+export declare class McpServer<TTools extends Record<string, ToolDef> = {}> extends McpServerBase {
+    readonly $types: McpServerTypes<TTools>;
+    widget<TName extends string, TInput extends ZodRawShape, TReturn extends CallToolResult>(name: TName, resourceConfig: McpServerOriginalResourceConfig, toolConfig: McpServerOriginalToolConfig & {
+        inputSchema?: TInput;
+        outputSchema?: ZodRawShape;
+    }, toolCallback: ToolHandler<TInput, TReturn>): AddTool<TTools, TName, TInput, ExtractStructuredContent<TReturn>>;
+    registerTool<TName extends string, InputArgs extends ZodRawShape, TReturn extends CallToolResult>(name: TName, config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs, TReturn>): AddTool<TTools, TName, InputArgs, ExtractStructuredContent<TReturn>>;
+    registerTool<InputArgs extends ZodRawShape>(name: string, config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs>): RegisteredTool;
+    private lookupDistFile;
+}
+export {};

package/dist/src/server/server.js

@@ -0,0 +1,62 @@
+import { McpServer as McpServerBase, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { templateHelper } from "./templateHelper.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+export class McpServer extends McpServerBase {
+    widget(name, resourceConfig, toolConfig, toolCallback) {
+        const uri = `ui://widgets/${name}.html`;
+        const resourceMetadata = {
+            ...(resourceConfig._meta ?? {}),
+        };
+        if (toolConfig.description !== undefined) {
+            resourceMetadata["openai/widgetDescription"] = toolConfig.description;
+        }
+        this.resource(name, uri, {
+            ...resourceConfig,
+            _meta: resourceMetadata,
+        }, async (_uri, extra) => {
+            const serverUrl = process.env.NODE_ENV === "production"
+                ? `https://${extra?.requestInfo?.headers?.["x-forwarded-host"] ??
+                    extra?.requestInfo?.headers?.host}`
+                : `http://localhost:3000`;
+            const html = process.env.NODE_ENV === "production"
+                ? templateHelper.renderProduction({
+                    serverUrl,
+                    widgetFile: this.lookupDistFile(`src/widgets/${name}.tsx`),
+                    styleFile: this.lookupDistFile("style.css"),
+                })
+                : templateHelper.renderDevelopment({
+                    serverUrl,
+                    widgetName: name,
+                });
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "text/html+skybridge",
+                        text: html,
+                    },
+                ],
+            };
+        });
+        const toolMeta = {
+            ...toolConfig._meta,
+            "openai/outputTemplate": uri,
+            "ui/resourceUri": uri,
+        };
+        this.registerTool(name, {
+            ...toolConfig,
+            _meta: toolMeta,
+        }, toolCallback);
+        return this;
+    }
+    registerTool(name, config, cb) {
+        super.registerTool(name, config, cb);
+        return this;
+    }
+    lookupDistFile(key) {
+        const manifest = JSON.parse(readFileSync(path.join(process.cwd(), "dist", "assets", ".vite", "manifest.json"), "utf-8"));
+        return manifest[key]?.file;
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/src/server/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/server/server.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,IAAI,aAAa,GAG3B,MAAM,yCAAyC,CAAC;AAUjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,IAAI,MAAM,WAAW,CAAC;AAkG7B,MAAM,OAAO,SAEX,SAAQ,aAAa;IAGrB,MAAM,CAKJ,IAAW,EACX,cAA+C,EAC/C,UAGC,EACD,YAA0C;QAE1C,MAAM,GAAG,GAAG,gBAAgB,IAAI,OAAO,CAAC;QACxC,MAAM,gBAAgB,GAAiB;YACrC,GAAG,CAAC,cAAc,CAAC,KAAK,IAAI,EAAE,CAAC;SAChC,CAAC;QACF,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACzC,gBAAgB,CAAC,0BAA0B,CAAC,GAAG,UAAU,CAAC,WAAW,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,QAAQ,CACX,IAAI,EACJ,GAAG,EACH;YACE,GAAG,cAAc;YACjB,KAAK,EAAE,gBAAgB;SACxB,EACD,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE;YACpB,MAAM,SAAS,GACb,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;gBACnC,CAAC,CAAC,WACE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,kBAAkB,CAAC;oBACjD,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,IAC/B,EAAE;gBACJ,CAAC,CAAC,uBAAuB,CAAC;YAE9B,MAAM,IAAI,GACR,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;gBACnC,CAAC,CAAC,cAAc,CAAC,gBAAgB,CAAC;oBAC9B,SAAS;oBACT,UAAU,EAAE,IAAI,CAAC,cAAc,CAAC,eAAe,IAAI,MAAM,CAAC;oBAC1D,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC;iBAC5C,CAAC;gBACJ,CAAC,CAAC,cAAc,CAAC,iBAAiB,CAAC;oBAC/B,SAAS;oBACT,UAAU,EAAE,IAAI;iBACjB,CAAC,CAAC;YAET,OAAO;gBACL,QAAQ,EAAE;oBACR;wBACE,GAAG;wBACH,QAAQ,EAAE,qBAAqB;wBAC/B,IAAI,EAAE,IAAI;qBACX;iBACF;aACF,CAAC;QACJ,CAAC,CACF,CAAC;QAEF,MAAM,QAAQ,GAAa;YACzB,GAAG,UAAU,CAAC,KAAK;YACnB,uBAAuB,EAAE,GAAG;YAC5B,gBAAgB,EAAE,GAAG;SACtB,CAAC;QAEF,IAAI,CAAC,YAAY,CACf,IAAI,EACJ;YACE,GAAG,UAAU;YACb,KAAK,EAAE,QAAQ;SAChB,EACD,YAAY,CACb,CAAC;QAEF,OAAO,IAAyE,CAAC;IACnF,CAAC;IAkBQ,YAAY,CACnB,IAAY,EACZ,MAA6B,EAC7B,EAA2B;QAE3B,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,cAAc,CAAC,GAAW;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,YAAY,CACV,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,CAAC,EACpE,OAAO,CACR,CACF,CAAC;QAEF,OAAO,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IAC7B,CAAC;CACF"}

package/dist/src/server/templateHelper.d.ts

@@ -0,0 +1,15 @@
+declare class TemplateHelper {
+    private templateCache;
+    private loadTemplate;
+    renderProduction(data: {
+        serverUrl: string;
+        widgetFile: string;
+        styleFile: string;
+    }): string;
+    renderDevelopment(data: {
+        serverUrl: string;
+        widgetName: string;
+    }): string;
+}
+export declare const templateHelper: TemplateHelper;
+export {};

package/dist/src/server/templateHelper.js

@@ -0,0 +1,29 @@
+import Handlebars from "handlebars";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+class TemplateHelper {
+    templateCache = new Map();
+    loadTemplate(templateName) {
+        if (this.templateCache.has(templateName)) {
+            return this.templateCache.get(templateName);
+        }
+        const templatePath = join(__dirname, "templates", `${templateName}.hbs`);
+        const templateSource = readFileSync(templatePath, "utf-8");
+        const template = Handlebars.compile(templateSource);
+        this.templateCache.set(templateName, template);
+        return template;
+    }
+    renderProduction(data) {
+        const template = this.loadTemplate("production");
+        return template(data);
+    }
+    renderDevelopment(data) {
+        const template = this.loadTemplate("development");
+        return template(data);
+    }
+}
+export const templateHelper = new TemplateHelper();
+//# sourceMappingURL=templateHelper.js.map

package/dist/src/server/templateHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateHelper.js","sourceRoot":"","sources":["../../../src/server/templateHelper.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAOtC,MAAM,cAAc;IACV,aAAa,GAAG,IAAI,GAAG,EAAsC,CAAC;IAE9D,YAAY,CAAC,YAAoB;QACvC,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAE,CAAC;QAC/C,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,YAAY,MAAM,CAAC,CAAC;QACzE,MAAM,cAAc,GAAG,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAC3D,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAEpD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;QAC/C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,gBAAgB,CAAC,IAIhB;QACC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;QACjD,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,iBAAiB,CAAC,IAA+C;QAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;QAClD,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;CACF;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,cAAc,EAAE,CAAC"}

package/dist/src/server/templates/development.hbs

@@ -0,0 +1,12 @@
+<base href="{{serverUrl}}" />
+<script type="module">
+  import { injectIntoGlobalHook } from "{{serverUrl}}/@react-refresh";
+  injectIntoGlobalHook(window); window.$RefreshReg$ = () => {};
+  window.$RefreshSig$ = () => (type) => type;
+  window.__vite_plugin_react_preamble_installed__ = true;
+</script>
+<script type="module" src="{{serverUrl}}/@vite/client"></script>
+<div id="root"></div>
+<script type="module">
+  import('{{serverUrl}}/src/widgets/{{widgetName}}.tsx');
+</script>

package/dist/src/server/templates/production.hbs

@@ -0,0 +1,6 @@
+<base href="{{serverUrl}}" />
+<div id="root"></div>
+<script type="module">
+  import('{{serverUrl}}/assets/{{widgetFile}}');
+</script>
+<link rel="stylesheet" crossorigin href="{{serverUrl}}/assets/{{styleFile}}" />