@snaptrude/plugin-core 0.0.2 → 0.0.4

package/src/api/entity/story.ts

@@ -0,0 +1,96 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+export abstract class PluginStoryApi {
+  constructor() {}
+
+  public abstract get({
+    storyValue,
+    properties,
+  }: PluginStoryGetArgs): PluginApiReturn<PluginStoryGetResult>
+
+  public abstract getAll(): PluginApiReturn<PluginStoryGetAllResult>
+
+  public abstract create({
+    storyValue,
+    height,
+  }: PluginStoryCreateArgs): PluginApiReturn<PluginStoryCreateResult>
+
+  public abstract update({
+    storyValue,
+    height,
+  }: PluginStoryUpdateArgs): PluginApiReturn<PluginStoryUpdateResult>
+}
+
+export const PluginStoryGetProperty = z.enum([
+  "value",
+  "id",
+  "name",
+  "height",
+  "base",
+  "hidden",
+  "spacesCount",
+  "totalArea",
+])
+
+export const PluginStoryGetArgs = z.object({
+  storyValue: z.number().int(),
+  properties: z.array(PluginStoryGetProperty),
+})
+
+export type PluginStoryGetArgs = z.infer<typeof PluginStoryGetArgs>
+
+export const PluginStoryGetResult = z
+  .object({
+    value: z.number(),
+    id: z.string(),
+    name: z.string(),
+    height: z.number(),
+    base: z.number(),
+    hidden: z.boolean(),
+    spacesCount: z.number(),
+    totalArea: z.number(),
+  })
+  .partial()
+
+export type PluginStoryGetResult = z.infer<typeof PluginStoryGetResult>
+
+export const PluginStoryGetAllResult = z.object({
+  stories: z.array(
+    z.object({
+      value: z.number(),
+      id: z.string(),
+      name: z.string(),
+    })
+  ),
+})
+
+export type PluginStoryGetAllResult = z.infer<typeof PluginStoryGetAllResult>
+
+export const PluginStoryCreateArgs = z.object({
+  storyValue: z.number().int(),
+  height: z.number().optional(),
+})
+
+export type PluginStoryCreateArgs = z.infer<typeof PluginStoryCreateArgs>
+
+export const PluginStoryCreateResult = z.object({
+  storyId: z.string(),
+  storyValue: z.number(),
+})
+
+export type PluginStoryCreateResult = z.infer<typeof PluginStoryCreateResult>
+
+export const PluginStoryUpdateArgs = z.object({
+  storyValue: z.number().int(),
+  height: z.number(),
+})
+
+export type PluginStoryUpdateArgs = z.infer<typeof PluginStoryUpdateArgs>
+
+export const PluginStoryUpdateResult = z.object({
+  storyValue: z.number(),
+  height: z.number(),
+})
+
+export type PluginStoryUpdateResult = z.infer<typeof PluginStoryUpdateResult>

package/src/api/index.ts

@@ -1,12 +1,18 @@
+import { PluginCoreApi } from "./core"
 import { PluginEntityApi } from "./entity"
 import { PluginToolsApi } from "./tools"
+import { PluginUnitsApi } from "./units"
 
 export abstract class PluginApi {
+  public abstract core: PluginCoreApi
   public abstract tools: PluginToolsApi
   public abstract entity: PluginEntityApi
+  public abstract units: PluginUnitsApi
 
   constructor() {}
 }
 
+export * from "./core"
 export * from "./entity"
 export * from "./tools"
+export * from "./units"

package/src/api/tools/selection.ts

@@ -1,4 +1,5 @@
-import type { ComponentId, PluginApiReturn } from "../../types"
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
 
 export abstract class PluginSelectionApi {
   constructor() {}
@@ -6,6 +7,8 @@ export abstract class PluginSelectionApi {
   public abstract get(): PluginApiReturn<PluginSelectionGetResult>
 }
 
-export type PluginSelectionGetResult = {
-  selected: ComponentId[]
-}
+export const PluginSelectionGetResult = z.object({
+  selected: z.array(z.string()),
+})
+
+export type PluginSelectionGetResult = z.infer<typeof PluginSelectionGetResult>

package/src/api/tools/transform.ts

@@ -1,4 +1,6 @@
+import * as z from "zod"
 import { PluginApiReturn } from "../../types"
+import { PVec3 } from "../core/math/vec3"
 
 export abstract class PluginTransformApi {
   constructor() {}
@@ -16,14 +18,18 @@ export abstract class PluginTransformApi {
   }: PluginRotateArgs): PluginApiReturn<void>
 }
 
-export type PluginMoveArgs = {
-  componentIds: string[]
-  displacement: [number, number, number]
-}
+export const PluginMoveArgs = z.object({
+  componentIds: z.array(z.string()),
+  displacement: PVec3,
+})
 
-export type PluginRotateArgs = {
-  componentIds: string[]
-  angle: number
-  axis: [number, number, number]
-  pivot: [number, number, number]
-}
+export type PluginMoveArgs = z.infer<typeof PluginMoveArgs>
+
+export const PluginRotateArgs = z.object({
+  componentIds: z.array(z.string()),
+  angle: z.number(),
+  axis: PVec3,
+  pivot: PVec3,
+})
+
+export type PluginRotateArgs = z.infer<typeof PluginRotateArgs>

package/src/api/units/index.ts

@@ -0,0 +1,95 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+export abstract class PluginUnitsApi {
+  constructor() {}
+
+  /**
+   * Convert a value from the given unit to Snaptrude's internal (Babylon) units.
+   *
+   * Use this when you have a measurement in real-world units (e.g. meters, feet)
+   * and need to convert it to the coordinate system used by Snaptrude internally.
+   *
+   * @param args.unit - The source unit to convert from (e.g. `"meters"`, `"feet-inches"`)
+   * @param args.value - The numeric value in the source unit
+   * @returns An object containing the converted `value` in Snaptrude/Babylon units
+   *
+   * @example
+   * ```ts
+   * const result = await snaptrude.units.convertFrom({ unit: "meters", value: 5 })
+   * // result.value is 5 meters expressed in Babylon units
+   * ```
+   */
+  public abstract convertFrom(
+    args: PluginUnitsConvertFromArgs,
+  ): PluginApiReturn<PluginUnitsConvertFromResult>
+
+  /**
+   * Convert a value from Snaptrude's internal (Babylon) units to the given unit.
+   *
+   * Use this when you have a value in Snaptrude's internal coordinate system
+   * and need to express it in real-world units (e.g. meters, feet).
+   *
+   * @param args.unit - The target unit to convert to (e.g. `"meters"`, `"feet-inches"`)
+   * @param args.value - The numeric value in Snaptrude/Babylon units
+   * @returns An object containing the converted `value` in the target unit
+   *
+   * @example
+   * ```ts
+   * const result = await snaptrude.units.convertTo({ unit: "feet-inches", value: 1.2 })
+   * // result.value is 1.2 Babylon units expressed in feet
+   * ```
+   */
+  public abstract convertTo(
+    args: PluginUnitsConvertToArgs,
+  ): PluginApiReturn<PluginUnitsConvertToResult>
+}
+
+/**
+ * Supported unit types for conversion.
+ *
+ * - `meters` — Metric meters
+ * - `feet-inches` — Imperial feet (1 foot = 12 inches)
+ * - `inches` — Imperial inches
+ * - `centimeters` — Metric centimeters
+ * - `millimeters` — Metric millimeters
+ * - `kilometers` — Metric kilometers
+ * - `miles` — Imperial miles
+ */
+export const PUnitType = z.enum([
+  "meters",
+  "feet-inches",
+  "inches",
+  "centimeters",
+  "millimeters",
+  "kilometers",
+  "miles",
+])
+
+export type PUnitType = z.infer<typeof PUnitType>
+
+export const PluginUnitsConvertFromArgs = z.object({
+  unit: PUnitType,
+  value: z.number(),
+})
+
+export type PluginUnitsConvertFromArgs = z.infer<typeof PluginUnitsConvertFromArgs>
+
+export const PluginUnitsConvertFromResult = z.object({
+  value: z.number(),
+})
+
+export type PluginUnitsConvertFromResult = z.infer<typeof PluginUnitsConvertFromResult>
+
+export const PluginUnitsConvertToArgs = z.object({
+  unit: PUnitType,
+  value: z.number(),
+})
+
+export type PluginUnitsConvertToArgs = z.infer<typeof PluginUnitsConvertToArgs>
+
+export const PluginUnitsConvertToResult = z.object({
+  value: z.number(),
+})
+
+export type PluginUnitsConvertToResult = z.infer<typeof PluginUnitsConvertToResult>