@snaptrude/plugin-client 0.0.2 → 0.0.4

package/src/api/core/math/index.ts

@@ -0,0 +1,17 @@
+import { PluginMathApi } from "@snaptrude/plugin-core"
+import { ClientVec3Api } from "./vec3"
+import { ClientQuatApi } from "./quat"
+
+export class ClientMathApi extends PluginMathApi {
+  public vec3: ClientVec3Api
+  public quat: ClientQuatApi
+
+  constructor() {
+    super()
+    this.vec3 = new ClientVec3Api()
+    this.quat = new ClientQuatApi()
+  }
+}
+
+export * from "./vec3"
+export * from "./quat"

package/src/api/core/math/quat.ts

@@ -0,0 +1,7 @@
+import { PluginQuatApi } from "@snaptrude/plugin-core"
+
+export class ClientQuatApi extends PluginQuatApi {
+  constructor() {
+    super()
+  }
+}

package/src/api/core/math/vec3.ts

@@ -0,0 +1,7 @@
+import { PluginVec3Api } from "@snaptrude/plugin-core"
+
+export class ClientVec3Api extends PluginVec3Api {
+  constructor() {
+    super()
+  }
+}

package/src/api/entity/index.ts

@@ -1,13 +1,17 @@
 import { PluginEntityApi } from "@snaptrude/plugin-core"
 import { ClientSpaceApi } from "./space"
+import { ClientStoryApi } from "./story"
 
 export class ClientEntityApi extends PluginEntityApi {
   public space: ClientSpaceApi
+  public story: ClientStoryApi
 
   constructor() {
     super()
     this.space = new ClientSpaceApi()
+    this.story = new ClientStoryApi()
   }
 }
 
 export * from "./space"
+export * from "./story"

package/src/api/entity/space.ts

@@ -2,10 +2,12 @@ import {
   PluginSpaceApi,
   PluginSpaceCreateRectangularArgs,
   PluginSpaceCreateRectangularResult,
+  PluginSpaceCreateFromProfileArgs,
+  PluginSpaceCreateFromProfileResult,
   PluginSpaceDeleteByIdArgs,
   PluginSpaceDeleteByIdResult,
-  PluginSpaceGetByIdArgs,
-  PluginSpaceGetByIdResult,
+  PluginSpaceGetArgs,
+  PluginSpaceGetResult,
   PluginSpaceGetAllResult,
 } from "@snaptrude/plugin-core"
 import { getHostApi } from "../../host-api"
@@ -29,13 +31,29 @@ export class ClientSpaceApi extends PluginSpaceApi {
     })
   }
 
-  public async getById({
+  public async createFromProfile({
+    profile,
+    extrudeHeight,
+    position,
+  }: PluginSpaceCreateFromProfileArgs): Promise<PluginSpaceCreateFromProfileResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "entity.space.createFromProfile",
+      args: {
+        profile,
+        extrudeHeight,
+        position,
+      },
+    })
+  }
+
+  public async get({
     spaceId,
     properties,
-  }: PluginSpaceGetByIdArgs): Promise<PluginSpaceGetByIdResult> {
+  }: PluginSpaceGetArgs): Promise<PluginSpaceGetResult> {
     const hostApi = getHostApi()
     return hostApi.call({
-      method: "entity.space.getById",
+      method: "entity.space.get",
       args: {
         spaceId,
         properties,

package/src/api/entity/story.ts

@@ -0,0 +1,66 @@
+import {
+  PluginStoryApi,
+  PluginStoryGetArgs,
+  PluginStoryGetResult,
+  PluginStoryGetAllResult,
+  PluginStoryCreateArgs,
+  PluginStoryCreateResult,
+  PluginStoryUpdateArgs,
+  PluginStoryUpdateResult,
+} from "@snaptrude/plugin-core"
+import { getHostApi } from "../../host-api"
+
+export class ClientStoryApi extends PluginStoryApi {
+  constructor() {
+    super()
+  }
+
+  public async get({
+    storyValue,
+    properties,
+  }: PluginStoryGetArgs): Promise<PluginStoryGetResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "entity.story.get",
+      args: {
+        storyValue,
+        properties,
+      },
+    })
+  }
+
+  public async getAll(): Promise<PluginStoryGetAllResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "entity.story.getAll",
+    })
+  }
+
+  public async create({
+    storyValue,
+    height,
+  }: PluginStoryCreateArgs): Promise<PluginStoryCreateResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "entity.story.create",
+      args: {
+        storyValue,
+        height,
+      },
+    })
+  }
+
+  public async update({
+    storyValue,
+    height,
+  }: PluginStoryUpdateArgs): Promise<PluginStoryUpdateResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "entity.story.update",
+      args: {
+        storyValue,
+        height,
+      },
+    })
+  }
+}

package/src/api/index.ts

@@ -1,17 +1,23 @@
+import { ClientCoreApi } from "./core"
 import { ClientEntityApi } from "./entity"
 import { ClientToolsApi } from "./tools"
+import { ClientUnitsApi } from "./units"
 import { PluginApi } from "@snaptrude/plugin-core"
 
 export class ClientPluginApi extends PluginApi {
   private static instance: ClientPluginApi
 
+  public core: ClientCoreApi
   public tools: ClientToolsApi
   public entity: ClientEntityApi
+  public units: ClientUnitsApi
 
   private constructor() {
     super()
+    this.core = new ClientCoreApi()
     this.tools = new ClientToolsApi()
     this.entity = new ClientEntityApi()
+    this.units = new ClientUnitsApi()
   }
 
   static getInstance(): ClientPluginApi {
@@ -22,5 +28,7 @@ export class ClientPluginApi extends PluginApi {
   }
 }
 
+export * from "./core"
 export * from "./entity"
 export * from "./tools"
+export * from "./units"

package/src/api/units/index.ts

@@ -0,0 +1,34 @@
+import {
+  PluginUnitsApi,
+  PluginUnitsConvertFromArgs,
+  PluginUnitsConvertFromResult,
+  PluginUnitsConvertToArgs,
+  PluginUnitsConvertToResult,
+} from "@snaptrude/plugin-core"
+import { getHostApi } from "../../host-api"
+
+export class ClientUnitsApi extends PluginUnitsApi {
+  constructor() {
+    super()
+  }
+
+  public async convertFrom(
+    args: PluginUnitsConvertFromArgs,
+  ): Promise<PluginUnitsConvertFromResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "units.convertFrom",
+      args,
+    })
+  }
+
+  public async convertTo(
+    args: PluginUnitsConvertToArgs,
+  ): Promise<PluginUnitsConvertToResult> {
+    const hostApi = getHostApi()
+    return hostApi.call({
+      method: "units.convertTo",
+      args,
+    })
+  }
+}

package/src/index.ts

@@ -2,6 +2,7 @@ import { ClientPluginApi } from "./api"
 
 export * from "./api"
 export * from "./host-api"
+export * from "./plugin-worker"
 
 /**
  * The Snaptrude plugin client API.

package/src/plugin-worker.ts

@@ -0,0 +1,91 @@
+import * as Comlink from "comlink"
+
+export interface UIMessage {
+  action: string
+  payload: unknown
+}
+
+interface PluginConfig {
+  pluginId: string
+  permissions: string[]
+}
+
+/**
+ * Base class for Snaptrude plugin workers.
+ *
+ * Handles Comlink wiring, host communication, and the standard lifecycle
+ * methods (`init`, `destroy`, `ping`, `onUIMessage`). Subclass this and
+ * override only the methods you need — then call `start()` to expose the
+ * worker API.
+ *
+ * The plugin ID is received automatically from the host during
+ * initialization — no need to pass it manually.
+ *
+ * @example
+ * ```ts
+ * import { PluginWorker } from "@snaptrude/plugin-client";
+ *
+ * class MyPlugin extends PluginWorker {
+ *   async onUIMessage(message: UIMessage) {
+ *     // handle messages from the UI panel
+ *   }
+ * }
+ *
+ * new MyPlugin().start();
+ * ```
+ */
+export abstract class PluginWorker {
+  protected pluginId!: string
+  private hostAPI: Comlink.Remote<Record<string, unknown>>
+
+  constructor() {
+    this.hostAPI = Comlink.wrap<Record<string, unknown>>(
+      self as unknown as Comlink.Endpoint
+    )
+  }
+
+  protected sendToUI(action: string, payload: unknown): void {
+    ;(this.hostAPI as Record<string, any>).ui.sendToUI({ action, payload })
+  }
+
+  async init(): Promise<void> {
+    console.log(this.pluginId, "init() called")
+    console.log(this.pluginId, "Initialization complete")
+  }
+
+  async destroy(): Promise<void> {
+    console.log(this.pluginId, "destroy() called — cleaning up")
+  }
+
+  async ping(): Promise<string> {
+    return "pong"
+  }
+
+  async onUIMessage(_message: UIMessage): Promise<void> {
+    // Override in subclass to handle UI messages
+  }
+
+  /**
+   * Expose the worker API via Comlink and start listening.
+   * Call this once after constructing the plugin instance.
+   *
+   * The host calls `init(config)` with `{ pluginId, permissions }`,
+   * which is captured here to set `this.pluginId` before the
+   * subclass's `init()` runs.
+   */
+  start(): void {
+    Comlink.expose(
+      {
+        init: (config: PluginConfig) => {
+          this.pluginId = config.pluginId
+          return this.init()
+        },
+        destroy: () => this.destroy(),
+        ping: () => this.ping(),
+        onUIMessage: (message: UIMessage) => this.onUIMessage(message),
+      },
+      self as unknown as Comlink.Endpoint
+    )
+    console.log("Worker loaded, API exposed via Comlink")
+  }
+}

package/tsconfig.json

@@ -3,7 +3,7 @@
     "target": "ES2020",
     "module": "ES2020",
     "moduleResolution": "bundler",
-    "lib": ["ES2020"],
+    "lib": ["ES2020", "WebWorker"],
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,