@snaptrude/plugin-core 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,25 +17,480 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  PArc: () => PArc,
+  PCurve: () => PCurve,
+  PLine: () => PLine,
+  PProfile: () => PProfile,
+  PQuat: () => PQuat,
+  PUnitType: () => PUnitType,
+  PVec3: () => PVec3,
   PluginApi: () => PluginApi,
+  PluginArcApi: () => PluginArcApi,
+  PluginCoreApi: () => PluginCoreApi,
+  PluginCurveApi: () => PluginCurveApi,
   PluginEntityApi: () => PluginEntityApi,
+  PluginGeomApi: () => PluginGeomApi,
+  PluginLineApi: () => PluginLineApi,
+  PluginMathApi: () => PluginMathApi,
+  PluginMoveArgs: () => PluginMoveArgs,
+  PluginProfileApi: () => PluginProfileApi,
+  PluginProfileFromLinePointsArgs: () => PluginProfileFromLinePointsArgs,
+  PluginQuatApi: () => PluginQuatApi,
+  PluginRotateArgs: () => PluginRotateArgs,
   PluginSelectionApi: () => PluginSelectionApi,
+  PluginSelectionGetResult: () => PluginSelectionGetResult,
   PluginSpaceApi: () => PluginSpaceApi,
+  PluginSpaceCreateFromProfileArgs: () => PluginSpaceCreateFromProfileArgs,
+  PluginSpaceCreateFromProfileResult: () => PluginSpaceCreateFromProfileResult,
+  PluginSpaceCreateRectangularArgs: () => PluginSpaceCreateRectangularArgs,
+  PluginSpaceCreateRectangularResult: () => PluginSpaceCreateRectangularResult,
+  PluginSpaceDeleteByIdArgs: () => PluginSpaceDeleteByIdArgs,
+  PluginSpaceGetAllResult: () => PluginSpaceGetAllResult,
+  PluginSpaceGetArgs: () => PluginSpaceGetArgs,
+  PluginSpaceGetProperty: () => PluginSpaceGetProperty,
+  PluginSpaceGetResult: () => PluginSpaceGetResult,
+  PluginStoryApi: () => PluginStoryApi,
+  PluginStoryCreateArgs: () => PluginStoryCreateArgs,
+  PluginStoryCreateResult: () => PluginStoryCreateResult,
+  PluginStoryGetAllResult: () => PluginStoryGetAllResult,
+  PluginStoryGetArgs: () => PluginStoryGetArgs,
+  PluginStoryGetProperty: () => PluginStoryGetProperty,
+  PluginStoryGetResult: () => PluginStoryGetResult,
+  PluginStoryUpdateArgs: () => PluginStoryUpdateArgs,
+  PluginStoryUpdateResult: () => PluginStoryUpdateResult,
   PluginToolsApi: () => PluginToolsApi,
-  PluginTransformApi: () => PluginTransformApi
+  PluginTransformApi: () => PluginTransformApi,
+  PluginUnitsApi: () => PluginUnitsApi,
+  PluginUnitsConvertFromArgs: () => PluginUnitsConvertFromArgs,
+  PluginUnitsConvertFromResult: () => PluginUnitsConvertFromResult,
+  PluginUnitsConvertToArgs: () => PluginUnitsConvertToArgs,
+  PluginUnitsConvertToResult: () => PluginUnitsConvertToResult,
+  PluginVec3Api: () => PluginVec3Api
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/api/core/math/vec3.ts
+var z = __toESM(require("zod"), 1);
+var PluginVec3Api = class {
+  constructor() {
+  }
+  /** Create a new PVec3. */
+  new(x, y, z12) {
+    return { x, y, z: z12 };
+  }
+  /** Add two vectors. */
+  add(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+  }
+  /** Subtract b from a. */
+  subtract(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+  }
+  /** Scale a vector by a scalar. */
+  scale(v, scalar) {
+    return { x: v.x * scalar, y: v.y * scalar, z: v.z * scalar };
+  }
+  /** Dot product of two vectors. */
+  dot(a, b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+  }
+  /** Cross product of two vectors. */
+  cross(a, b) {
+    return {
+      x: a.y * b.z - a.z * b.y,
+      y: a.z * b.x - a.x * b.z,
+      z: a.x * b.y - a.y * b.x
+    };
+  }
+  /** Length (magnitude) of a vector. */
+  length(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+  }
+  /** Squared length of a vector (avoids sqrt). */
+  lengthSquared(v) {
+    return v.x * v.x + v.y * v.y + v.z * v.z;
+  }
+  /** Normalize a vector to unit length. Returns zero vector if length is 0. */
+  normalize(v) {
+    const len = this.length(v);
+    if (len === 0) return { x: 0, y: 0, z: 0 };
+    return { x: v.x / len, y: v.y / len, z: v.z / len };
+  }
+  /** Distance between two points. */
+  distance(a, b) {
+    return this.length(this.subtract(a, b));
+  }
+  /** Linearly interpolate between two vectors. */
+  lerp(a, b, t) {
+    return {
+      x: a.x + (b.x - a.x) * t,
+      y: a.y + (b.y - a.y) * t,
+      z: a.z + (b.z - a.z) * t
+    };
+  }
+  /** Negate a vector. */
+  negate(v) {
+    return { x: -v.x, y: -v.y, z: -v.z };
+  }
+  /** Check if two vectors are equal (exact). */
+  equals(a, b) {
+    return a.x === b.x && a.y === b.y && a.z === b.z;
+  }
+  /** Check if two vectors are approximately equal within an epsilon. */
+  equalsApprox(a, b, epsilon = 1e-6) {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon;
+  }
+};
+var PVec3 = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number()
+});
+
+// src/api/core/math/quat.ts
+var z2 = __toESM(require("zod"), 1);
+var PluginQuatApi = class {
+  constructor() {
+  }
+  /** Create a new PQuat. */
+  new(x, y, z12, w) {
+    return { x, y, z: z12, w };
+  }
+  /** Create an identity quaternion (no rotation). */
+  identity() {
+    return { x: 0, y: 0, z: 0, w: 1 };
+  }
+  /** Create a quaternion from an axis and angle (radians). */
+  fromAxisAngle(axis, angle) {
+    const halfAngle = angle / 2;
+    const s = Math.sin(halfAngle);
+    const len = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+    if (len === 0) return { x: 0, y: 0, z: 0, w: 1 };
+    return {
+      x: axis.x / len * s,
+      y: axis.y / len * s,
+      z: axis.z / len * s,
+      w: Math.cos(halfAngle)
+    };
+  }
+  /** Create a quaternion from Euler angles (radians, XYZ order). */
+  fromEuler(x, y, z12) {
+    const cx = Math.cos(x / 2);
+    const sx = Math.sin(x / 2);
+    const cy = Math.cos(y / 2);
+    const sy = Math.sin(y / 2);
+    const cz = Math.cos(z12 / 2);
+    const sz = Math.sin(z12 / 2);
+    return {
+      x: sx * cy * cz + cx * sy * sz,
+      y: cx * sy * cz - sx * cy * sz,
+      z: cx * cy * sz + sx * sy * cz,
+      w: cx * cy * cz - sx * sy * sz
+    };
+  }
+  /** Multiply two quaternions (a * b). */
+  multiply(a, b) {
+    return {
+      x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+      y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+      z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+      w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+    };
+  }
+  /** Conjugate of a quaternion. */
+  conjugate(q) {
+    return { x: -q.x, y: -q.y, z: -q.z, w: q.w };
+  }
+  /** Length (magnitude) of a quaternion. */
+  length(q) {
+    return Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+  }
+  /** Normalize a quaternion to unit length. Returns identity if length is 0. */
+  normalize(q) {
+    const len = this.length(q);
+    if (len === 0) return { x: 0, y: 0, z: 0, w: 1 };
+    return { x: q.x / len, y: q.y / len, z: q.z / len, w: q.w / len };
+  }
+  /** Inverse of a quaternion (conjugate / lengthSquared). */
+  inverse(q) {
+    const lenSq = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+    if (lenSq === 0) return { x: 0, y: 0, z: 0, w: 1 };
+    return { x: -q.x / lenSq, y: -q.y / lenSq, z: -q.z / lenSq, w: q.w / lenSq };
+  }
+  /** Rotate a vector by a quaternion. */
+  rotateVec3(q, v) {
+    const vq = { x: v.x, y: v.y, z: v.z, w: 0 };
+    const conj = this.conjugate(q);
+    const result = this.multiply(this.multiply(q, vq), conj);
+    return { x: result.x, y: result.y, z: result.z };
+  }
+  /** Convert a quaternion to axis-angle representation. */
+  toAxisAngle(q) {
+    const nq = this.normalize(q);
+    const angle = 2 * Math.acos(Math.min(1, Math.max(-1, nq.w)));
+    const s = Math.sin(angle / 2);
+    if (s < 1e-6) {
+      return { axis: { x: 1, y: 0, z: 0 }, angle: 0 };
+    }
+    return {
+      axis: { x: nq.x / s, y: nq.y / s, z: nq.z / s },
+      angle
+    };
+  }
+  /** Spherical linear interpolation between two quaternions. */
+  slerp(a, b, t) {
+    let cosHalf = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    let bx = b.x, by = b.y, bz = b.z, bw = b.w;
+    if (cosHalf < 0) {
+      cosHalf = -cosHalf;
+      bx = -bx;
+      by = -by;
+      bz = -bz;
+      bw = -bw;
+    }
+    if (cosHalf >= 1) {
+      return { x: a.x, y: a.y, z: a.z, w: a.w };
+    }
+    const halfAngle = Math.acos(cosHalf);
+    const sinHalf = Math.sin(halfAngle);
+    const ratioA = Math.sin((1 - t) * halfAngle) / sinHalf;
+    const ratioB = Math.sin(t * halfAngle) / sinHalf;
+    return {
+      x: a.x * ratioA + bx * ratioB,
+      y: a.y * ratioA + by * ratioB,
+      z: a.z * ratioA + bz * ratioB,
+      w: a.w * ratioA + bw * ratioB
+    };
+  }
+  /** Dot product of two quaternions. */
+  dot(a, b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+  }
+  /** Check if two quaternions are equal (exact). */
+  equals(a, b) {
+    return a.x === b.x && a.y === b.y && a.z === b.z && a.w === b.w;
+  }
+  /** Check if two quaternions are approximately equal within an epsilon. */
+  equalsApprox(a, b, epsilon = 1e-6) {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon && Math.abs(a.w - b.w) < epsilon;
+  }
+};
+var PQuat = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  z: z2.number(),
+  w: z2.number()
+});
+
+// src/api/core/math/index.ts
+var PluginMathApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/geom/line.ts
+var z3 = __toESM(require("zod"), 1);
+var PluginLineApi = class {
+  constructor() {
+  }
+  /** Create a new PLine from start and end points. */
+  new(startPoint, endPoint) {
+    return { curveType: "Line", startPoint, endPoint };
+  }
+};
+var PLine = z3.object({
+  curveType: z3.literal("Line"),
+  startPoint: PVec3,
+  endPoint: PVec3
+});
+
+// src/api/core/geom/arc.ts
+var z4 = __toESM(require("zod"), 1);
+var PluginArcApi = class {
+  constructor() {
+  }
+  /** Create a new PArc from start, end, centre and axis. */
+  new(startPoint, endPoint, centrePoint, axis) {
+    return { curveType: "Arc", startPoint, endPoint, centrePoint, axis };
+  }
+};
+var PArc = z4.object({
+  curveType: z4.literal("Arc"),
+  startPoint: PVec3,
+  endPoint: PVec3,
+  centrePoint: PVec3,
+  axis: PVec3
+});
+
+// src/api/core/geom/curve.ts
+var z5 = __toESM(require("zod"), 1);
+var PluginCurveApi = class {
+  constructor() {
+  }
+  /** Create a PCurve from a PLine or PArc. */
+  new(curve) {
+    return curve;
+  }
+};
+var PCurve = z5.discriminatedUnion("curveType", [PLine, PArc]);
+
+// src/api/core/geom/profile.ts
+var z6 = __toESM(require("zod"), 1);
+var PluginProfileApi = class {
+  constructor() {
+  }
+  /** Create a new PProfile from an array of PCurves. */
+  new(curves) {
+    return { curves };
+  }
+};
+var PluginProfileFromLinePointsArgs = z6.object({
+  points: z6.array(PVec3)
+});
+var PProfile = z6.object({
+  curves: z6.array(PCurve)
+});
+
+// src/api/core/geom/index.ts
+var PluginGeomApi = class {
+  constructor() {
+  }
+};
+
+// src/api/core/index.ts
+var PluginCoreApi = class {
+  constructor() {
+  }
+};
+
 // src/api/entity/space.ts
+var z7 = __toESM(require("zod"), 1);
 var PluginSpaceApi = class {
   constructor() {
   }
 };
+var PluginSpaceCreateRectangularArgs = z7.object({
+  position: PVec3,
+  dimensions: z7.object({
+    width: z7.number(),
+    height: z7.number(),
+    depth: z7.number()
+  })
+});
+var PluginSpaceCreateRectangularResult = z7.object({
+  spaceId: z7.string()
+});
+var PluginSpaceCreateFromProfileArgs = z7.object({
+  profile: PProfile,
+  extrudeHeight: z7.number(),
+  position: PVec3
+});
+var PluginSpaceCreateFromProfileResult = z7.object({
+  spaceId: z7.string()
+});
+var PluginSpaceGetProperty = z7.enum([
+  "id",
+  "type",
+  "room_type",
+  "name",
+  "area",
+  "department",
+  "position",
+  "absolutePosition",
+  "rotation",
+  "rotationQuaternion"
+]);
+var PluginSpaceGetArgs = z7.object({
+  spaceId: z7.string(),
+  properties: z7.array(PluginSpaceGetProperty)
+});
+var PluginSpaceGetResult = z7.object({
+  id: z7.string(),
+  type: z7.string(),
+  room_type: z7.string(),
+  name: z7.string(),
+  area: z7.number(),
+  department: z7.string(),
+  position: PVec3,
+  absolutePosition: PVec3,
+  rotation: PVec3,
+  rotationQuaternion: PQuat.nullable()
+}).partial();
+var PluginSpaceGetAllResult = z7.object({
+  spacesIds: z7.array(z7.string())
+});
+var PluginSpaceDeleteByIdArgs = z7.object({
+  spaceId: z7.string()
+});
+
+// src/api/entity/story.ts
+var z8 = __toESM(require("zod"), 1);
+var PluginStoryApi = class {
+  constructor() {
+  }
+};
+var PluginStoryGetProperty = z8.enum([
+  "value",
+  "id",
+  "name",
+  "height",
+  "base",
+  "hidden",
+  "spacesCount",
+  "totalArea"
+]);
+var PluginStoryGetArgs = z8.object({
+  storyValue: z8.number().int(),
+  properties: z8.array(PluginStoryGetProperty)
+});
+var PluginStoryGetResult = z8.object({
+  value: z8.number(),
+  id: z8.string(),
+  name: z8.string(),
+  height: z8.number(),
+  base: z8.number(),
+  hidden: z8.boolean(),
+  spacesCount: z8.number(),
+  totalArea: z8.number()
+}).partial();
+var PluginStoryGetAllResult = z8.object({
+  stories: z8.array(
+    z8.object({
+      value: z8.number(),
+      id: z8.string(),
+      name: z8.string()
+    })
+  )
+});
+var PluginStoryCreateArgs = z8.object({
+  storyValue: z8.number().int(),
+  height: z8.number().optional()
+});
+var PluginStoryCreateResult = z8.object({
+  storyId: z8.string(),
+  storyValue: z8.number()
+});
+var PluginStoryUpdateArgs = z8.object({
+  storyValue: z8.number().int(),
+  height: z8.number()
+});
+var PluginStoryUpdateResult = z8.object({
+  storyValue: z8.number(),
+  height: z8.number()
+});
 
 // src/api/entity/index.ts
 var PluginEntityApi = class {
@@ -42,16 +499,31 @@ var PluginEntityApi = class {
 };
 
 // src/api/tools/selection.ts
+var z9 = __toESM(require("zod"), 1);
 var PluginSelectionApi = class {
   constructor() {
   }
 };
+var PluginSelectionGetResult = z9.object({
+  selected: z9.array(z9.string())
+});
 
 // src/api/tools/transform.ts
+var z10 = __toESM(require("zod"), 1);
 var PluginTransformApi = class {
   constructor() {
   }
 };
+var PluginMoveArgs = z10.object({
+  componentIds: z10.array(z10.string()),
+  displacement: PVec3
+});
+var PluginRotateArgs = z10.object({
+  componentIds: z10.array(z10.string()),
+  angle: z10.number(),
+  axis: PVec3,
+  pivot: PVec3
+});
 
 // src/api/tools/index.ts
 var PluginToolsApi = class {
@@ -59,6 +531,36 @@ var PluginToolsApi = class {
   }
 };
 
+// src/api/units/index.ts
+var z11 = __toESM(require("zod"), 1);
+var PluginUnitsApi = class {
+  constructor() {
+  }
+};
+var PUnitType = z11.enum([
+  "meters",
+  "feet-inches",
+  "inches",
+  "centimeters",
+  "millimeters",
+  "kilometers",
+  "miles"
+]);
+var PluginUnitsConvertFromArgs = z11.object({
+  unit: PUnitType,
+  value: z11.number()
+});
+var PluginUnitsConvertFromResult = z11.object({
+  value: z11.number()
+});
+var PluginUnitsConvertToArgs = z11.object({
+  unit: PUnitType,
+  value: z11.number()
+});
+var PluginUnitsConvertToResult = z11.object({
+  value: z11.number()
+});
+
 // src/api/index.ts
 var PluginApi = class {
   constructor() {
@@ -66,11 +568,54 @@ var PluginApi = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PArc,
+  PCurve,
+  PLine,
+  PProfile,
+  PQuat,
+  PUnitType,
+  PVec3,
   PluginApi,
+  PluginArcApi,
+  PluginCoreApi,
+  PluginCurveApi,
   PluginEntityApi,
+  PluginGeomApi,
+  PluginLineApi,
+  PluginMathApi,
+  PluginMoveArgs,
+  PluginProfileApi,
+  PluginProfileFromLinePointsArgs,
+  PluginQuatApi,
+  PluginRotateArgs,
   PluginSelectionApi,
+  PluginSelectionGetResult,
   PluginSpaceApi,
+  PluginSpaceCreateFromProfileArgs,
+  PluginSpaceCreateFromProfileResult,
+  PluginSpaceCreateRectangularArgs,
+  PluginSpaceCreateRectangularResult,
+  PluginSpaceDeleteByIdArgs,
+  PluginSpaceGetAllResult,
+  PluginSpaceGetArgs,
+  PluginSpaceGetProperty,
+  PluginSpaceGetResult,
+  PluginStoryApi,
+  PluginStoryCreateArgs,
+  PluginStoryCreateResult,
+  PluginStoryGetAllResult,
+  PluginStoryGetArgs,
+  PluginStoryGetProperty,
+  PluginStoryGetResult,
+  PluginStoryUpdateArgs,
+  PluginStoryUpdateResult,
   PluginToolsApi,
-  PluginTransformApi
+  PluginTransformApi,
+  PluginUnitsApi,
+  PluginUnitsConvertFromArgs,
+  PluginUnitsConvertFromResult,
+  PluginUnitsConvertToArgs,
+  PluginUnitsConvertToResult,
+  PluginVec3Api
 });
 //# sourceMappingURL=index.cjs.map