@workbench-kit/adapters 0.0.1-prototype.0 → 0.0.2-prototype.0.1.1

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@workbench-kit/adapters",
-  "version": "0.0.1-prototype.0",
+  "version": "0.0.2-prototype.0.1.1",
   "private": false,
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
     "./library": "./src/library.ts",
     "./runtime": "./src/runtime.ts",
-    "./workspace": "./src/workspace.ts"
+    "./workspace": "./src/workspace.ts",
+    "./workbench-demo": "./src/workbench-demo.ts",
+    "./workbench-demo-config": "./src/workbench-demo-config.ts",
+    "./persistence": "./src/persistence.ts"
   },
   "files": [
     "src",
@@ -17,9 +20,9 @@
     "!src/**/*.stories.tsx"
   ],
   "dependencies": {
-    "@workbench-kit/contracts": "0.0.1-prototype.0",
-    "@workbench-kit/runtime": "0.0.1-prototype.0",
-    "@workbench-kit/workspace": "0.0.1-prototype.0"
+    "@workbench-kit/contracts": "0.0.2-prototype.0.1.1",
+    "@workbench-kit/runtime": "0.0.2-prototype.0.1.1",
+    "@workbench-kit/workspace": "0.0.2-prototype.0.1.1"
   },
   "description": "Workbench Kit adapters for workspace repositories and runtime transports.",
   "publishConfig": {
@@ -29,7 +32,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/NewChoBo/newchobo-ui-package.git",
+    "url": "git+https://github.com/NewChoBo/workbench-kit.git",
     "directory": "packages/adapters"
   },
   "scripts": {

package/src/index.ts

@@ -1,3 +1,8 @@
-export * from './runtime';
-export * from './library';
-export * from './workspace';
+export * from './runtime';
+export * from './library';
+export * from './workspace';
+export * from './workbench-demo';
+export * from './widget-studio-assets';
+export * from './widget-studio-asset-package';
+export * from './workbench-demo-config';
+export * from './persistence';

package/src/library.ts

@@ -1,145 +1,145 @@
-import type { LibraryManifest, LibraryProvider } from '@workbench-kit/contracts';
-import {
-  normalizeLibraryItemProviderSource,
-  parseLibraryManifest,
-  parseLibraryManifestText,
-} from '@workbench-kit/contracts';
-
-type ManifestTextLoader = () => Promise<string> | string;
-
-export interface LibraryManifestProviderOptions {
-  displayName: string;
-  id: string;
-  loadManifestText: ManifestTextLoader;
-}
-
-export interface StaticLibraryManifestProviderOptions {
-  displayName: string;
-  id: string;
-  manifestText: string;
-}
-
-export interface ObjectLibraryManifestProviderOptions {
-  displayName: string;
-  id: string;
-  manifest: unknown;
-}
-
-export interface HttpLibraryManifestProviderOptions {
-  displayName: string;
-  id: string;
-  manifestUrl: string;
-  readText?: (url: string) => Promise<string>;
-}
-
-export function createLibraryManifestProvider({
-  displayName,
-  id,
-  loadManifestText,
-}: LibraryManifestProviderOptions): LibraryProvider {
-  return {
-    displayName,
-    id,
-    async listItems() {
-      const manifest = parseLibraryManifestSourceText(id, await loadManifestText());
-      return manifest.items.map((item) =>
-        normalizeLibraryItemProviderSource(item, {
-          providerId: id,
-        }),
-      );
-    },
-  };
-}
-
-export function createStaticLibraryManifestProvider({
-  displayName,
-  id,
-  manifestText,
-}: StaticLibraryManifestProviderOptions): LibraryProvider {
-  return createLibraryManifestProvider({
-    displayName,
-    id,
-    loadManifestText: () => manifestText,
-  });
-}
-
-export function createLibraryManifestObjectProvider({
-  displayName,
-  id,
-  manifest,
-}: ObjectLibraryManifestProviderOptions): LibraryProvider {
-  return {
-    displayName,
-    id,
-    async listItems() {
-      const parsedManifest = parseLibraryManifestSourceData(id, manifest);
-      return parsedManifest.items.map((item) =>
-        normalizeLibraryItemProviderSource(item, {
-          providerId: id,
-        }),
-      );
-    },
-  };
-}
-
-export function createLibraryManifestUrlProvider({
-  displayName,
-  id,
-  manifestUrl,
-  readText,
-}: HttpLibraryManifestProviderOptions): LibraryProvider {
-  return createLibraryManifestProvider({
-    displayName,
-    id,
-    loadManifestText: async () => {
-      const loader = readText ?? defaultReadText;
-      return loader(manifestUrl);
-    },
-  });
-}
-
-function parseLibraryManifestSourceText(
-  providerId: string,
-  rawManifestText: string,
-): LibraryManifest {
-  const manifest = parseLibraryManifestText(rawManifestText, `library-manifest:${providerId}`);
-
-  return normalizeManifestSourceId(manifest, providerId);
-}
-
-function parseLibraryManifestSourceData(
-  providerId: string,
-  rawManifestData: unknown,
-): LibraryManifest {
-  const manifest = parseLibraryManifest(rawManifestData, `library-manifest:${providerId}`);
-
-  return normalizeManifestSourceId(manifest, providerId);
-}
-
-function normalizeManifestSourceId(manifest: LibraryManifest, providerId: string): LibraryManifest {
-  if (manifest.source.sourceId) {
-    return manifest;
-  }
-
-  return {
-    ...manifest,
-    source: {
-      ...manifest.source,
-      sourceId: providerId,
-    },
-  };
-}
-
-async function defaultReadText(url: string): Promise<string> {
-  if (typeof globalThis.fetch !== 'function') {
-    throw new Error('fetch is not available in this environment');
-  }
-
-  const response = await globalThis.fetch(url);
-  if (!response.ok) {
-    const statusText = response.statusText ? ` ${response.statusText}` : '';
-    throw new Error(`Failed to load library manifest from ${url}: ${response.status}${statusText}`);
-  }
-
-  return response.text();
-}
+import type { LibraryManifest, LibraryProvider } from '@workbench-kit/contracts';
+import {
+  normalizeLibraryItemProviderSource,
+  parseLibraryManifest,
+  parseLibraryManifestText,
+} from '@workbench-kit/contracts';
+
+type ManifestTextLoader = () => Promise<string> | string;
+
+export interface LibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  loadManifestText: ManifestTextLoader;
+}
+
+export interface StaticLibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  manifestText: string;
+}
+
+export interface ObjectLibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  manifest: unknown;
+}
+
+export interface HttpLibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  manifestUrl: string;
+  readText?: (url: string) => Promise<string>;
+}
+
+export function createLibraryManifestProvider({
+  displayName,
+  id,
+  loadManifestText,
+}: LibraryManifestProviderOptions): LibraryProvider {
+  return {
+    displayName,
+    id,
+    async listItems() {
+      const manifest = parseLibraryManifestSourceText(id, await loadManifestText());
+      return manifest.items.map((item) =>
+        normalizeLibraryItemProviderSource(item, {
+          providerId: id,
+        }),
+      );
+    },
+  };
+}
+
+export function createStaticLibraryManifestProvider({
+  displayName,
+  id,
+  manifestText,
+}: StaticLibraryManifestProviderOptions): LibraryProvider {
+  return createLibraryManifestProvider({
+    displayName,
+    id,
+    loadManifestText: () => manifestText,
+  });
+}
+
+export function createLibraryManifestObjectProvider({
+  displayName,
+  id,
+  manifest,
+}: ObjectLibraryManifestProviderOptions): LibraryProvider {
+  return {
+    displayName,
+    id,
+    async listItems() {
+      const parsedManifest = parseLibraryManifestSourceData(id, manifest);
+      return parsedManifest.items.map((item) =>
+        normalizeLibraryItemProviderSource(item, {
+          providerId: id,
+        }),
+      );
+    },
+  };
+}
+
+export function createLibraryManifestUrlProvider({
+  displayName,
+  id,
+  manifestUrl,
+  readText,
+}: HttpLibraryManifestProviderOptions): LibraryProvider {
+  return createLibraryManifestProvider({
+    displayName,
+    id,
+    loadManifestText: async () => {
+      const loader = readText ?? defaultReadText;
+      return loader(manifestUrl);
+    },
+  });
+}
+
+function parseLibraryManifestSourceText(
+  providerId: string,
+  rawManifestText: string,
+): LibraryManifest {
+  const manifest = parseLibraryManifestText(rawManifestText, `library-manifest:${providerId}`);
+
+  return normalizeManifestSourceId(manifest, providerId);
+}
+
+function parseLibraryManifestSourceData(
+  providerId: string,
+  rawManifestData: unknown,
+): LibraryManifest {
+  const manifest = parseLibraryManifest(rawManifestData, `library-manifest:${providerId}`);
+
+  return normalizeManifestSourceId(manifest, providerId);
+}
+
+function normalizeManifestSourceId(manifest: LibraryManifest, providerId: string): LibraryManifest {
+  if (manifest.source.sourceId) {
+    return manifest;
+  }
+
+  return {
+    ...manifest,
+    source: {
+      ...manifest.source,
+      sourceId: providerId,
+    },
+  };
+}
+
+async function defaultReadText(url: string): Promise<string> {
+  if (typeof globalThis.fetch !== 'function') {
+    throw new Error('fetch is not available in this environment');
+  }
+
+  const response = await globalThis.fetch(url);
+  if (!response.ok) {
+    const statusText = response.statusText ? ` ${response.statusText}` : '';
+    throw new Error(`Failed to load library manifest from ${url}: ${response.status}${statusText}`);
+  }
+
+  return response.text();
+}

package/src/persistence.ts

@@ -0,0 +1,26 @@
+/**
+ * Optional persistence boundary for host apps that store workbench UI state
+ * outside the in-memory adapters used by Storybook fixtures.
+ */
+export interface WorkbenchPersistenceAdapter {
+  loadState<T>(key: string): Promise<T | null>;
+  removeState(key: string): Promise<void>;
+  saveState<T>(key: string, value: T): Promise<void>;
+}
+
+export class InMemoryWorkbenchPersistenceAdapter implements WorkbenchPersistenceAdapter {
+  private readonly store = new Map<string, unknown>();
+
+  async loadState<T>(key: string): Promise<T | null> {
+    if (!this.store.has(key)) return null;
+    return structuredClone(this.store.get(key)) as T;
+  }
+
+  async removeState(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+
+  async saveState<T>(key: string, value: T): Promise<void> {
+    this.store.set(key, structuredClone(value));
+  }
+}

package/src/runtime.ts

@@ -1,97 +1,97 @@
-import type { ChatStreamEvent, ChatTransport } from '@workbench-kit/contracts';
-import type { WorkbenchRuntimeEvent, MockWorkbenchRuntime } from '@workbench-kit/runtime';
-
-export interface RuntimeChatTransportOptions {
-  runtime: MockWorkbenchRuntime;
-}
-
-export function createChatTransportFromRuntime({
-  runtime,
-}: RuntimeChatTransportOptions): ChatTransport {
-  return {
-    cancel: () => runtime.cancel(),
-    sendMessage: async (message, options) => {
-      void options;
-      const next = runtime.sendMessage(message);
-      if (!next) return undefined;
-
-      return {
-        content: next.content,
-        createdAt: next.createdAt,
-        id: next.id,
-        label: next.label,
-        source: next.source,
-      };
-    },
-    subscribe: (listener: (event: ChatStreamEvent) => void) =>
-      runtime.subscribe((event: WorkbenchRuntimeEvent) => {
-        if (event.type === 'message') {
-          listener({
-            message: {
-              content: event.message.content,
-              createdAt: event.message.createdAt,
-              id: event.message.id,
-              label: event.message.label,
-              source: event.message.source,
-            },
-            type: 'message',
-          });
-          return;
-        }
-
-        if (event.type === 'message-delta') {
-          listener({
-            delta: event.delta,
-            message: {
-              content: event.message.content,
-              createdAt: event.message.createdAt,
-              id: event.message.id,
-              label: event.message.label,
-              source: event.message.source,
-            },
-            type: 'message-delta',
-          });
-          return;
-        }
-
-        if (event.type === 'status') {
-          listener({
-            previousStatus: event.previousStatus,
-            status: event.status,
-            type: 'status',
-          });
-          return;
-        }
-
-        if (event.patch.type === 'delete-file') {
-          listener({
-            patch: { path: event.patch.path, type: 'delete-file' },
-            type: 'workspace-patch',
-          });
-          return;
-        }
-
-        listener({
-          patch: {
-            content: event.patch.content,
-            mimeType: event.patch.mimeType,
-            path: event.patch.path,
-            source: event.patch.source,
-            type: 'write-file',
-            updatedAt: event.patch.updatedAt,
-          },
-          type: 'workspace-patch',
-        });
-      }),
-  };
-}
-
-export function emitRuntimeWorkspacePatch({
-  runtime,
-  patch,
-}: {
-  runtime: Pick<MockWorkbenchRuntime, 'emitWorkspacePatch'>;
-  patch: Parameters<MockWorkbenchRuntime['emitWorkspacePatch']>[0];
-}) {
-  runtime.emitWorkspacePatch(patch);
-}
+import type { ChatStreamEvent, ChatTransport } from '@workbench-kit/contracts';
+import type { WorkbenchRuntimeEvent, MockWorkbenchRuntime } from '@workbench-kit/runtime';
+
+export interface RuntimeChatTransportOptions {
+  runtime: MockWorkbenchRuntime;
+}
+
+export function createChatTransportFromRuntime({
+  runtime,
+}: RuntimeChatTransportOptions): ChatTransport {
+  return {
+    cancel: () => runtime.cancel(),
+    sendMessage: async (message, options) => {
+      void options;
+      const next = runtime.sendMessage(message);
+      if (!next) return undefined;
+
+      return {
+        content: next.content,
+        createdAt: next.createdAt,
+        id: next.id,
+        label: next.label,
+        source: next.source,
+      };
+    },
+    subscribe: (listener: (event: ChatStreamEvent) => void) =>
+      runtime.subscribe((event: WorkbenchRuntimeEvent) => {
+        if (event.type === 'message') {
+          listener({
+            message: {
+              content: event.message.content,
+              createdAt: event.message.createdAt,
+              id: event.message.id,
+              label: event.message.label,
+              source: event.message.source,
+            },
+            type: 'message',
+          });
+          return;
+        }
+
+        if (event.type === 'message-delta') {
+          listener({
+            delta: event.delta,
+            message: {
+              content: event.message.content,
+              createdAt: event.message.createdAt,
+              id: event.message.id,
+              label: event.message.label,
+              source: event.message.source,
+            },
+            type: 'message-delta',
+          });
+          return;
+        }
+
+        if (event.type === 'status') {
+          listener({
+            previousStatus: event.previousStatus,
+            status: event.status,
+            type: 'status',
+          });
+          return;
+        }
+
+        if (event.patch.type === 'delete-file') {
+          listener({
+            patch: { path: event.patch.path, type: 'delete-file' },
+            type: 'workspace-patch',
+          });
+          return;
+        }
+
+        listener({
+          patch: {
+            content: event.patch.content,
+            mimeType: event.patch.mimeType,
+            path: event.patch.path,
+            source: event.patch.source,
+            type: 'write-file',
+            updatedAt: event.patch.updatedAt,
+          },
+          type: 'workspace-patch',
+        });
+      }),
+  };
+}
+
+export function emitRuntimeWorkspacePatch({
+  runtime,
+  patch,
+}: {
+  runtime: Pick<MockWorkbenchRuntime, 'emitWorkspacePatch'>;
+  patch: Parameters<MockWorkbenchRuntime['emitWorkspacePatch']>[0];
+}) {
+  runtime.emitWorkspacePatch(patch);
+}

package/src/widget-studio-asset-package.ts

@@ -0,0 +1,65 @@
+import type { WorkspaceFile } from '@workbench-kit/workspace';
+
+export const WIDGET_STUDIO_ASSETS_DIR = 'src/widgets/assets';
+export const WIDGET_STUDIO_CUSTOM_ASSETS_DIR = 'src/widgets/assets/custom';
+
+const MANIFEST_MIME = 'application/vnd.workbench-kit.widget-asset-manifest+json';
+const CONTENT_MIME = 'application/vnd.workbench-kit.widget-asset-content+json';
+const SCHEMA_MIME = 'application/vnd.workbench-kit.widget-asset-schema+json';
+
+export interface WidgetStudioAssetPackageDefinition {
+  readonly slug: string;
+  readonly baseDir?: string | undefined;
+  readonly updatedAt: string;
+  readonly manifest: Record<string, unknown>;
+  readonly content: Record<string, unknown>;
+  readonly schema?: Record<string, unknown> | undefined;
+}
+
+function json(value: unknown): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+export function createWidgetStudioAssetPackageFiles(
+  definition: WidgetStudioAssetPackageDefinition,
+): WorkspaceFile[] {
+  const baseDir = definition.baseDir ?? WIDGET_STUDIO_ASSETS_DIR;
+  const root = `${baseDir}/${definition.slug}`;
+  const files: WorkspaceFile[] = [
+    {
+      path: `${root}/manifest.json`,
+      mimeType: MANIFEST_MIME,
+      updatedAt: definition.updatedAt,
+      source: 'user',
+      content: json({
+        $schema: 'https://workbench-kit.dev/schemas/widget-asset-manifest.v1.jdw.schema.json',
+        ...definition.manifest,
+      }),
+    },
+    {
+      path: `${root}/content.json`,
+      mimeType: CONTENT_MIME,
+      updatedAt: definition.updatedAt,
+      source: 'user',
+      content: json(definition.content),
+    },
+  ];
+
+  if (definition.schema) {
+    files.push({
+      path: `${root}/schema.json`,
+      mimeType: SCHEMA_MIME,
+      updatedAt: definition.updatedAt,
+      source: 'user',
+      content: json(definition.schema),
+    });
+  }
+
+  return files;
+}
+
+export function flattenWidgetStudioAssetPackages(
+  packages: readonly WidgetStudioAssetPackageDefinition[],
+): WorkspaceFile[] {
+  return packages.flatMap((definition) => createWidgetStudioAssetPackageFiles(definition));
+}