@weasel-js/core 1.7.0 → 1.7.2

package/dist/canvas/SceneCanvas/DepRegistryProviderIfRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepRegistryProviderIfRoot.js","names":["_Fragment","DepRegistryProviderIfRoot","useOptionalDepRegistry","Fragment","DepRegistryProvider"],"sources":["../../../src/canvas/SceneCanvas/DepRegistryProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<DepRegistryProvider>` wrapper: mounts one only when no registry\n * is in scope, and otherwise renders its children against the one there. Used\n * by a non-isolated `<WeaselProvider>`. Mirrors `ActionsProviderIfRoot`.\n */\nimport type { ReactNode } from 'react';\nimport { DepRegistryProvider, useOptionalDepRegistry } from '@weasel-js/routing/react';\n\n/** Mount a `<DepRegistryProvider>` only when none is already in scope, so a\n *  consumer's dep sources are not shadowed by a nested canvas. */\nexport function DepRegistryProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = useOptionalDepRegistry();\n  if (parent) return <>{children}</>;\n  return <DepRegistryProvider>{children}</DepRegistryProvider>;\n}\n"],"mappings":";;;AAUA,SAAgBC,EAA0B,EAAE,eAAqC;CAG/E,OAFeC,EACX,IAAe,kBAAAF,GAAA,EAAG,YAAW,CAAA,IAC1B,kBAACI,GAAD,EAAsB,YAA8B,CAAA;AAC7D"}

package/dist/canvas/SceneCanvas/PointerProviderIfRoot.js

@@ -0,0 +1,51 @@
+import { clientToWorld as e } from "../../core/viewport/clientToWorld.js";
+import { PointerContextProvider as t, usePointerContext as n } from "../../features/pointer/PointerContext.js";
+import { useOptionalViewRegistry as r } from "../viewRegistry.js";
+import { useEffect as i } from "react";
+import { Fragment as a, jsx as o } from "react/jsx-runtime";
+//#region src/canvas/SceneCanvas/PointerProviderIfRoot.tsx
+function s({ children: e }) {
+	return n() ? /* @__PURE__ */ o(a, { children: e }) : /* @__PURE__ */ o(t, { children: e });
+}
+function c({ canvasRef: t }) {
+	let a = n(), o = r();
+	return i(() => {
+		if (!a) return;
+		let n = t.current;
+		if (!n) return;
+		let r = (t, r, i) => {
+			let s = o?.resolver.at(t, r, i), c = n.getBoundingClientRect(), [l, u] = e(r, i, s?.origin ?? c, s?.view ?? {
+				x: 0,
+				y: 0,
+				scale: {
+					x: 1,
+					y: 1
+				}
+			});
+			a.set({
+				worldX: l,
+				worldY: u,
+				viewId: s?.id ?? null
+			});
+		}, i = (e) => r(e.pointerId, e.clientX, e.clientY), s = (e) => {
+			if (e.buttons !== 0) {
+				r(e.pointerId, e.clientX, e.clientY);
+				return;
+			}
+			a.set(null);
+		}, c = (e) => {
+			e.target !== n && e.buttons !== 0 && r(e.pointerId, e.clientX, e.clientY);
+		};
+		return n.addEventListener("pointermove", i), n.addEventListener("pointerleave", s), document.addEventListener("pointermove", c), () => {
+			n.removeEventListener("pointermove", i), n.removeEventListener("pointerleave", s), document.removeEventListener("pointermove", c);
+		};
+	}, [
+		a,
+		t,
+		o
+	]), null;
+}
+//#endregion
+export { s as PointerProviderIfRoot, c as PointerPublisher };
+
+//# sourceMappingURL=PointerProviderIfRoot.js.map

package/dist/canvas/SceneCanvas/PointerProviderIfRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointerProviderIfRoot.js","names":["_Fragment","PointerProviderIfRoot","usePointerContext","Fragment","PointerContextProvider","PointerPublisher","ctx","registry","useOptionalViewRegistry","useEffect","el","canvasRef","publish","target","pointerId","clientX","clientY","rect","worldX","worldY","clientToWorld","onMove","onLeave","onDocMove"],"sources":["../../../src/canvas/SceneCanvas/PointerProviderIfRoot.tsx"],"sourcesContent":["/**\n * Conditional `<PointerContextProvider>` wrapper. Mounts a provider only\n * when no parent provider is in scope — otherwise renders children unwrapped\n * so SceneCanvas defers to the host's existing scope.\n *\n * Pairs with `<PointerPublisher>` which attaches native pointermove/leave\n * listeners to the canvas element and writes world-space coords into the\n * surrounding context's `pointerRef`.\n */\nimport { useEffect, type MutableRefObject, type ReactNode } from 'react';\nimport { PointerContextProvider, usePointerContext } from 'features/pointer/PointerContext';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\nimport { useOptionalViewRegistry } from '../viewRegistry';\n\n/** Mount a `<PointerContextProvider>` only when none is already in scope. */\nexport function PointerProviderIfRoot({ children }: { children: ReactNode }) {\n  const parent = usePointerContext();\n  if (parent) return <>{children}</>;\n  return <PointerContextProvider>{children}</PointerContextProvider>;\n}\n\n/**\n * Attaches native `pointermove` / `pointerleave` listeners to the supplied\n * canvas element and publishes the world-space pointer coordinates into the\n * surrounding `<PointerContextProvider>`. Renders nothing. No-op when no\n * provider is in scope (matches \"publish if anyone is listening\").\n *\n * Lives inside the provider scope so it sees both consumer-mounted providers\n * and SceneCanvas's auto-mounted one.\n */\nexport function PointerPublisher({\n  canvasRef,\n}: {\n  canvasRef: MutableRefObject<HTMLElement | null>;\n}) {\n  const ctx = usePointerContext();\n  const registry = useOptionalViewRegistry();\n  useEffect(() => {\n    if (!ctx) return;\n    const el = canvasRef.current;\n    if (!el) return;\n    // The surface's one resolver answers which camera a client point belongs\n    // to, so paste-at-pointer lands in the panel the cursor is over. With no\n    // views declared it answers the canvas's own camera and rect.\n    const publish = (pointerId: number | null, clientX: number, clientY: number): void => {\n      const target = registry?.resolver.at(pointerId, clientX, clientY);\n      const rect = el.getBoundingClientRect();\n      const [worldX, worldY] = clientToWorld(\n        clientX, clientY,\n        target?.origin ?? rect,\n        target?.view ?? { x: 0, y: 0, scale: { x: 1, y: 1 } },\n      );\n      ctx.set({ worldX, worldY, viewId: target?.id ?? null });\n    };\n    const onMove = (e: PointerEvent): void => publish(e.pointerId, e.clientX, e.clientY);\n    const onLeave = (e: PointerEvent): void => {\n      // Don't clear coords mid-drag: any pointer button down means the user\n      // is still actively manipulating the canvas, and downstream consumers\n      // (resize/move/etc.) need the latest world position even when the\n      // cursor leaves the canvas rect. The `useGestureDispatcher`-side\n      // `setPointerCapture` keeps pointermove flowing in that case, so we\n      // get fresh values; this guard just prevents the leave event from\n      // racing in and nulling them between captured moves.\n      if (e.buttons !== 0) {\n        publish(e.pointerId, e.clientX, e.clientY);\n        return;\n      }\n      ctx.set(null);\n    };\n    // Document-level pointermove backstop so the HUD keeps updating when the\n    // pointer drifts off the canvas during a drag (pointer capture routes\n    // events back to the canvas, but the leave-window edge case is covered\n    // here too). Filter to events whose target isn't the canvas to avoid\n    // double-publishing.\n    const onDocMove = (e: PointerEvent): void => {\n      if (e.target === el) return;\n      // Only forward off-canvas moves during an active drag — idle hover\n      // outside the canvas shouldn't be reported as a canvas pointer position.\n      if (e.buttons === 0) return;\n      publish(e.pointerId, e.clientX, e.clientY);\n    };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    document.addEventListener('pointermove', onDocMove);\n    return () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n      document.removeEventListener('pointermove', onDocMove);\n    };\n    // canvasRef + registry + ctx identity are all stable across the lifetime\n    // of the surrounding provider; effect runs once per mount.\n  }, [ctx, canvasRef, registry]);\n  return null;\n}\n"],"mappings":";;;;;;AAeA,SAAgBC,EAAsB,EAAE,eAAqC;CAG3E,OAFeC,EACX,IAAe,kBAAAF,GAAA,EAAG,YAAW,CAAA,IAC1B,kBAACI,GAAD,EAAyB,YAAiC,CAAA;AACnE;AAWA,SAAgBC,EAAiB,EAC/B,gBAGC;CACD,IAAMC,IAAMJ,EAAkB,GACxBK,IAAWC,EAAwB;CAwDzC,OAvDAC,QAAgB;EACd,IAAI,CAACH,GAAK;EACV,IAAMI,IAAKC,EAAU;EACrB,IAAI,CAACD,GAAI;EAIT,IAAME,KAAW,GAA0B,GAAiB,MAA0B;GACpF,IAAMC,IAASN,GAAU,SAAS,GAAGO,GAAWC,GAASC,CAAO,GAC1DC,IAAOP,EAAG,sBAAsB,GAChC,CAACQ,GAAQC,KAAUC,EACvBL,GAASC,GACTH,GAAQ,UAAUI,GAClBJ,GAAQ,QAAQ;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;KAAE,GAAG;KAAG,GAAG;IAAE;GAAE,CACtD;GACA,EAAI,IAAI;IAAE;IAAQ;IAAQ,QAAQA,GAAQ,MAAM;GAAK,CAAC;EACxD,GACMQ,KAAU,MAA0BT,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,GAC7EU,KAAW,MAA0B;GAQzC,IAAI,EAAE,YAAY,GAAG;IACnB,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;IACzC;GACF;GACA,EAAI,IAAI,IAAI;EACd,GAMMC,KAAa,MAA0B;GAC3C,AAAI,EAAE,WAAWb,KAGb,EAAE,YAAY,KAClBE,EAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO;EAC3C;EAIA,OAHAF,EAAG,iBAAiB,eAAeW,CAAM,GACzCX,EAAG,iBAAiB,gBAAgBY,CAAO,GAC3C,SAAS,iBAAiB,eAAeC,CAAS,SACrC;GAGX,AAFAb,EAAG,oBAAoB,eAAeW,CAAM,GAC5CX,EAAG,oBAAoB,gBAAgBY,CAAO,GAC9C,SAAS,oBAAoB,eAAeC,CAAS;EACvD;CAGF,GAAG;EAACjB;EAAKK;EAAWJ;CAAQ,CAAC,GACtB;AACT"}

package/dist/canvas/SceneCanvas/contributionFrameHooks.js

@@ -0,0 +1,42 @@
+import { useEffect as e, useRef as t } from "react";
+import { useLatest as n } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/contributionFrameHooks.ts
+function r(e, t, n, r) {
+	for (let i of e) {
+		let e = i[t];
+		if (e) try {
+			e(n);
+		} catch (n) {
+			if (r.has(e)) continue;
+			r.add(e), console.error(`[weasel] contribution "${i.id}" threw from ${t}; the frame went on without it.`, n);
+		}
+	}
+}
+function i(i, a, o) {
+	let s = i.some((e) => e.beforePaint), c = i.some((e) => e.afterPaint), l = n(i), u = n(o), d = t(/* @__PURE__ */ new WeakSet()).current;
+	e(() => {
+		if (!a || !(s || c)) return;
+		let e = (e) => ({
+			time: e,
+			view: a.getView(),
+			requestFrame: a.requestRedraw,
+			deps: u.current
+		}), t = (t) => (n) => {
+			r(l.current, t, e(n), d);
+		}, n = s ? a.subscribeBeforePaint(t("beforePaint")) : void 0, i = c ? a.subscribeFrame(t("afterPaint")) : void 0;
+		return a.requestRedraw(), () => {
+			n?.(), i?.();
+		};
+	}, [
+		a,
+		s,
+		c,
+		l,
+		u,
+		d
+	]);
+}
+//#endregion
+export { r as runContributionFrameHooks, i as useContributionFrameHooks };
+
+//# sourceMappingURL=contributionFrameHooks.js.map

package/dist/canvas/SceneCanvas/contributionFrameHooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contributionFrameHooks.js","names":["runContributionFrameHooks","entry","entries","hook","phase","ctx","err","reported","useContributionFrameHooks","hasBefore","hasAfter","entriesRef","useLatest","depsRef","deps","useRef","api","ctxAt","run","time","offBefore","offAfter"],"sources":["../../../src/canvas/SceneCanvas/contributionFrameHooks.ts"],"sourcesContent":["/**\n * Runs contributions' `beforePaint` / `afterPaint` on the surface's own frame\n * loop. One subscription per phase serves every entry, and only while some\n * entry declares that phase — a surface with no hooks subscribes to nothing.\n */\nimport { useEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport type {\n  ContributionDepReader, ContributionFrameCtx, SurfaceContribution,\n} from '../surfaceContribution';\n\ntype Phase = 'beforePaint' | 'afterPaint';\n\n/**\n * Call every entry's `phase` hook in list order. A hook that throws is\n * reported through `console.error` the first time and skipped, so one broken\n * contribution costs its own work rather than the frame.\n */\nexport function runContributionFrameHooks(\n  entries: readonly SurfaceContribution[],\n  phase: Phase,\n  ctx: ContributionFrameCtx,\n  reported: WeakSet<object>,\n): void {\n  for (const entry of entries) {\n    const hook = entry[phase];\n    if (!hook) continue;\n    try {\n      hook(ctx);\n    } catch (err) {\n      if (reported.has(hook)) continue;\n      reported.add(hook);\n      console.error(`[weasel] contribution \"${entry.id}\" threw from ${phase}; the frame went on without it.`, err);\n    }\n  }\n}\n\nexport function useContributionFrameHooks(\n  entries: readonly SurfaceContribution[],\n  api: CanvasExtensionApi | null,\n  deps: ContributionDepReader,\n): void {\n  const hasBefore = entries.some((e) => e.beforePaint);\n  const hasAfter = entries.some((e) => e.afterPaint);\n  const entriesRef = useLatest(entries);\n  const depsRef = useLatest(deps);\n  const reported = useRef(new WeakSet<object>()).current;\n\n  useEffect(() => {\n    if (!api || !(hasBefore || hasAfter)) return;\n    const ctxAt = (time: number): ContributionFrameCtx => ({\n      time,\n      view: api.getView(),\n      requestFrame: api.requestRedraw,\n      deps: depsRef.current,\n    });\n    const run = (phase: Phase) => (time: number) => {\n      runContributionFrameHooks(entriesRef.current, phase, ctxAt(time), reported);\n    };\n    const offBefore = hasBefore ? api.subscribeBeforePaint(run('beforePaint')) : undefined;\n    const offAfter = hasAfter ? api.subscribeFrame(run('afterPaint')) : undefined;\n    // A hook arriving after the last paint would otherwise wait for an\n    // unrelated redraw to run for the first time.\n    api.requestRedraw();\n    return () => { offBefore?.(); offAfter?.(); };\n  }, [api, hasBefore, hasAfter, entriesRef, depsRef, reported]);\n}\n"],"mappings":";;;AAmBA,SAAgBA,EACd,GACA,GACA,GACA,GACM;CACN,KAAK,IAAMC,KAASC,GAAS;EAC3B,IAAMC,IAAOF,EAAMG;EACnB,IAAKD,GACL,IAAI;GACF,EAAKE,CAAG;EACV,SAASC,GAAK;GACZ,IAAIC,EAAS,IAAIJ,CAAI,GAAG;GAExB,AADAI,EAAS,IAAIJ,CAAI,GACjB,QAAQ,MAAM,0BAA0BF,EAAM,GAAG,eAAeG,EAAM,kCAAkCE,CAAG;EAC7G;CACF;AACF;AAEA,SAAgBE,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAYP,EAAQ,MAAM,MAAM,EAAE,WAAW,GAC7CQ,IAAWR,EAAQ,MAAM,MAAM,EAAE,UAAU,GAC3CS,IAAaC,EAAUV,CAAO,GAC9BW,IAAUD,EAAUE,CAAI,GACxBP,IAAWQ,kBAAO,IAAI,QAAgB,CAAC,CAAC,CAAC;CAE/C,QAAgB;EACd,IAAI,CAACC,KAAO,EAAEP,KAAaC,IAAW;EACtC,IAAMO,KAAS,OAAwC;GACrD;GACA,MAAMD,EAAI,QAAQ;GAClB,cAAcA,EAAI;GAClB,MAAMH,EAAQ;EAChB,IACMK,KAAO,OAAkB,MAAiB;GAC9C,EAA0BP,EAAW,SAASP,GAAOa,EAAME,CAAI,GAAGZ,CAAQ;EAC5E,GACMa,IAAYX,IAAYO,EAAI,qBAAqBE,EAAI,aAAa,CAAC,IAAI,KAAA,GACvEG,IAAWX,IAAWM,EAAI,eAAeE,EAAI,YAAY,CAAC,IAAI,KAAA;EAIpE,OADAF,EAAI,cAAc,SACL;GAAiB,AAAfI,IAAY,GAAGC,IAAW;EAAG;CAC9C,GAAG;EAACL;EAAKP;EAAWC;EAAUC;EAAYE;EAASN;CAAQ,CAAC;AAC9D"}

package/dist/canvas/SceneCanvas/defaultNodeProperties.js

@@ -0,0 +1,549 @@
+import { listMarkers as e } from "../../core/strokeMarkers.js";
+import { KIT_SHAPE_KINDS as t } from "../../core/shapeKinds.js";
+import { prefUnit as n } from "../../tools/prefs.js";
+import { inferredNodeRouting as r } from "./defaultNodeRouting.js";
+import { dashForStrokeStyle as i, strokeDashStyleOf as a } from "@weasel-js/paint";
+import { resolveAlign as o } from "@weasel-js/text";
+import { ANGLE_RADIANS as s } from "@weasel-js/quantity";
+//#region src/canvas/SceneCanvas/defaultNodeProperties.ts
+var c = n(s, "deg", {
+	precision: 1,
+	suffix: "°"
+});
+function l(e) {
+	let t = e?.width;
+	if (typeof t == "number" || typeof t == "object" && t && typeof t.px == "number") return t;
+}
+var u = {
+	read: (e, t) => t === void 0 ? void 0 : a(Array.isArray(e) ? e : void 0, l(t)),
+	write: (e, t) => e === "dashed" || e === "dotted" ? i(e, l(t)) : e === "solid" ? void 0 : t?.dash
+}, d = {
+	read: (e) => typeof e == "string" ? e : e && typeof e == "object" && "key" in e ? String(e.key) : "",
+	write: (e) => e === "" ? void 0 : e
+}, f = {
+	read: (e) => e === "italic",
+	write: (e) => e ? "italic" : void 0
+}, p = {
+	read: (e, t) => {
+		if (e === void 0 || e === "justify") return e;
+		let n = t?.direction === "rtl" ? "rtl" : "ltr";
+		return o(e, n);
+	},
+	write: (e) => e
+}, m = () => [{
+	value: "",
+	label: "None"
+}, ...e().map((e) => ({
+	value: e.id,
+	label: e.id
+}))];
+function h(e = {}) {
+	return {
+		name: "Properties",
+		children: {
+			layout: {
+				name: "Layout",
+				children: {
+					"pose.x": {
+						kind: "number",
+						name: "X",
+						description: "Left edge, world units.",
+						default: 0,
+						pair: "Position"
+					},
+					"pose.y": {
+						kind: "number",
+						name: "Y",
+						description: "Top edge, world units.",
+						default: 0,
+						pair: "Position"
+					},
+					"pose.width": {
+						kind: "number",
+						name: "W",
+						description: "Width, world units.",
+						default: 0,
+						min: 0,
+						pair: "Size"
+					},
+					"pose.height": {
+						kind: "number",
+						name: "H",
+						description: "Height, world units.",
+						default: 0,
+						min: 0,
+						pair: "Size"
+					},
+					"pose.rotation": {
+						kind: "number",
+						name: "Rotation",
+						description: "Rotation about the box center.",
+						default: 0,
+						step: 1,
+						unit: c
+					}
+				}
+			},
+			...e.text ? { content: {
+				name: "Content",
+				children: { "data.text": {
+					kind: "string",
+					name: "Text",
+					description: "Text content.",
+					default: "",
+					block: !0
+				} }
+			} } : {},
+			appearance: {
+				name: "",
+				children: {
+					"data.fill": {
+						kind: "paint",
+						name: "Fill",
+						description: "Fill paint.",
+						default: {
+							fill: "solid",
+							color: "#000000ff"
+						},
+						alpha: !0,
+						block: !0
+					},
+					"data.stroke": {
+						kind: "object",
+						name: "Stroke",
+						description: "Stroke paint and line geometry.",
+						default: {
+							paint: {
+								fill: "solid",
+								color: "#000000ff"
+							},
+							width: 1
+						},
+						block: !0,
+						children: {
+							width: {
+								kind: "number",
+								name: "Width",
+								description: "Stroke width, world units.",
+								default: 1,
+								min: 0,
+								max: 20,
+								step: .5,
+								control: "slider",
+								icon: "strokeWidth",
+								block: !0
+							},
+							paint: {
+								kind: "paint",
+								name: "Paint",
+								description: "Stroke paint.",
+								default: {
+									fill: "solid",
+									color: "#000000ff"
+								},
+								alpha: !0,
+								block: !0
+							},
+							cap: {
+								kind: "enum",
+								name: "Cap",
+								description: "How an open end is drawn.",
+								default: "butt",
+								control: "toggle",
+								block: !0,
+								pair: "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.",
+								default: "miter",
+								control: "toggle",
+								block: !0,
+								pair: "Line",
+								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.",
+								default: "center",
+								control: "toggle",
+								block: !0,
+								pair: "Line",
+								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: u,
+								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: {
+								kind: "enum",
+								name: "Start",
+								description: "Marker at the first vertex of each open subpath.",
+								default: "",
+								control: "select",
+								block: !0,
+								pair: "Markers",
+								encoding: d,
+								options: m()
+							},
+							markerMid: {
+								kind: "enum",
+								name: "Mid",
+								description: "Marker at every interior authored vertex.",
+								default: "",
+								control: "select",
+								block: !0,
+								pair: "Markers",
+								encoding: d,
+								options: m()
+							},
+							markerEnd: {
+								kind: "enum",
+								name: "End",
+								description: "Marker at the last vertex of each open subpath.",
+								default: "",
+								control: "select",
+								block: !0,
+								pair: "Markers",
+								encoding: d,
+								options: m()
+							}
+						}
+					}
+				}
+			},
+			...e.text ? { text: {
+				name: "",
+				children: {
+					"data.style": {
+						kind: "object",
+						name: "Style",
+						description: "Typography for the whole node. Its color is the node's own `data.fill`, in Appearance.",
+						default: {},
+						block: !0,
+						children: {
+							character: {
+								name: "Character",
+								children: {
+									fontFamily: {
+										kind: "font-family",
+										name: "Font",
+										description: "Registered font family.",
+										default: "sans-serif"
+									},
+									fontSize: {
+										kind: "number",
+										name: "Size",
+										description: "Font size, world units.",
+										default: 16,
+										min: 1,
+										step: 1,
+										pair: "Size / weight"
+									},
+									fontWeight: {
+										kind: "font-weight",
+										name: "Weight",
+										description: "Font weight, from the faces the family has.",
+										default: 400,
+										pair: "Size / weight"
+									},
+									fontStyle: {
+										kind: "boolean",
+										name: "Italic",
+										description: "Set the text in its italic face.",
+										default: !1,
+										control: "toggle",
+										icon: "italic",
+										short: "I",
+										pair: "Style",
+										encoding: f
+									},
+									underline: {
+										kind: "boolean",
+										name: "Underline",
+										description: "Underline the text.",
+										default: !1,
+										control: "toggle",
+										icon: "underline",
+										short: "U",
+										pair: "Style"
+									},
+									strikethrough: {
+										kind: "boolean",
+										name: "Strikethrough",
+										description: "Strike through the text.",
+										default: !1,
+										control: "toggle",
+										icon: "strikethrough",
+										short: "S",
+										pair: "Style"
+									},
+									overline: {
+										kind: "boolean",
+										name: "Overline",
+										description: "Rule the text above its ascent.",
+										default: !1,
+										control: "toggle",
+										icon: "overline",
+										short: "O",
+										pair: "Style"
+									},
+									script: {
+										kind: "enum",
+										name: "Script",
+										description: "Set the text smaller and raised or lowered, on the line it would otherwise hold.",
+										default: void 0,
+										control: "toggle",
+										clearable: !0,
+										pair: "Style",
+										options: [{
+											value: "super",
+											label: "Superscript",
+											icon: "superscript"
+										}, {
+											value: "sub",
+											label: "Subscript",
+											icon: "subscript"
+										}]
+									},
+									letterSpacing: {
+										kind: "number",
+										name: "Tracking",
+										description: "Extra advance per glyph, world units.",
+										default: 0,
+										step: .1
+									},
+									textTransform: {
+										kind: "enum",
+										name: "Case",
+										description: "Draw the text in capitals, lowercase or title case. The text itself is unchanged.",
+										default: "none",
+										control: "toggle",
+										options: [
+											{
+												value: "none",
+												label: "None",
+												short: "–"
+											},
+											{
+												value: "uppercase",
+												label: "Uppercase",
+												short: "AA"
+											},
+											{
+												value: "lowercase",
+												label: "Lowercase",
+												short: "aa"
+											},
+											{
+												value: "capitalize",
+												label: "Capitalize",
+												short: "Aa"
+											}
+										]
+									},
+									fontVariantCaps: {
+										kind: "enum",
+										name: "Small caps",
+										description: "Draw lowercase letters as smaller capitals. The text itself is unchanged.",
+										default: "normal",
+										control: "toggle",
+										options: [{
+											value: "normal",
+											label: "Normal",
+											short: "–"
+										}, {
+											value: "small-caps",
+											label: "Small caps",
+											short: "Sc"
+										}]
+									}
+								}
+							},
+							paragraph: {
+								name: "Paragraph",
+								children: {
+									lineHeight: {
+										kind: "number",
+										name: "Leading",
+										description: "Line height as a multiple of font size.",
+										default: 1.2,
+										min: .5,
+										step: .1
+									},
+									wrap: {
+										kind: "boolean",
+										name: "Wrap",
+										description: "Break lines between words at the box width.",
+										default: !1,
+										control: "switch"
+									},
+									direction: {
+										kind: "enum",
+										name: "Direction",
+										description: "Reading direction.",
+										default: "ltr",
+										control: "toggle",
+										options: [{
+											value: "ltr",
+											label: "Left to right",
+											short: "LTR"
+										}, {
+											value: "rtl",
+											label: "Right to left",
+											short: "RTL"
+										}]
+									},
+									align: {
+										kind: "enum",
+										name: "Align",
+										description: "Horizontal alignment.",
+										default: "left",
+										control: "toggle",
+										encoding: p,
+										options: [
+											{
+												value: "left",
+												label: "Left",
+												icon: "textAlignLeft"
+											},
+											{
+												value: "center",
+												label: "Center",
+												icon: "textAlignCenter"
+											},
+											{
+												value: "right",
+												label: "Right",
+												icon: "textAlignRight"
+											},
+											{
+												value: "justify",
+												label: "Justify",
+												icon: "textAlignJustify"
+											}
+										]
+									}
+								}
+							}
+						}
+					},
+					"data.verticalAlign": {
+						kind: "enum",
+						name: "Vertical",
+						description: "Where the lines sit in the box's height.",
+						default: "top",
+						control: "toggle",
+						options: [
+							{
+								value: "top",
+								label: "Top",
+								icon: "textAlignTop"
+							},
+							{
+								value: "center",
+								label: "Middle",
+								icon: "textAlignMiddle"
+							},
+							{
+								value: "bottom",
+								label: "Bottom",
+								icon: "textAlignBottom"
+							}
+						]
+					}
+				}
+			} } : {}
+		}
+	};
+}
+var g = t.map((e) => ({
+	name: e,
+	schema: h({ text: e === "text" })
+})), _ = r.map((e) => ({
+	name: e.name,
+	schema: h({ text: e.name === "text" })
+}));
+//#endregion
+export { g as defaultNodeProperties, _ as inferredNodeProperties, c as rotationDegreesUnit };
+
+//# sourceMappingURL=defaultNodeProperties.js.map