@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/SceneCanvas/defaultNodeProperties.js

@@ -1,62 +1,130 @@
-import { KIT_SHAPE_KINDS as e } from "../../core/shapeKinds.js";
-import { inferredNodeRouting as t } from "./defaultNodeRouting.js";
-import { dashForStrokeStyle as n, strokeDashStyleOf as r } from "@weasel-js/paint";
-import { listMarkers as i, markerGeneration as a } from "@weasel-js/stroke";
-import { resolveAlign as o } from "@weasel-js/text";
-import { ANGLE_RADIANS as s } from "@weasel-js/quantity";
-import { prefUnit as c } from "@weasel-js/prefs";
+import { minSizeOf } from "../../core/scene/minSize.js";
+import { KIT_SHAPE_KINDS, shapeKindInfo } from "../../core/shapeKinds.js";
+import { settleShapeGenerator } from "../../features/paths/shapeGenerator.js";
+import { inferredNodeRouting } from "./defaultNodeRouting.js";
+import { SHAPE_GENERATOR_SECTIONS } from "./shapeGeneratorProperties.js";
+import { poseLinearOf } from "@weasel-js/geom";
+import { dashForStrokeStyle, strokeDashStyleOf } from "@weasel-js/paint";
+import { listMarkers, markerGeneration } from "@weasel-js/stroke";
+import { resolveAlign } from "@weasel-js/text";
+import { ANGLE_RADIANS, decimal } from "@weasel-js/quantity";
+import { prefUnit } from "@weasel-js/prefs";
+
 //#region src/canvas/SceneCanvas/defaultNodeProperties.ts
-var l = c(s, "deg", {
+/** Radians-stored / degrees-shown conversion for `pose.rotation` leaves.
+*  Display rounds to 0.1° so a canonical radian value doesn't render as
+*  a 15-digit float. */
+var rotationDegreesUnit = prefUnit(ANGLE_RADIANS, "deg", {
 	precision: 1,
 	suffix: "°"
 });
-function u(e) {
-	let t = e?.width;
-	if (typeof t == "number" || typeof t == "object" && t && typeof t.px == "number") return t;
+/** How a typed number reads. The stored value keeps every digit a drag or a scale gave it. */
+var TWO_PLACES = decimal({
+	maxPlaces: 2,
+	grouping: false
+});
+/** `Stroke.width` off a partly-typed stroke object, or `undefined`. */
+function strokeWidthOf(stroke) {
+	const w = stroke?.width;
+	if (typeof w === "number") return w;
+	if (typeof w === "object" && w !== null && typeof w.px === "number") return w;
 }
-var d = {
-	read: (e, t) => t === void 0 ? void 0 : r(Array.isArray(e) ? e : void 0, u(t)),
-	write: (e, t) => e === "dashed" || e === "dotted" ? n(e, u(t)) : e === "solid" ? void 0 : t?.dash
-}, f = {
-	read: (e) => typeof e == "string" ? e : e && typeof e == "object" && "key" in e ? String(e.key) : "",
-	write: (e) => e === "" ? void 0 : e
-}, p = {
-	read: (e) => e === "italic",
-	write: (e) => e ? "italic" : void 0
-}, m = {
-	read: (e, t) => {
-		if (e === void 0 || e === "justify") return e;
-		let n = t?.direction === "rtl" ? "rtl" : "ltr";
-		return o(e, n);
+/** `Stroke.dash` — a stored array of lengths — read and written as a named
+*  style. The presets are multiples of the sibling `width`, which is why the
+*  encoding is handed the whole stroke rather than the field. */
+var strokeDashEncoding = {
+	read: (dash, stroke) => stroke === void 0 ? void 0 : strokeDashStyleOf(Array.isArray(dash) ? dash : void 0, strokeWidthOf(stroke)),
+	write: (style, stroke) => style === "dashed" || style === "dotted" ? dashForStrokeStyle(style, strokeWidthOf(stroke)) : style === "solid" ? void 0 : stroke?.dash
+};
+/** `Stroke.markerStart` / `markerMid` / `markerEnd` — a `MarkerRef` — read and
+*  written as a bare key, with the empty string standing for no marker. */
+var markerEncoding = {
+	read: (ref) => {
+		if (typeof ref === "string") return ref;
+		if (ref && typeof ref === "object" && "key" in ref) return String(ref.key);
+		return "";
+	},
+	write: (value) => value === "" ? void 0 : value
+};
+/** `TextStyle.fontStyle` as an Italic flag. Off removes the field rather than
+*  storing `'normal'`, which is what an absent one already means. */
+var italicEncoding = {
+	read: (stored) => stored === "italic",
+	write: (on) => on ? "italic" : void 0
+};
+/** `TextStyle.align` read as the edge that paints, or as `justify`. The model
+*  also holds the reading-order pair `start` / `end`, which name an edge only
+*  under a stated `direction`. Under `auto` each paragraph takes its own from
+*  its text, so no segment is lit. A click writes the edge. */
+var alignEncoding = {
+	read: (stored, style) => {
+		if (stored === "start" || stored === "end") {
+			const direction = style?.direction;
+			return direction === "ltr" || direction === "rtl" ? resolveAlign(stored, direction) : void 0;
+		}
+		return stored;
 	},
-	write: (e) => e
-}, h;
-function g() {
-	let e = a();
-	return h?.generation !== e && (h = {
-		generation: e,
+	write: (edge) => edge
+};
+var DEFAULT_NIB = {
+	angle: Math.PI / 6,
+	ratio: .25
+};
+/** `Stroke.nib` as a flag: on keeps the nib held, or starts a default one,
+*  and off removes it. */
+var nibEncoding = {
+	read: (stored) => stored != null && typeof stored === "object",
+	write: (on, stroke) => on ? stroke?.nib ?? DEFAULT_NIB : void 0
+};
+/** `pose.transform` as a flag: on while the pose carries a skew or a per-axis
+*  scale, and off removes it. On keeps the one held, since a flag cannot
+*  author a matrix. */
+var transformEncoding = {
+	read: (stored) => poseLinearOf({ transform: stored }) !== null,
+	write: (on, pose) => on ? pose?.transform : void 0
+};
+/** `data.overflow` as a flag: on is `'clip'`, and off removes the key, since
+*  absent draws past the box. */
+var overflowEncoding = {
+	read: (stored) => stored === "clip",
+	write: (on) => on ? "clip" : void 0
+};
+var markerOptionsCache;
+/** A `select` rather than a `toggle`: nine options will not fit a segmented
+*  strip. One array per state of the registry, so a reader comparing
+*  references sees a change only when the set changed. */
+function markerOptions() {
+	const generation = markerGeneration();
+	if (markerOptionsCache?.generation !== generation) markerOptionsCache = {
+		generation,
 		options: [{
 			value: "",
 			label: "None"
-		}, ...i().map((e) => ({
-			value: e.id,
-			label: e.id
+		}, ...listMarkers().map((m) => ({
+			value: m.id,
+			label: m.id
 		}))]
-	}), h.options;
+	};
+	return markerOptionsCache.options;
 }
-function _(e) {
+function markerLeaf(leaf) {
 	return {
 		kind: "enum",
 		default: "",
 		control: "select",
-		encoding: f,
-		...e,
+		encoding: markerEncoding,
+		...leaf,
 		get options() {
-			return g();
+			return markerOptions();
 		}
 	};
 }
-var v = {
+/** `data.fill` is a whole `Fill`, so it is an object leaf, as the stroke is.
+*  Its field is a `paint` leaf, not a `color` one, because a color control
+*  would read `undefined` off a gradient and write a bare string over it.
+*  `block` for the same reason every stroke field is: the kind bar and the
+*  per-kind editor want the width a 64px label column takes. */
+var FILL_LEAF = {
 	kind: "object",
 	name: "Fill",
 	description: "Fill paint.",
@@ -64,7 +132,7 @@ var v = {
 		kind: "solid",
 		color: "#000000ff"
 	} },
-	block: !0,
+	block: true,
 	children: { paint: {
 		kind: "paint",
 		name: "Fill",
@@ -73,252 +141,335 @@ var v = {
 			kind: "solid",
 			color: "#000000ff"
 		},
-		alpha: !0,
-		block: !0
+		alpha: true,
+		block: true
 	} }
 };
-function y(e = {}) {
+/** A text node's `data.background`: a `Fill`, as `data.fill` is, painted over
+*  the whole box rather than the glyphs. */
+var BACKGROUND_LEAF = {
+	...FILL_LEAF,
+	name: "Background",
+	description: "Paint behind the text, over the whole box.",
+	default: { paint: {
+		kind: "solid",
+		color: "#ffffffff"
+	} },
+	children: { paint: {
+		kind: "paint",
+		name: "Background",
+		description: "Paint behind the text.",
+		default: {
+			kind: "solid",
+			color: "#ffffffff"
+		},
+		alpha: true,
+		block: true
+	} }
+};
+/** A whole `Stroke`: paint and line geometry, one value. */
+var STROKE_LEAF = {
+	kind: "object",
+	name: "Stroke",
+	description: "Stroke paint and line geometry.",
+	default: {
+		paint: {
+			kind: "solid",
+			color: "#000000ff"
+		},
+		width: 1
+	},
+	block: true,
+	children: {
+		width: {
+			kind: "number",
+			name: "Width",
+			description: "Stroke width, world units.",
+			absentIsDefault: true,
+			default: 1,
+			min: 0,
+			max: 20,
+			step: .5,
+			control: "slider",
+			icon: /* @icon */ "core:strokeWidth",
+			block: true
+		},
+		paint: {
+			kind: "paint",
+			name: "Paint",
+			description: "Stroke paint.",
+			default: {
+				kind: "solid",
+				color: "#000000ff"
+			},
+			alpha: true,
+			block: true
+		},
+		cap: {
+			kind: "enum",
+			name: "Cap",
+			description: "How an open end is drawn.",
+			absentIsDefault: true,
+			default: "butt",
+			control: "toggle",
+			block: true,
+			pair: {
+				with: ["data.stroke.join", "data.stroke.align"],
+				label: "Line"
+			},
+			options: [
+				{
+					value: "butt",
+					label: "Butt",
+					icon: /* @icon */ "core:capButt"
+				},
+				{
+					value: "round",
+					label: "Round",
+					icon: /* @icon */ "core:capRound"
+				},
+				{
+					value: "square",
+					label: "Square",
+					icon: /* @icon */ "core:capSquare"
+				}
+			]
+		},
+		join: {
+			kind: "enum",
+			name: "Join",
+			description: "How a corner is drawn.",
+			absentIsDefault: true,
+			default: "miter",
+			control: "toggle",
+			block: true,
+			options: [
+				{
+					value: "miter",
+					label: "Miter",
+					icon: /* @icon */ "core:joinMiter"
+				},
+				{
+					value: "round",
+					label: "Round",
+					icon: /* @icon */ "core:joinRound"
+				},
+				{
+					value: "bevel",
+					label: "Bevel",
+					icon: /* @icon */ "core:joinBevel"
+				}
+			]
+		},
+		align: {
+			kind: "enum",
+			name: "Align",
+			description: "Where the ribbon sits relative to the edge.",
+			absentIsDefault: true,
+			default: "center",
+			control: "toggle",
+			block: true,
+			options: [
+				{
+					value: "inner",
+					label: "Inner",
+					icon: /* @icon */ "core:alignInner"
+				},
+				{
+					value: "center",
+					label: "Center",
+					icon: /* @icon */ "core:alignCenter"
+				},
+				{
+					value: "outer",
+					label: "Outer",
+					icon: /* @icon */ "core:alignOuter"
+				}
+			]
+		},
+		dash: {
+			kind: "enum",
+			name: "Style",
+			description: "Solid, dashed or dotted. Dash lengths are multiples of the stroke width, so a style holds as the width changes.",
+			default: "solid",
+			control: "toggle",
+			block: true,
+			encoding: strokeDashEncoding,
+			options: [
+				{
+					value: "solid",
+					label: "Solid",
+					icon: /* @icon */ "core:dashSolid"
+				},
+				{
+					value: "dashed",
+					label: "Dashed",
+					icon: /* @icon */ "core:dashDashed"
+				},
+				{
+					value: "dotted",
+					label: "Dotted",
+					icon: /* @icon */ "core:dashDotted"
+				},
+				{
+					value: "custom",
+					label: "Custom",
+					icon: /* @icon */ "core:dashCustom",
+					disabled: true
+				}
+			]
+		},
+		nib: {
+			kind: "boolean",
+			name: "Nib",
+			description: "A broad pen: the stroke is its full width moving across the nib, and thinner moving along it.",
+			default: false,
+			control: "switch",
+			block: true,
+			encoding: nibEncoding
+		},
+		"nib.angle": {
+			kind: "number",
+			name: "Angle",
+			description: "The nib's edge, counterclockwise from level.",
+			default: DEFAULT_NIB.angle,
+			step: 1,
+			unit: rotationDegreesUnit,
+			block: true,
+			showIf: { path: "data.stroke.nib" },
+			pair: {
+				with: "data.stroke.nib.ratio",
+				label: "Nib"
+			}
+		},
+		"nib.ratio": {
+			kind: "number",
+			name: "Thinnest",
+			description: "The width moving along the nib, as a fraction of the width moving across it.",
+			default: DEFAULT_NIB.ratio,
+			min: 0,
+			max: 1,
+			step: .05,
+			control: "slider",
+			block: true,
+			showIf: { path: "data.stroke.nib" }
+		},
+		markerStart: markerLeaf({
+			name: "Start",
+			description: "Marker at the first vertex of each open subpath.",
+			block: true,
+			pair: {
+				with: ["data.stroke.markerMid", "data.stroke.markerEnd"],
+				label: "Markers"
+			}
+		}),
+		markerMid: markerLeaf({
+			name: "Mid",
+			description: "Marker at every interior authored vertex.",
+			block: true
+		}),
+		markerEnd: markerLeaf({
+			name: "End",
+			description: "Marker at the last vertex of each open subpath.",
+			block: true
+		})
+	}
+};
+/** A box side's floor: the node's `data.minSize`, which resize and insert hold it to as well. */
+var minSizeAt = (side) => (read) => minSizeOf({ minSize: read("data.minSize") })?.[side];
+/** The pose box, its rotation, and the `transform` inside that. */
+var LAYOUT = {
+	name: "Layout",
+	members: {
+		"pose.x": {
+			kind: "number",
+			display: TWO_PLACES,
+			name: "X",
+			description: "Left edge, world units.",
+			default: 0,
+			pair: {
+				with: "pose.y",
+				label: "Position"
+			}
+		},
+		"pose.y": {
+			kind: "number",
+			display: TWO_PLACES,
+			name: "Y",
+			description: "Top edge, world units.",
+			default: 0
+		},
+		"pose.width": {
+			kind: "number",
+			display: TWO_PLACES,
+			name: "W",
+			description: "Width, world units.",
+			default: 0,
+			min: 0,
+			minAt: minSizeAt("width"),
+			pair: {
+				with: "pose.height",
+				label: "Size"
+			}
+		},
+		"pose.height": {
+			kind: "number",
+			display: TWO_PLACES,
+			name: "H",
+			description: "Height, world units.",
+			default: 0,
+			min: 0,
+			minAt: minSizeAt("height")
+		},
+		"pose.rotation": {
+			kind: "number",
+			name: "Rotation",
+			description: "Rotation about the box center.",
+			default: 0,
+			step: 1,
+			unit: rotationDegreesUnit,
+			absentIsDefault: true
+		},
+		"pose.transform": {
+			kind: "boolean",
+			name: "Skew",
+			description: "The skew or per-axis scale the box and rotation cannot hold. Off removes it.",
+			default: false,
+			control: "switch",
+			encoding: transformEncoding
+		}
+	}
+};
+/** Build the standard shape schema — Layout (pose box + rotation) +
+*  Appearance (fill / stroke), optionally a Text group. Matches the kit's
+*  builtin-shape data template (`{ path, fill, stroke?, text? }`,
+*  `useBuiltinShapeTools`). */
+function shapeSchema(opts = {}) {
 	return {
 		name: "Properties",
 		members: {
-			layout: {
-				name: "Layout",
-				members: {
-					"pose.x": {
-						kind: "number",
-						name: "X",
-						description: "Left edge, world units.",
-						default: 0,
-						pair: {
-							with: "pose.y",
-							label: "Position"
-						}
-					},
-					"pose.y": {
-						kind: "number",
-						name: "Y",
-						description: "Top edge, world units.",
-						default: 0
-					},
-					"pose.width": {
-						kind: "number",
-						name: "W",
-						description: "Width, world units.",
-						default: 0,
-						min: 0,
-						pair: {
-							with: "pose.height",
-							label: "Size"
-						}
-					},
-					"pose.height": {
-						kind: "number",
-						name: "H",
-						description: "Height, world units.",
-						default: 0,
-						min: 0
-					},
-					"pose.rotation": {
-						kind: "number",
-						name: "Rotation",
-						description: "Rotation about the box center.",
-						default: 0,
-						step: 1,
-						unit: l,
-						absentIsDefault: !0
-					}
-				}
-			},
-			...e.text ? { content: {
+			layout: LAYOUT,
+			...Object.fromEntries((opts.generators ?? []).map((g) => [g, SHAPE_GENERATOR_SECTIONS[g]])),
+			...opts.text ? { content: {
 				name: "Content",
 				members: { "data.text": {
 					kind: "string",
 					name: "Text",
 					description: "Text content.",
-					absentIsDefault: !0,
+					absentIsDefault: true,
 					default: "",
-					block: !0
+					block: true
 				} }
 			} } : {},
 			appearance: {
 				name: "",
 				members: {
-					"data.fill": v,
-					"data.stroke": {
-						kind: "object",
-						name: "Stroke",
-						description: "Stroke paint and line geometry.",
-						default: {
-							paint: {
-								kind: "solid",
-								color: "#000000ff"
-							},
-							width: 1
-						},
-						block: !0,
-						children: {
-							width: {
-								kind: "number",
-								name: "Width",
-								description: "Stroke width, world units.",
-								absentIsDefault: !0,
-								default: 1,
-								min: 0,
-								max: 20,
-								step: .5,
-								control: "slider",
-								icon: "strokeWidth",
-								block: !0
-							},
-							paint: {
-								kind: "paint",
-								name: "Paint",
-								description: "Stroke paint.",
-								default: {
-									kind: "solid",
-									color: "#000000ff"
-								},
-								alpha: !0,
-								block: !0
-							},
-							cap: {
-								kind: "enum",
-								name: "Cap",
-								description: "How an open end is drawn.",
-								absentIsDefault: !0,
-								default: "butt",
-								control: "toggle",
-								block: !0,
-								pair: {
-									with: ["data.stroke.join", "data.stroke.align"],
-									label: "Line"
-								},
-								options: [
-									{
-										value: "butt",
-										label: "Butt",
-										icon: "capButt"
-									},
-									{
-										value: "round",
-										label: "Round",
-										icon: "capRound"
-									},
-									{
-										value: "square",
-										label: "Square",
-										icon: "capSquare"
-									}
-								]
-							},
-							join: {
-								kind: "enum",
-								name: "Join",
-								description: "How a corner is drawn.",
-								absentIsDefault: !0,
-								default: "miter",
-								control: "toggle",
-								block: !0,
-								options: [
-									{
-										value: "miter",
-										label: "Miter",
-										icon: "joinMiter"
-									},
-									{
-										value: "round",
-										label: "Round",
-										icon: "joinRound"
-									},
-									{
-										value: "bevel",
-										label: "Bevel",
-										icon: "joinBevel"
-									}
-								]
-							},
-							align: {
-								kind: "enum",
-								name: "Align",
-								description: "Where the ribbon sits relative to the edge.",
-								absentIsDefault: !0,
-								default: "center",
-								control: "toggle",
-								block: !0,
-								options: [
-									{
-										value: "inner",
-										label: "Inner",
-										icon: "alignInner"
-									},
-									{
-										value: "center",
-										label: "Center",
-										icon: "alignCenter"
-									},
-									{
-										value: "outer",
-										label: "Outer",
-										icon: "alignOuter"
-									}
-								]
-							},
-							dash: {
-								kind: "enum",
-								name: "Style",
-								description: "Solid, dashed or dotted. Dash lengths are multiples of the stroke width, so a style holds as the width changes.",
-								default: "solid",
-								control: "toggle",
-								block: !0,
-								encoding: d,
-								options: [
-									{
-										value: "solid",
-										label: "Solid",
-										icon: "dashSolid"
-									},
-									{
-										value: "dashed",
-										label: "Dashed",
-										icon: "dashDashed"
-									},
-									{
-										value: "dotted",
-										label: "Dotted",
-										icon: "dashDotted"
-									},
-									{
-										value: "custom",
-										label: "Custom",
-										icon: "dashCustom",
-										disabled: !0
-									}
-								]
-							},
-							markerStart: _({
-								name: "Start",
-								description: "Marker at the first vertex of each open subpath.",
-								block: !0,
-								pair: {
-									with: ["data.stroke.markerMid", "data.stroke.markerEnd"],
-									label: "Markers"
-								}
-							}),
-							markerMid: _({
-								name: "Mid",
-								description: "Marker at every interior authored vertex.",
-								block: !0
-							}),
-							markerEnd: _({
-								name: "End",
-								description: "Marker at the last vertex of each open subpath.",
-								block: !0
-							})
-						}
-					}
+					"data.fill": FILL_LEAF,
+					...opts.text ? { "data.background": BACKGROUND_LEAF } : {},
+					"data.stroke": STROKE_LEAF
 				}
 			},
-			...e.text ? { text: {
+			...opts.text ? { text: {
 				name: "",
 				members: {
 					"data.style": {
@@ -326,8 +477,8 @@ function y(e = {}) {
 						name: "Style",
 						description: "Typography for the whole node. Its color is the node's own `data.fill`, in Appearance.",
 						default: {},
-						absentIsDefault: !0,
-						block: !0,
+						absentIsDefault: true,
+						block: true,
 						children: {
 							character: {
 								name: "Character",
@@ -336,14 +487,15 @@ function y(e = {}) {
 										kind: "font-family",
 										name: "Font",
 										description: "Registered font family.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "sans-serif"
 									},
 									fontSize: {
 										kind: "number",
+										display: TWO_PLACES,
 										name: "Size",
 										description: "Font size, world units.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 16,
 										min: 1,
 										step: 1,
@@ -356,16 +508,16 @@ function y(e = {}) {
 										kind: "font-weight",
 										name: "Weight",
 										description: "Font weight, from the faces the family has.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 400
 									},
 									fontStyle: {
 										kind: "boolean",
 										name: "Italic",
 										description: "Set the text in its italic face.",
-										default: !1,
+										default: false,
 										control: "toggle",
-										icon: "italic",
+										icon: /* @icon */ "core:italic",
 										short: ["I"],
 										pair: {
 											with: [
@@ -376,36 +528,36 @@ function y(e = {}) {
 											],
 											label: "Style"
 										},
-										encoding: p
+										encoding: italicEncoding
 									},
 									underline: {
 										kind: "boolean",
 										name: "Underline",
 										description: "Underline the text.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "toggle",
-										icon: "underline",
+										icon: /* @icon */ "core:underline",
 										short: ["U"]
 									},
 									strikethrough: {
 										kind: "boolean",
 										name: "Strikethrough",
 										description: "Strike through the text.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "toggle",
-										icon: "strikethrough",
+										icon: /* @icon */ "core:strikethrough",
 										short: ["S"]
 									},
 									overline: {
 										kind: "boolean",
 										name: "Overline",
 										description: "Rule the text above its ascent.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "toggle",
-										icon: "overline",
+										icon: /* @icon */ "core:overline",
 										short: ["O"]
 									},
 									script: {
@@ -414,22 +566,23 @@ function y(e = {}) {
 										description: "Set the text smaller and raised or lowered, on the line it would otherwise hold.",
 										default: void 0,
 										control: "toggle",
-										clearable: !0,
+										clearable: true,
 										options: [{
 											value: "super",
 											label: "Superscript",
-											icon: "superscript"
+											icon: /* @icon */ "core:superscript"
 										}, {
 											value: "sub",
 											label: "Subscript",
-											icon: "subscript"
+											icon: /* @icon */ "core:subscript"
 										}]
 									},
 									letterSpacing: {
 										kind: "number",
+										display: TWO_PLACES,
 										name: "Tracking",
 										description: "Extra advance per glyph, world units.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 0,
 										step: .1
 									},
@@ -437,7 +590,7 @@ function y(e = {}) {
 										kind: "enum",
 										name: "Case",
 										description: "Draw the text in capitals, lowercase or title case. The text itself is unchanged.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "none",
 										control: "toggle",
 										options: [
@@ -467,7 +620,7 @@ function y(e = {}) {
 										kind: "enum",
 										name: "Small caps",
 										description: "Draw lowercase letters as smaller capitals. The text itself is unchanged.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "normal",
 										control: "toggle",
 										options: [{
@@ -487,9 +640,10 @@ function y(e = {}) {
 								members: {
 									lineHeight: {
 										kind: "number",
+										display: TWO_PLACES,
 										name: "Leading",
 										description: "Line height as a multiple of font size.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 1.2,
 										min: .5,
 										step: .1
@@ -498,15 +652,16 @@ function y(e = {}) {
 										kind: "boolean",
 										name: "Wrap",
 										description: "Break lines between words at the box width.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "switch"
 									},
 									tabSize: {
 										kind: "number",
+										display: TWO_PLACES,
 										name: "Tab size",
 										description: "Distance between tab stops, in spaces.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 8,
 										min: 1,
 										step: 1
@@ -515,7 +670,7 @@ function y(e = {}) {
 										kind: "enum",
 										name: "Direction",
 										description: "Reading direction. Auto takes each paragraph's from its first strong character.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "auto",
 										control: "toggle",
 										options: [
@@ -540,30 +695,30 @@ function y(e = {}) {
 										kind: "enum",
 										name: "Align",
 										description: "Horizontal alignment.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "left",
 										control: "toggle",
-										encoding: m,
+										encoding: alignEncoding,
 										options: [
 											{
 												value: "left",
 												label: "Left",
-												icon: "textAlignLeft"
+												icon: /* @icon */ "core:textAlignLeft"
 											},
 											{
 												value: "center",
 												label: "Center",
-												icon: "textAlignCenter"
+												icon: /* @icon */ "core:textAlignCenter"
 											},
 											{
 												value: "right",
 												label: "Right",
-												icon: "textAlignRight"
+												icon: /* @icon */ "core:textAlignRight"
 											},
 											{
 												value: "justify",
 												label: "Justify",
-												icon: "textAlignJustify"
+												icon: /* @icon */ "core:textAlignJustify"
 											}
 										]
 									}
@@ -571,44 +726,86 @@ function y(e = {}) {
 							}
 						}
 					},
+					"data.padding": {
+						kind: "number",
+						display: TWO_PLACES,
+						name: "Padding",
+						description: "Inset from the box to the text on every side, world units.",
+						absentIsDefault: true,
+						default: 0,
+						min: 0,
+						step: 1
+					},
 					"data.verticalAlign": {
 						kind: "enum",
 						name: "Vertical",
 						description: "Where the lines sit in the box's height.",
-						absentIsDefault: !0,
+						absentIsDefault: true,
 						default: "top",
 						control: "toggle",
 						options: [
 							{
 								value: "top",
 								label: "Top",
-								icon: "textAlignTop"
+								icon: /* @icon */ "core:textAlignTop"
 							},
 							{
 								value: "center",
 								label: "Middle",
-								icon: "textAlignMiddle"
+								icon: /* @icon */ "core:textAlignMiddle"
 							},
 							{
 								value: "bottom",
 								label: "Bottom",
-								icon: "textAlignBottom"
+								icon: /* @icon */ "core:textAlignBottom"
 							}
 						]
+					},
+					"data.overflow": {
+						kind: "boolean",
+						name: "Clip",
+						description: "Cut the text at the box's edge instead of drawing it past.",
+						default: false,
+						control: "switch",
+						encoding: overflowEncoding
 					}
 				}
 			} } : {}
 		}
 	};
 }
-var b = e.map((e) => ({
-	name: e,
-	schema: y({ text: e === "text" })
-})), x = t.map((e) => ({
-	name: e.name,
-	schema: y({ text: e.name === "text" })
-}));
-//#endregion
-export { b as defaultNodeProperties, x as inferredNodeProperties, l as rotationDegreesUnit };
+/** The kinds whose nodes can hold a `data.generator`, and which kinds of it. */
+var GENERATED_KINDS = {
+	polygon: ["polygon"],
+	star: ["star"],
+	path: ["polygon", "star"]
+};
+function shapeEntry(name) {
+	const generators = GENERATED_KINDS[name];
+	return {
+		name,
+		schema: shapeSchema({
+			text: shapeKindInfo(name)?.text ?? false,
+			...generators ? { generators } : {}
+		}),
+		...generators ? { settle: settleShapeGenerator } : {}
+	};
+}
+/**
+* Default properties-trait entries covering the kit's built-in shape
+* kinds (`KIT_SHAPE_KINDS`) — the sibling of `defaultNodeRouting`. Every
+* kind gets the standard box schema; `text` adds a Text group. In
+* lockstep with `KIT_SHAPE_KINDS` by construction (derived via `.map`).
+*/
+var defaultNodeProperties = KIT_SHAPE_KINDS.map(shapeEntry);
+/**
+* Properties-trait entries for the *inferred* routing kinds
+* (`inferredNodeRouting`: `text` / `path` / `image`) — the vocabulary
+* consumers produce when they don't tag `data.kind` (e.g. WeaselDraw).
+* In lockstep with `inferredNodeRouting` by construction.
+*/
+var inferredNodeProperties = inferredNodeRouting.map((e) => shapeEntry(e.name));
 
+//#endregion
+export { defaultNodeProperties, inferredNodeProperties, rotationDegreesUnit };
 //# sourceMappingURL=defaultNodeProperties.js.map