@snaptrude/plugin-core 1.0.2-plainpoint-20261026.2 → 1.0.2

package/src/api/presentation/placedViews.ts

@@ -820,6 +820,8 @@ export const PluginViewSettingCategory = z.enum([
   "Reference Line",
   "Adjacency Line",
   "Landscape elements",
+  "Text",
+  "Annotation",
 ])
 export type PluginViewSettingCategory = z.infer<
   typeof PluginViewSettingCategory
@@ -864,6 +866,10 @@ export type PluginViewLineStyle = z.infer<typeof PluginViewLineStyle>
  * | `viewStyle` | `"NONE" \| "FILLET" \| "BUBBLE"`? | Shape restyle: block / rounded corner / bubble |
  * | `radius` | `number`? | Corner radius for `FILLET` (feet) |
  * | `inset` | `number`? | Shape inset/offset |
+ * | `textColor` | `string`? | Dimension / Text / Annotation: `#rrggbb`, or `inherit` (each text keeps its own) |
+ * | `textFontFamily` | `string`? | Text / Annotation: one font family for every text, or `inherit` |
+ * | `textFontStyle` | `"inherit" \| "Regular" \| "Bold" \| "Italic" \| "Bold Italic"`? | Text / Annotation: one font style, or `inherit` (a family without it draws Regular) |
+ * | `leaderVisible` | `boolean`? | Annotation: draw the leaders (line, landing, arrowhead) |
  */
 export const PluginPlacedViewStylePatch = z
   .object({
@@ -921,6 +927,12 @@ export const PluginPlacedViewStylePatch = z
       .regex(/^#[0-9a-fA-F]{6}$/)
       .optional(),
     textMaskPadding: z.number().finite().min(0).max(5).optional(),
+    // Text and Annotation rows: one font for every authored text, or `inherit`.
+    textFontFamily: z.string().trim().min(1).optional(),
+    textFontStyle: z
+      .enum(["inherit", "Regular", "Bold", "Italic", "Bold Italic"])
+      .optional(),
+    leaderVisible: z.boolean().optional(),
   })
   .strict()
   .refine((p) => Object.keys(p).length > 0, {

package/src/api/presentation/standards.ts

@@ -82,6 +82,7 @@ const StoredText = z
       })
       .strict()
       .optional(),
+    Text: z.object({ textMm: TextSize.optional() }).strict().optional(),
   })
   .strict()
 const StoredDimension = z
@@ -226,6 +227,10 @@ export const PluginGraphicStandardPatch = z
           })
           .strict()
           .optional(),
+        Text: z
+          .object({ textMm: TextSize.nullable().optional() })
+          .strict()
+          .optional(),
       })
       .strict()
       .optional(),
@@ -329,6 +334,7 @@ export const PluginResolvedGraphicStandard = z.object({
     gridBubbleRadiusMm: HeadRadius,
     sectionTextMm: TextSize,
     sectionHeadRadiusMm: HeadRadius,
+    annotationMm: TextSize,
   }),
   dimension: z.object({
     tickMm: TickLength,

package/src/handles.ts

@@ -288,17 +288,6 @@ export const EdgeHandle = handleSchema("edge")
 export const HalfEdgeHandle = handleSchema("halfedge")
 export const VertexHandle = handleSchema("vertex")
 export const Vec3Components = z.object({ x: z.number(), y: z.number(), z: z.number() })
-/**
- * A vec3 ARGUMENT: a {@linkcode Vec3Handle} in any inbound form, or a plain finite
- * `{ x, y, z }` point. Geometry reads return plain points, and callers pass them straight
- * back where a vec3 is expected; the host resolves the point as a vector. Returns stay
- * {@linkcode Vec3Handle}. Explicitly typed to keep handles.d.ts inside its size budget.
- */
-export type Vec3Input = Handle<"vec3"> | Vec3Components
-export const Vec3Input: z.ZodUnion<readonly [typeof Vec3Handle, typeof Vec3Components]> = z.union(
-  [Vec3Handle, Vec3Components],
-  { error: 'expected a "vec3" handle or a plain { x, y, z } point' }
-)
 export const QuatComponents = z.object({
   x: z.number(),
   y: z.number(),

package/test/designText.test.mjs

@@ -0,0 +1,72 @@
+// The design.text argument contract, checked before transport.
+// Run: node --test test/
+// Imports the BUILT package (dist) — run `pnpm build` first.
+import test from "node:test"
+import assert from "node:assert/strict"
+import {
+  PluginDesignTextCreateArgs,
+  PluginDesignTextUpdateArgs,
+  PluginTextPatch,
+} from "../dist/index.js"
+
+const position = "vec3_position"
+
+test("create takes one non-blank line of words", () => {
+  assert.equal(
+    PluginDesignTextCreateArgs.safeParse({ position, content: "LIVING" })
+      .success,
+    true,
+  )
+  for (const content of ["", "   ", "two\nlines", "two\r\nlines"])
+    assert.equal(
+      PluginDesignTextCreateArgs.safeParse({ position, content }).success,
+      false,
+      JSON.stringify(content),
+    )
+})
+
+test("create takes a #rrggbb colour and a vec3 handle for the arrowhead", () => {
+  const ok = {
+    position,
+    content: "Shear wall",
+    color: "#c62828",
+    arrowhead: "vec3_head",
+  }
+  assert.equal(PluginDesignTextCreateArgs.safeParse(ok).success, true)
+  for (const color of ["red", "#12345", "c62828"])
+    assert.equal(
+      PluginDesignTextCreateArgs.safeParse({ ...ok, color }).success,
+      false,
+      color,
+    )
+  for (const arrowhead of [{ x: 1, y: 0, z: 2 }, "component_1", "quat_1"])
+    assert.equal(
+      PluginDesignTextCreateArgs.safeParse({ ...ok, arrowhead }).success,
+      false,
+      JSON.stringify(arrowhead),
+    )
+})
+
+test("an update patch sets at least one known field", () => {
+  assert.deepEqual(PluginTextPatch.parse({ fontStyle: "Bold" }), {
+    fontStyle: "Bold",
+  })
+  for (const patch of [
+    {},
+    { size: 3 },
+    { content: "Fire exit", rotation: 90 },
+    { content: " " },
+  ])
+    assert.equal(
+      PluginTextPatch.safeParse(patch).success,
+      false,
+      JSON.stringify(patch),
+    )
+  assert.equal(
+    PluginDesignTextUpdateArgs.safeParse({
+      texts: [],
+      patch: { color: "#1565c0" },
+    }).success,
+    false,
+  )
+})

package/test/paperPensContract.test.mjs

@@ -2,7 +2,10 @@ import { test } from "node:test"
 import assert from "node:assert/strict"
 import {
   PluginGraphicStandardPatch,
+  PluginGraphicsAnnotationCategory,
+  PluginGraphicsOverrideCategory,
   PluginGraphicsOverrides,
+  PluginResolvedGraphicStandard,
   PluginGraphicsSetScaleArgs,
   PluginDesignCreateReferenceLinesArgs,
   PluginReferenceLineOptions,
@@ -36,6 +39,42 @@ test("Paper Pens rejects ambiguous, ineffective and stock-writing edits before t
   assert.deepEqual(PluginGraphicStandardPatch.parse(patch), patch)
 })
 
+test("Text is an annotation category with a projection pen and a size, but no view override", () => {
+  assert.equal(PluginGraphicsAnnotationCategory.safeParse("Text").success, true)
+  assert.equal(PluginGraphicsOverrideCategory.safeParse("Text").success, false)
+  assert.equal(
+    PluginGraphicsOverrides.safeParse({ Text: { hidden: true } }).success,
+    false,
+  )
+  for (const patch of [
+    { annotationText: { Text: { textMm: 3.5 } } },
+    { annotationText: { Text: { textMm: null } } },
+    { objectStyles: { Text: { projection: 2 } } },
+  ])
+    assert.deepEqual(PluginGraphicStandardPatch.parse(patch), patch)
+  for (const patch of [
+    { annotationText: { Text: { textMm: 0 } } },
+    { annotationText: { Text: { sizeMm: 3 } } },
+    { objectStyles: { Text: { cut: 2 } } },
+  ])
+    assert.equal(PluginGraphicStandardPatch.safeParse(patch).success, false)
+  const text = {
+    nameMm: 3,
+    areaMm: 2.5,
+    dimensionMm: 2.5,
+    gridTextMm: 3.5,
+    gridBubbleRadiusMm: 5,
+    sectionTextMm: 3,
+    sectionHeadRadiusMm: 6,
+  }
+  const resolvedText = PluginResolvedGraphicStandard.shape.text
+  assert.equal(resolvedText.safeParse(text).success, false)
+  assert.equal(
+    resolvedText.safeParse({ ...text, annotationMm: 2.5 }).success,
+    true,
+  )
+})
+
 test("explicit reference styles cannot conflict with legacy fields or mixed call forms", () => {
   assert.equal(
     PluginReferenceLineOptions.safeParse({ styleId: "wide", thickness: 3 })

package/test/handles.test.mjs

@@ -1,36 +0,0 @@
-// Node built-in test runner suite for the handle schemas.
-// Imports the BUILT package (dist) — run `pnpm build` first.
-import test from "node:test"
-import assert from "node:assert/strict"
-import { Vec3Handle, Vec3Input, Handle, PluginDesignMoveArgs } from "../dist/index.js"
-
-test("a vec3 handle parses in every inbound form, and only as a handle", () => {
-  for (const v of ["vec3_abc", new Handle("vec3_abc"), { __h: "vec3_abc" }, { id: "vec3_abc" }]) {
-    const out = Vec3Handle.parse(v)
-    assert.ok(out instanceof Handle)
-    assert.equal(out.id, "vec3_abc")
-  }
-  assert.equal(Vec3Handle.safeParse({ x: 1, y: 2, z: 3 }).success, false)
-  const bad = Vec3Handle.safeParse("profile_1")
-  assert.equal(bad.success, false)
-  assert.match(bad.error.issues[0].message, /expected a "vec3" handle/)
-})
-
-test("Vec3Input takes a handle or a plain { x, y, z } point", () => {
-  // Geometry reads return plain points; agents pass them back where a vec3 belongs.
-  const point = { x: 1, y: 2.5, z: -3 }
-  assert.deepEqual(Vec3Input.parse(point), point)
-  assert.ok(Vec3Input.parse("vec3_abc") instanceof Handle)
-  const args = PluginDesignMoveArgs.parse({ components: ["wl_1"], displacement: { x: 0, y: 0, z: 10 } })
-  assert.deepEqual(args.displacement, { x: 0, y: 0, z: 10 })
-  const handled = PluginDesignMoveArgs.parse({ components: ["wl_1"], displacement: "vec3_d" })
-  assert.equal(handled.displacement.id, "vec3_d")
-})
-
-test("Vec3Input still rejects non-points and wrong handles, with one message", () => {
-  for (const v of [{ x: 1, y: 2 }, { x: 1, y: Number.NaN, z: 3 }, { x: "1", y: 2, z: 3 }, "profile_1", null, 42]) {
-    const r = Vec3Input.safeParse(v)
-    assert.equal(r.success, false, JSON.stringify(v))
-    assert.equal(r.error.issues[0].message, 'expected a "vec3" handle or a plain { x, y, z } point')
-  }
-})