@weasel-js/core 1.9.3 → 1.10.0

package/dist/interactions/actions/move/session.js

@@ -0,0 +1,63 @@
+import { commitGestureOps as e, readGestureLifecycle as t } from "../gestureLifecycle.js";
+import { gestureReaders as n } from "../../gestures/shared/screenTolerance.js";
+import { nodeDescriptors as r, poseDescriptorOf as i } from "../poseDescriptorDep.js";
+import { moveSources as a } from "../selectionSubtree.js";
+import { layoutDrop as o } from "./behaviors/layoutDrop.js";
+import { reparentOnDrop as s } from "./behaviors/reparentOnDrop.js";
+import { buildGestureContext as c, captureFrames as l, capturePlaneRefs as u, captureStartPoses as d } from "./capture.js";
+import { moveGestureAdapter as f } from "./gestureAdapter.js";
+import { DRAG_THRESHOLD_PX as p, isAnchorOrControl as m, resolveParams as h } from "@weasel-js/routing";
+//#region src/interactions/actions/move/session.ts
+function g(g, _, v) {
+	let y = g.deps.selection, b = g.deps.scene, x = i(g.deps.poseDescriptor), S = g.deps.layout, C = g.deps.applyOps, w = g.deps.geometryProjection;
+	if (!y || !b) return null;
+	let T = b.composition;
+	if (m(g.drag?.affordance)) return null;
+	let E = h(_?.params), D = E?.expandIds, O = [...y.get()], k = a(b, D ? D(O) : O);
+	if (k.length === 0) return null;
+	let A = S?.reflow ?? null, { startPoses: j, cascadeIds: M, caught: N } = d(b, k, A, x), { carried: P, frames: F } = l(b, k, j), I = {
+		session: () => U,
+		frame: v
+	}, L = [
+		..._?.behaviors ?? [],
+		...S ? [o(I)] : [],
+		s(I)
+	], R = E?.dragThresholdPx ?? p, z = t(E, "Move", L), B = f(b, (t, n, r) => e({
+		scene: b,
+		applyOps: C,
+		adapter: r
+	}, z, t), y.adapterMethods), V = n(g.deps), H = c(g, b, k, j, B, V);
+	for (let e of L) e.onStart?.(H);
+	let U = {
+		startPoses: j,
+		ids: k,
+		cascadeIds: M,
+		carried: P,
+		frames: F,
+		scene: b,
+		view: g.deps.view,
+		planeRefs: u(b, k, g.deps.view, F, j, x),
+		caught: N,
+		projection: x,
+		descriptorOf: r(b, x),
+		behaviors: L,
+		gestureCtx: H,
+		adapter: B,
+		layout: S,
+		pc: T,
+		applyOps: C,
+		geometryProjection: w,
+		lifecycle: z,
+		nodeAtPoint: g.deps.nodeAtPoint,
+		reparentOnDrop: () => h(_?.params)?.reparentOnDrop ?? "off",
+		dragThresholdPx: R
+	};
+	return {
+		session: U,
+		readers: V
+	};
+}
+//#endregion
+export { g as beginMove };
+
+//# sourceMappingURL=session.js.map

package/dist/interactions/actions/move/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["beginMove","selection","ctx","scene","projection","poseDescriptorOf","layout","applyOps","geometryProjection","pc","isAnchorOrControl","params","resolveParams","opts","expandIds","\"expandIds\"","selected","ids","moveSources","reflow","captureStartPoses","captureFrames","startPoses","gesture","session","behaviors","layoutDrop","reparentOnDrop","dragThresholdPx","\"dragThresholdPx\"","DRAG_THRESHOLD_PX","lifecycle","readGestureLifecycle","adapter","moveGestureAdapter","commitGestureOps","through","ops","readers","gestureReaders","gestureCtx","buildGestureContext","b","capturePlaneRefs","frames","nodeDescriptors","\"reparentOnDrop\""],"sources":["../../../../src/interactions/actions/move/session.ts"],"sourcesContent":["import type { BindingOpts, InvocationCtx } from '@weasel-js/routing';\nimport { DRAG_THRESHOLD_PX, isAnchorOrControl, resolveParams } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { PoseComposition } from 'core/scene/composePose';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, MoveBehavior } from '../../gestures/types';\nimport type { LayoutDep, NodeAtPointDep } from '../depSchema';\nimport type { GeometryProjection } from '../geometryProjection';\nimport { commitGestureOps, readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { moveSources } from '../selectionSubtree';\nimport { layoutDrop } from './behaviors/layoutDrop';\nimport { reparentOnDrop } from './behaviors/reparentOnDrop';\nimport { buildGestureContext, captureFrames, capturePlaneRefs, captureStartPoses } from './capture';\nimport { moveGestureAdapter, type MoveGestureAdapter } from './gestureAdapter';\n\n/** Allowed values for the `reparentOnDrop` binding param. `'off'` (the\n *  default) preserves the legacy translate-only commit. `'top'` lands the\n *  moved node at the top of the container under the cursor. `'above'`\n *  lands it immediately above the hit sibling in z-order (falls back to\n *  `'top'` semantics when the hit is itself a container or when the hit\n *  and moved node share no parent). */\nexport type ReparentOnDrop = 'off' | 'top' | 'above';\n\n/** What a move captured at press. Nothing here changes during the drag. */\nexport interface MoveSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  /** The drag roots. */\n  readonly ids: readonly NodeId[];\n  /** Descendants of the roots, previewed along with them. */\n  readonly cascadeIds: readonly NodeId[];\n  /** Start pose of every root and descendant. */\n  readonly startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Ids whose frame is itself moving, so they ride it and are not translated. */\n  readonly carried: ReadonlySet<NodeId>;\n  /** For each moved id stored under a frame: its world pose and the frame's, at press. */\n  readonly frames: ReadonlyMap<NodeId, { world: unknown; frameWorld: unknown }>;\n  /** Ids grabbed mid-glide, with how far the pose shown stood from the document's. */\n  readonly caught: ReadonlyMap<NodeId, { dx: number; dy: number }>;\n  /** Per layer on another plane than the edited one: a point of its first root, in both. */\n  readonly planeRefs: ReadonlyMap<string, { own: { x: number; y: number }; edited: { x: number; y: number } }>;\n  readonly view: unknown;\n  readonly projection: PoseDescriptor<unknown>;\n  readonly descriptorOf: (id: NodeId | string) => PoseDescriptor<unknown>;\n  readonly pc: PoseComposition<unknown>;\n  /** The binding's behaviors, then the ones the action adds: a layout drop\n   *  when the `layout` dep is present, and reparent-on-drop. */\n  readonly behaviors: readonly MoveBehavior<unknown>[];\n  /** Reused across the drag; behaviors mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<unknown>;\n  readonly adapter: MoveGestureAdapter<unknown>;\n  readonly layout: LayoutDep | undefined;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  readonly geometryProjection?: GeometryProjection;\n  readonly lifecycle: GestureLifecycle;\n  readonly nodeAtPoint: NodeAtPointDep | undefined;\n  /** Read at release: a binding's params may be a thunk. */\n  readonly reparentOnDrop: () => ReparentOnDrop;\n  readonly dragThresholdPx: number;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface MoveFrame {\n  readonly delta: { dx: number; dy: number };\n  /** Stored-frame pose of every displaced id, roots and descendants, and of\n   *  any other id a behavior posed. */\n  readonly previews: Map<NodeId, unknown>;\n  /** Ids the behaviors asked to have painted at full opacity. */\n  readonly opaque: ReadonlySet<NodeId>;\n}\n\n/** What the behaviors the action builds itself read of the drag they belong\n *  to. Neither is readable from `onStart`, which runs before the session\n *  exists. */\nexport interface MoveGesture {\n  session(): MoveSession;\n  /** The latest frame: the previous one while an `onMove` is running. */\n  frame(): MoveFrame;\n}\n\n/** Capture a drag at press. Null when there is nothing to move. Runs each\n *  behavior's `onStart`. `frame` reads the drag's latest frame, for the\n *  behaviors appended to the binding's own. */\nexport function beginMove(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n  frame: () => MoveFrame,\n): { session: MoveSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  const projection = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const layout = ctx.deps.layout;\n  const applyOps = ctx.deps.applyOps;\n  const geometryProjection = ctx.deps.geometryProjection;\n\n  if (!selection || !scene) return null;\n  const pc = scene.composition;\n  // Anchors sit on the selected body, and this binding ties editAnchors' on\n  // specificity; with no mode registry to filter move out, declining is what lets it through.\n  if (isAnchorOrControl(ctx.drag?.affordance)) return null;\n\n  const params = resolveParams(opts?.params);\n  const expandIds = params?.['expandIds'] as ((ids: string[]) => string[]) | undefined;\n  const selected = [...selection.get()] as string[];\n  const ids = moveSources(scene, expandIds ? expandIds(selected) : selected) as NodeId[];\n  if (ids.length === 0) return null;\n\n  const reflow = layout?.reflow ?? null;\n  const { startPoses, cascadeIds, caught } = captureStartPoses(scene, ids, reflow, projection);\n  const { carried, frames } = captureFrames(scene, ids, startPoses);\n\n  // Everything a move does beyond translating is a behavior: the binding's\n  // own, then the layout drop, then reparent-on-drop. On release the first to\n  // answer owns the commit, so each preempts the ones after it.\n  const gesture: MoveGesture = { session: () => session, frame };\n  const behaviors: MoveBehavior<unknown>[] = [\n    ...((opts?.behaviors ?? []) as MoveBehavior<unknown>[]),\n    ...(layout ? [layoutDrop(gesture)] : []),\n    reparentOnDrop(gesture),\n  ];\n  const dragThresholdPx = (params?.['dragThresholdPx'] as number | undefined)\n    ?? DRAG_THRESHOLD_PX;\n  const lifecycle = readGestureLifecycle(params, 'Move', behaviors);\n  // A behavior that commits after the gesture has ended, a coast coming to\n  // rest, lands its batch the way the gesture's own commit does.\n  const adapter = moveGestureAdapter<unknown>(scene, (ops, _label, through) =>\n    commitGestureOps({ scene, applyOps, adapter: through }, lifecycle, ops), selection.adapterMethods);\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, scene, ids, startPoses, adapter, readers);\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n\n  const session: MoveSession = {\n    startPoses,\n    ids,\n    cascadeIds,\n    carried,\n    frames,\n    scene,\n    view: ctx.deps.view,\n    planeRefs: capturePlaneRefs(scene, ids, ctx.deps.view, frames, startPoses, projection),\n    caught,\n    projection,\n    descriptorOf: nodeDescriptors(scene, projection),\n    behaviors,\n    gestureCtx,\n    adapter,\n    layout,\n    pc,\n    applyOps,\n    geometryProjection,\n    lifecycle,\n    nodeAtPoint: ctx.deps.nodeAtPoint,\n    reparentOnDrop: () => (resolveParams(opts?.params)?.['reparentOnDrop'] as ReparentOnDrop | undefined) ?? 'off',\n    dragThresholdPx,\n  };\n  return { session, readers };\n}\n"],"mappings":";;;;;;;;;;AAqFA,SAAgBA,EACd,GACA,GACA,GAC0D;CAC1D,IAAMC,IAAYC,EAAI,KAAK,WACrBC,IAAQD,EAAI,KAAK,OACjBE,IAAaC,EAAiBH,EAAI,KAAK,cAAc,GACrDI,IAASJ,EAAI,KAAK,QAClBK,IAAWL,EAAI,KAAK,UACpBM,IAAqBN,EAAI,KAAK;CAEpC,IAAI,CAACD,KAAa,CAACE,GAAO,OAAO;CACjC,IAAMM,IAAKN,EAAM;CAGjB,IAAIO,EAAkBR,EAAI,MAAM,UAAU,GAAG,OAAO;CAEpD,IAAMS,IAASC,EAAcC,GAAM,MAAM,GACnCC,IAAYH,GAASI,WACrBC,IAAW,CAAC,GAAGf,EAAU,IAAI,CAAC,GAC9BgB,IAAMC,EAAYf,GAAOW,IAAYA,EAAUE,CAAQ,IAAIA,CAAQ;CACzE,IAAIC,EAAI,WAAW,GAAG,OAAO;CAE7B,IAAME,IAASb,GAAQ,UAAU,MAC3B,EAAE,eAAY,eAAY,cAAWc,EAAkBjB,GAAOc,GAAKE,GAAQf,CAAU,GACrF,EAAE,YAAS,cAAWiB,EAAclB,GAAOc,GAAKK,CAAU,GAK1DC,IAAuB;EAAE,eAAeC;EAAS;CAAM,GACvDC,IAAqC;EACzC,GAAKZ,GAAM,aAAa,CAAC;EACzB,GAAIP,IAAS,CAACoB,EAAWH,CAAO,CAAC,IAAI,CAAC;EACtCI,EAAeJ,CAAO;CACxB,GACMK,IAAmBjB,GAASkB,mBAC7BC,GACCC,IAAYC,EAAqBrB,GAAQ,QAAQc,CAAS,GAG1DQ,IAAUC,EAA4B/B,IAAQ,GAAK,GAAQ,MAC/DgC,EAAiB;EAAE;EAAO;EAAU,SAASC;CAAQ,GAAGL,GAAWM,CAAG,GAAGpC,EAAU,cAAc,GAC7FqC,IAAUC,EAAerC,EAAI,IAAI,GACjCsC,IAAaC,EAAoBvC,GAAKC,GAAOc,GAAKK,GAAYW,GAASK,CAAO;CACpF,KAAK,IAAMI,KAAKjB,GAAW,EAAE,UAAUe,CAAU;CAEjD,IAAMhB,IAAuB;EAC3B;EACA;EACA;EACA;EACA;EACA;EACA,MAAMtB,EAAI,KAAK;EACf,WAAWyC,EAAiBxC,GAAOc,GAAKf,EAAI,KAAK,MAAM0C,GAAQtB,GAAYlB,CAAU;EACrF;EACA;EACA,cAAcyC,EAAgB1C,GAAOC,CAAU;EAC/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAaF,EAAI,KAAK;EACtB,sBAAuBU,EAAcC,GAAM,MAAM,CAAC,EAAGiC,kBAAoD;EACzG;CACF;CACA,OAAO;EAAE;EAAS;CAAQ;AAC5B"}

package/dist/interactions/actions/move/translate.js

@@ -0,0 +1,61 @@
+import { translatePoseViaDescriptor as e } from "../../../core/geometry/poseDescriptor.js";
+import { createTransformOp as t } from "../../../core/ops/transform.js";
+import { localDelta as n } from "./delta.js";
+import { geometryDataOp as r } from "../geometryProjection.js";
+//#region src/interactions/actions/move/translate.ts
+function i(i, a, o) {
+	let s = [];
+	for (let c of a) {
+		if (!i.startPoses.has(c) || i.carried.has(c)) continue;
+		let a = i.scene.get(c);
+		if (!a) continue;
+		let l = n(i, c, o.dx, o.dy), u = i.caught.get(c);
+		u && (l.dx += u.dx, l.dy += u.dy);
+		let d = [
+			1,
+			0,
+			0,
+			1,
+			l.dx,
+			l.dy
+		], f = a.pose;
+		if (s.push(t({
+			id: c,
+			from: f,
+			to: e(f, l.dx, l.dy, i.descriptorOf(c)),
+			label: i.lifecycle.label
+		})), i.geometryProjection) {
+			let e = r(i.geometryProjection, {
+				id: c,
+				data: a.data,
+				pose: f
+			}, d, i.lifecycle.label);
+			e && s.push(e);
+		}
+	}
+	return s;
+}
+function a(e, t, n) {
+	let r = new Set(t);
+	return i(e, o(e, new Set(e.ids.filter((e) => !r.has(e)))), n);
+}
+function o(e, t) {
+	let n = new Set(e.ids), r = e.ids.filter((e) => !t.has(e));
+	for (let i of e.cascadeIds) {
+		let a = e.scene.get(i)?.parent ?? null, o = !1;
+		for (; a;) {
+			if (t.has(a)) {
+				o = !0;
+				break;
+			}
+			if (n.has(a)) break;
+			a = e.scene.get(a)?.parent ?? null;
+		}
+		o || r.push(i);
+	}
+	return r;
+}
+//#endregion
+export { a as rootTranslateOps, i as translateOps, o as unreleasedIds };
+
+//# sourceMappingURL=translate.js.map

package/dist/interactions/actions/move/translate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.js","names":["translateOps","ops","id","ids","session","node","localDelta","delta","c","m","authored","createTransformOp","translatePoseViaDescriptor","dataOp","geometryDataOp","rootTranslateOps","wanted","roots","unreleasedIds","selected","out","released","cur","claimed"],"sources":["../../../../src/interactions/actions/move/translate.ts"],"sourcesContent":["import type { Mat3 } from '@weasel-js/geom';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { geometryDataOp } from '../geometryProjection';\nimport { localDelta } from './delta';\nimport type { MoveSession } from './session';\n\n/** The default translate commit: one transform op per id, plus the data-held\n *  geometry op when the `geometryProjection` seam is wired. */\nexport function translateOps(session: MoveSession, ids: Iterable<NodeId>, delta: { dx: number; dy: number }): Op[] {\n  const ops: Op[] = [];\n  for (const id of ids) {\n    if (!session.startPoses.has(id) || session.carried.has(id)) continue;\n    const node = session.scene.get(id);\n    if (!node) continue;\n    const l = localDelta(session, id, delta.dx, delta.dy);\n    const c = session.caught.get(id);\n    if (c) { l.dx += c.dx; l.dy += c.dy; }\n    const m: Mat3 = [1, 0, 0, 1, l.dx, l.dy];\n    // The authored pose, not the captured one: a derived node's captured pose\n    // is its derivation, and writing that back would lose the placeholder undo\n    // restores.\n    const authored = node.pose;\n    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from: authored,\n      to: translatePoseViaDescriptor(authored, l.dx, l.dy, session.descriptorOf(id)),\n      label: session.lifecycle.label,\n    }));\n    if (session.geometryProjection) {\n      const dataOp = geometryDataOp(\n        session.geometryProjection,\n        { id: id as string, data: node.data, pose: authored },\n        m,\n        session.lifecycle.label,\n      );\n      if (dataOp) ops.push(dataOp);\n    }\n  }\n  return ops;\n}\n\n/** The default translate commit for the dragged roots among `roots` and the\n *  descendants that follow them. Anything else in `roots` is ignored. */\nexport function rootTranslateOps(session: MoveSession, roots: Iterable<string>, delta: { dx: number; dy: number }): Op[] {\n  const wanted = new Set<string>(roots);\n  const others = new Set<NodeId>(session.ids.filter((id) => !wanted.has(id)));\n  return translateOps(session, unreleasedIds(session, others), delta);\n}\n\n/** Selected roots no source layout claimed on release, plus the descendants\n *  that follow them — the part of the selection the translate commit owns. */\nexport function unreleasedIds(session: MoveSession, released: Set<NodeId>): NodeId[] {\n  const selected = new Set<NodeId>(session.ids);\n  const out: NodeId[] = session.ids.filter((id) => !released.has(id));\n  for (const id of session.cascadeIds) {\n    let cur = session.scene.get(id)?.parent ?? null;\n    let claimed = false;\n    while (cur) {\n      if (released.has(cur)) { claimed = true; break; }\n      if (selected.has(cur)) break;\n      cur = session.scene.get(cur)?.parent ?? null;\n    }\n    if (!claimed) out.push(id);\n  }\n  return out;\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EAAa,GAAsB,GAAuB,GAAyC;CACjH,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAMC,GAAK;EACpB,IAAI,CAACC,EAAQ,WAAW,IAAIF,CAAE,KAAKE,EAAQ,QAAQ,IAAIF,CAAE,GAAG;EAC5D,IAAMG,IAAOD,EAAQ,MAAM,IAAIF,CAAE;EACjC,IAAI,CAACG,GAAM;EACX,IAAM,IAAIC,EAAWF,GAASF,GAAIK,EAAM,IAAIA,EAAM,EAAE,GAC9CC,IAAIJ,EAAQ,OAAO,IAAIF,CAAE;EAC/B,AAAIM,MAAK,EAAE,MAAMA,EAAE,IAAI,EAAE,MAAMA,EAAE;EACjC,IAAMC,IAAU;GAAC;GAAG;GAAG;GAAG;GAAG,EAAE;GAAI,EAAE;EAAE,GAIjCC,IAAWL,EAAK;EAOtB,IANAJ,EAAI,KAAKU,EAA2B;GAC9B;GACJ,MAAMD;GACN,IAAIE,EAA2BF,GAAU,EAAE,IAAI,EAAE,IAAIN,EAAQ,aAAaF,CAAE,CAAC;GAC7E,OAAOE,EAAQ,UAAU;EAC3B,CAAC,CAAC,GACEA,EAAQ,oBAAoB;GAC9B,IAAMS,IAASC,EACbV,EAAQ,oBACR;IAAM;IAAc,MAAMC,EAAK;IAAM,MAAMK;GAAS,GACpDD,GACAL,EAAQ,UAAU,KACpB;GACA,AAAIS,KAAQZ,EAAI,KAAKY,CAAM;EAC7B;CACF;CACA,OAAOZ;AACT;AAIA,SAAgBc,EAAiB,GAAsB,GAAyB,GAAyC;CACvH,IAAMC,IAAS,IAAI,IAAYC,CAAK;CAEpC,OAAOjB,EAAaI,GAASc,EAAcd,GAAS,IADjC,IAAYA,EAAQ,IAAI,QAAQ,MAAO,CAACY,EAAO,IAAId,CAAE,CAAC,CACrB,CAAM,GAAGK,CAAK;AACpE;AAIA,SAAgBW,EAAc,GAAsB,GAAiC;CACnF,IAAMC,IAAW,IAAI,IAAYf,EAAQ,GAAG,GACtCgB,IAAgBhB,EAAQ,IAAI,QAAQ,MAAO,CAACiB,EAAS,IAAInB,CAAE,CAAC;CAClE,KAAK,IAAMA,KAAME,EAAQ,YAAY;EACnC,IAAIkB,IAAMlB,EAAQ,MAAM,IAAIF,CAAE,CAAC,EAAE,UAAU,MACvCqB,IAAU;EACd,OAAOD,IAAK;GACV,IAAID,EAAS,IAAIC,CAAG,GAAG;IAAE,IAAU;IAAM;GAAO;GAChD,IAAIH,EAAS,IAAIG,CAAG,GAAG;GACvB,IAAMlB,EAAQ,MAAM,IAAIkB,CAAG,CAAC,EAAE,UAAU;EAC1C;EACA,AAAKC,KAASH,EAAI,KAAKlB,CAAE;CAC3B;CACA,OAAOkB;AACT"}

package/dist/interactions/actions/outlines/createOutlines.js

@@ -1,84 +1,37 @@
-import { locateChild as e } from "../../../core/ops/slot.js";
-import { unionBounds as t } from "../../../core/geometry/unionBounds.js";
-import { createDeleteOp as n } from "../../../core/ops/delete.js";
-import { createInsertOp as r } from "../../../core/ops/create.js";
-import { dispatchApplyBatch as i } from "../../../core/applyOps.js";
-import { createSetSelectionOp as a } from "../../../core/ops/select.js";
-import { TextOutlinesError as o, textToPathsByPaint as s } from "../../../features/text/textToPath.js";
-import { boundsOfPath as c } from "@weasel-js/geom";
+import { replaceWithPaths as e } from "./replaceWithPaths.js";
+import { TextOutlinesError as t, textToPathsByPaint as n } from "@weasel-js/text";
 //#region src/interactions/actions/outlines/createOutlines.ts
-function l(t) {
-	let c = [...t.getSelection()], l = [];
+function r(r) {
+	let i = [...r.getSelection()], a = [];
 	try {
-		for (let e of c) {
-			let n = t.getTextSource(e);
-			if (!n) continue;
-			let r = s(n.data, n.pose);
-			r.length > 0 && l.push({
+		for (let e of i) {
+			let t = r.getTextSource(e);
+			if (!t) continue;
+			let i = n(t.data, t.pose);
+			i.length > 0 && a.push({
 				id: e,
-				paths: r
+				paths: i
 			});
 		}
 	} catch (e) {
-		if (e instanceof o) return {
+		if (e instanceof t) return {
 			kind: "failed",
 			reason: "text-outlines",
 			error: e
 		};
 		throw e;
 	}
-	if (l.length === 0) return {
+	if (a.length === 0) return {
 		kind: "noop",
 		reason: "no-text"
 	};
-	let f = [], p = /* @__PURE__ */ new Map(), m = [...l.map((n) => ({
-		...n,
-		at: e(t, n.id)
-	}))].sort((e, t) => (t.at?.index ?? -1) - (e.at?.index ?? -1));
-	for (let { id: e, paths: i, at: a } of m) {
-		let o = t.getNode?.(e) ?? { id: e }, s = a?.index ?? -1, c = a?.parentId ?? t.getParent?.(e) ?? null, l = (e, t) => r(s >= 0 ? {
-			node: e,
-			index: s + t
-		} : { node: e });
-		f.push(n({
-			node: o,
-			index: s
-		}));
-		let m = i.length > 1 ? t.createContainerNode?.(e, {
-			parent: c,
-			bounds: d(i)
-		}) : void 0;
-		if (m) {
-			f.push(l(m, 0));
-			for (let n of i) f.push(r({ node: t.createPathNode(n.path, e, u(n, m.id)) }));
-			p.set(e, [m.id]);
-		} else {
-			let n = i.map((n) => t.createPathNode(n.path, e, u(n, c)));
-			n.forEach((e, t) => f.push(l(e, t))), p.set(e, n.map((e) => e.id));
-		}
-	}
-	return f.push(a({
-		from: c,
-		to: c.flatMap((e) => p.get(e) ?? [e])
-	})), i(t, f, "Create Outlines"), {
+	let o = e(r, i, a, "Create Outlines");
+	return {
 		kind: "applied",
-		resultIds: l.flatMap((e) => p.get(e.id))
+		resultIds: a.flatMap((e) => o.get(e.id))
 	};
 }
-function u(e, t) {
-	return e.stroke === void 0 ? {
-		fill: e.fill,
-		parent: t
-	} : {
-		fill: e.fill,
-		stroke: e.stroke,
-		parent: t
-	};
-}
-function d(e) {
-	return t(e.map((e) => c(e.path)));
-}
 //#endregion
-export { l as applyCreateOutlines };
+export { r as applyCreateOutlines };
 
 //# sourceMappingURL=createOutlines.js.map

package/dist/interactions/actions/outlines/createOutlines.js.map

@@ -1 +1 @@
-{"version":3,"file":"createOutlines.js","names":["applyCreateOutlines","sel","adapter","converted","id","text","paths","textToPathsByPaint","err","TextOutlinesError","ops","replaced","order","c","locateChild","b","a","node","index","at","parent","place","createInsertOp","created","i","createDeleteOp","container","envelope","p","specOf","n","createSetSelectionOp","dispatchApplyBatch","unionBounds","boundsOfPath"],"sources":["../../../../src/interactions/actions/outlines/createOutlines.ts"],"sourcesContent":["/**\n * Create Outlines: replace each selected text node with path nodes carrying\n * its glyph outlines, giving up editability for geometry — the destructive\n * conversion every vector editor has. One path per paint the text wears; one\n * undoable batch; the replacement takes the text node's slot, so stacking\n * order is unchanged.\n */\nimport { boundsOfPath, type PolygonPath, type Rect } from '@weasel-js/geom';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport { locateChild } from 'core/ops/slot';\nimport { unionBounds } from 'core/geometry/unionBounds';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport {\n  textToPathsByPaint, TextOutlinesError, type TextNodeSource, type TextPaintPath,\n} from 'features/text/textToPath';\n\n/** What a path minted by Create Outlines must carry — see\n *  {@link CreateOutlinesAdapter.createPathNode}. */\nexport interface OutlinePathSpec {\n  /** The fill these glyphs wear, resolved: their run's, else the node's,\n   *  else the default text fill. `null` is no fill. */\n  fill: FillStyle | null;\n  /** The stroke they wear, resolved the same way; absent for none. */\n  stroke?: Stroke;\n  /** The parent the path goes under: the text's own, or the container\n   *  minted to hold a multi-paint text's paths. */\n  parent: string | null;\n}\n\n/** What `applyCreateOutlines` reads and writes through. */\nexport interface CreateOutlinesAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  /** The text node behind `id`, or `undefined` for anything else. */\n  getTextSource(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Mint one path node of text node `sourceId`'s outlines. `path` is in world\n   * space. The node must wear `spec`'s fill and stroke — a text whose runs\n   * differ in paint gets one path per paint — and sit under `spec.parent`.\n   * The kit places it; only the consumer knows its data shape.\n   */\n  createPathNode(path: PolygonPath, sourceId: NodeId, spec: OutlinePathSpec): { id: string };\n  /**\n   * Mint the container that holds a multi-paint text's paths, under `parent`.\n   * `bounds` is the world envelope of the paths. The kit puts the container in\n   * the text's slot and the paths inside it, in the text's order. Without\n   * this, the paths are laid flat in that slot instead.\n   */\n  createContainerNode?(sourceId: NodeId, spec: { parent: string | null; bounds: Rect }): { id: string };\n  /** Full node for `id`, so undo restores the text node whole. Without it the\n   *  delete captures an `{ id }` stub. */\n  getNode?(id: string): { id: string } | undefined | null;\n  /** Parent and sibling order — the reorder contract. With both, each path is\n   *  inserted at its text node's index; without, where `insertNode` defaults. */\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }, index?: number): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome of {@link applyCreateOutlines}. */\nexport type CreateOutlinesResult =\n  /** `resultIds` are what replaced the text nodes at their level — a path,\n   *  a container, or a run of flat paths each — which is also what is now\n   *  selected in the text nodes' place. */\n  | { kind: 'applied'; resultIds: string[] }\n  /** Nothing selected is text with ink. */\n  | { kind: 'noop'; reason: 'no-text' }\n  /** Some selected text has no outline geometry; nothing was changed. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\n/**\n * Convert every text node in the selection to outlines, as one batch labeled\n * \"Create Outlines\". Other selected nodes are left alone and stay selected.\n * All or nothing: if any text node's face cannot supply outlines the scene is\n * untouched and the error comes back in the result.\n */\nexport function applyCreateOutlines(adapter: CreateOutlinesAdapter): CreateOutlinesResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const converted: { id: NodeId; paths: TextPaintPath[] }[] = [];\n  try {\n    for (const id of sel) {\n      const text = adapter.getTextSource(id);\n      if (!text) continue;\n      const paths = textToPathsByPaint(text.data, text.pose);\n      if (paths.length > 0) converted.push({ id, paths });\n    }\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  if (converted.length === 0) return { kind: 'noop', reason: 'no-text' };\n\n  const ops: Op[] = [];\n  const replaced = new Map<NodeId, string[]>();\n  // Replacements in the same parent are inserted top slot first, so an\n  // earlier one widening the sibling list cannot shift a later one's index.\n  const located = converted.map((c) => ({ ...c, at: locateChild(adapter, c.id) }));\n  const order = [...located].sort((a, b) => (b.at?.index ?? -1) - (a.at?.index ?? -1));\n  for (const { id, paths, at } of order) {\n    const node = adapter.getNode?.(id) ?? { id };\n    const index = at?.index ?? -1;\n    const parent = at?.parentId ?? adapter.getParent?.(id) ?? null;\n    const place = (created: { id: string }, i: number) =>\n      createInsertOp(index >= 0 ? { node: created, index: index + i } : { node: created });\n    ops.push(createDeleteOp({ node, index }));\n\n    const container = paths.length > 1\n      ? adapter.createContainerNode?.(id, { parent, bounds: envelope(paths) })\n      : undefined;\n    if (container) {\n      ops.push(place(container, 0));\n      for (const p of paths) {\n        ops.push(createInsertOp({ node: adapter.createPathNode(p.path, id, specOf(p, container.id)) }));\n      }\n      replaced.set(id, [container.id]);\n    } else {\n      const created = paths.map((p) => adapter.createPathNode(p.path, id, specOf(p, parent)));\n      created.forEach((n, i) => ops.push(place(n, i)));\n      replaced.set(id, created.map((n) => n.id));\n    }\n  }\n  ops.push(createSetSelectionOp({\n    from: sel,\n    to: sel.flatMap((id) => (replaced.get(id) ?? [id]) as NodeId[]),\n  }));\n  dispatchApplyBatch(adapter, ops, 'Create Outlines');\n  return { kind: 'applied', resultIds: converted.flatMap((c) => replaced.get(c.id)!) };\n}\n\nfunction specOf(p: TextPaintPath, parent: string | null): OutlinePathSpec {\n  return p.stroke !== undefined ? { fill: p.fill, stroke: p.stroke, parent } : { fill: p.fill, parent };\n}\n\nfunction envelope(paths: readonly TextPaintPath[]): Rect {\n  return unionBounds(paths.map((p) => boundsOfPath(p.path)))!;\n}\n"],"mappings":";;;;;;;;;AAmFA,SAAgBA,EAAoB,GAAsD;CACxF,IAAMC,IAAM,CAAC,GAAGC,EAAQ,aAAa,CAAC,GAChCC,IAAsD,CAAC;CAC7D,IAAI;EACF,KAAK,IAAMC,KAAMH,GAAK;GACpB,IAAMI,IAAOH,EAAQ,cAAcE,CAAE;GACrC,IAAI,CAACC,GAAM;GACX,IAAMC,IAAQC,EAAmBF,EAAK,MAAMA,EAAK,IAAI;GACrD,AAAIC,EAAM,SAAS,KAAGH,EAAU,KAAK;IAAE;IAAI;GAAM,CAAC;EACpD;CACF,SAASK,GAAK;EACZ,IAAIA,aAAeC,GAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAOD;EAAI;EACnG,MAAMA;CACR;CACA,IAAIL,EAAU,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAU;CAErE,IAAMO,IAAY,CAAC,GACbC,oBAAW,IAAI,IAAsB,GAIrCC,IAAQ,CAAC,GADCT,EAAU,KAAK,OAAO;EAAE,GAAGU;EAAG,IAAIC,EAAYZ,GAASW,EAAE,EAAE;CAAE,EAC3D,CAAO,CAAC,CAAC,MAAM,GAAG,OAAOE,EAAE,IAAI,SAAS,OAAOC,EAAE,IAAI,SAAS,GAAG;CACnF,KAAK,IAAM,EAAE,OAAI,UAAO,WAAQJ,GAAO;EACrC,IAAMK,IAAOf,EAAQ,UAAUE,CAAE,KAAK,EAAE,MAAG,GACrCc,IAAQC,GAAI,SAAS,IACrBC,IAASD,GAAI,YAAYjB,EAAQ,YAAYE,CAAE,KAAK,MACpDiB,KAAS,GAAyB,MACtCC,EAAeJ,KAAS,IAAI;GAAE,MAAMK;GAAS,OAAOL,IAAQM;EAAE,IAAI,EAAE,MAAMD,EAAQ,CAAC;EACrF,EAAI,KAAKE,EAAe;GAAE;GAAM;EAAM,CAAC,CAAC;EAExC,IAAMC,IAAYpB,EAAM,SAAS,IAC7BJ,EAAQ,sBAAsBE,GAAI;GAAE;GAAQ,QAAQuB,EAASrB,CAAK;EAAE,CAAC,IACrE,KAAA;EACJ,IAAIoB,GAAW;GACb,EAAI,KAAKL,EAAMK,GAAW,CAAC,CAAC;GAC5B,KAAK,IAAME,KAAKtB,GACd,EAAI,KAAKgB,EAAe,EAAE,MAAMpB,EAAQ,eAAe0B,EAAE,MAAMxB,GAAIyB,EAAOD,GAAGF,EAAU,EAAE,CAAC,EAAE,CAAC,CAAC;GAEhG,EAAS,IAAItB,GAAI,CAACsB,EAAU,EAAE,CAAC;EACjC,OAAO;GACL,IAAMH,IAAUjB,EAAM,KAAK,MAAMJ,EAAQ,eAAe0B,EAAE,MAAMxB,GAAIyB,EAAOD,GAAGR,CAAM,CAAC,CAAC;GAEtF,AADAG,EAAQ,SAAS,GAAG,MAAMb,EAAI,KAAKW,EAAMS,GAAGN,CAAC,CAAC,CAAC,GAC/Cb,EAAS,IAAIP,GAAImB,EAAQ,KAAK,MAAMO,EAAE,EAAE,CAAC;EAC3C;CACF;CAMA,OALApB,EAAI,KAAKqB,EAAqB;EAC5B,MAAM9B;EACN,IAAIA,EAAI,SAAS,MAAQU,EAAS,IAAIP,CAAE,KAAK,CAACA,CAAE,CAAc;CAChE,CAAC,CAAC,GACF4B,EAAmB9B,GAASQ,GAAK,iBAAiB,GAC3C;EAAE,MAAM;EAAW,WAAWP,EAAU,SAAS,MAAMQ,EAAS,IAAIE,EAAE,EAAE,CAAE;CAAE;AACrF;AAEA,SAASgB,EAAO,GAAkB,GAAwC;CACxE,OAAOD,EAAE,WAAW,KAAA,IAAyD;EAAE,MAAMA,EAAE;EAAM;CAAO,IAApE;EAAE,MAAMA,EAAE;EAAM,QAAQA,EAAE;EAAQ;CAAO;AAC3E;AAEA,SAASD,EAAS,GAAuC;CACvD,OAAOM,EAAY3B,EAAM,KAAK,MAAM4B,EAAaN,EAAE,IAAI,CAAC,CAAC;AAC3D"}
+{"version":3,"file":"createOutlines.js","names":["applyCreateOutlines","sel","adapter","converted","id","text","paths","textToPathsByPaint","err","TextOutlinesError","replaced","replaceWithPaths","c"],"sources":["../../../../src/interactions/actions/outlines/createOutlines.ts"],"sourcesContent":["/**\n * Create Outlines: replace each selected text node with path nodes carrying\n * its glyph outlines, giving up editability for geometry — the destructive\n * conversion every vector editor has. One path per paint the text wears; one\n * undoable batch; the replacement takes the text node's slot, so stacking\n * order is unchanged.\n */\nimport type { Mat3, Path, Rect } from '@weasel-js/geom';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { textToPathsByPaint, TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport { replaceWithPaths, type PaintedPath } from './replaceWithPaths';\n\n/** What a path minted by an outline action must carry — see\n *  {@link CreateOutlinesAdapter.createPathNode}. */\nexport interface OutlinePathSpec extends PathPaint {\n  /** The parent the path goes under: the source's own, or the container\n   *  minted to hold a source's several paths. */\n  parent: string | null;\n}\n\n/** What `applyCreateOutlines` and `applyOutlineStroke` read and write through. */\nexport interface CreateOutlinesAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  /** The text node behind `id`, or `undefined` for anything else. */\n  getTextSource(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Optional: the world-space path of the path node behind `id`, and the\n   * paint it wears. Outline Stroke reads both, and passes over a node that\n   * lacks either.\n   */\n  getWorldPath?(id: NodeId): Path | undefined;\n  getPaint?(id: NodeId): PathPaint | undefined;\n  /**\n   * Optional: the frame the node behind `id` draws its stroke in, as the\n   * matrix taking that frame to world (`poseFrameOf`); null or absent for a\n   * node drawn straight. Outline Stroke skews and stretches a world-width\n   * stroke with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Mat3 | null | undefined;\n  /**\n   * Mint one path node of node `sourceId`'s outlines. `path` is in world\n   * space. The node must wear `spec`'s fill and stroke — a text whose runs\n   * differ in paint gets one path per paint, and a filled node whose stroke\n   * is outlined gets one for the fill and one for the stroke — and sit under\n   * `spec.parent`. The kit places it; only the consumer knows its data shape,\n   * so anything else of the source's `data` worth keeping is the adapter's to\n   * copy: onto this path when it stands alone in the source's slot, onto the\n   * container when `createContainerNode` minted one.\n   */\n  createPathNode(path: Path, sourceId: NodeId, spec: OutlinePathSpec): { id: string };\n  /**\n   * Mint the container that holds one source's several paths, under `parent`.\n   * `bounds` is the world envelope of the paths. The kit puts the container in\n   * the source's slot and the paths inside it, back to front. Without this,\n   * the paths are laid flat in that slot instead.\n   */\n  createContainerNode?(sourceId: NodeId, spec: { parent: string | null; bounds: Rect }): { id: string };\n  /** Full node for `id`, so undo restores the text node whole. Without it the\n   *  delete captures an `{ id }` stub. */\n  getNode?(id: string): { id: string } | undefined | null;\n  /** Parent and sibling order — the reorder contract. With both, each path is\n   *  inserted at its text node's index; without, where `insertNode` defaults. */\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }, index?: number): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome of {@link applyCreateOutlines}. */\nexport type CreateOutlinesResult =\n  /** `resultIds` are what replaced the text nodes at their level — a path,\n   *  a container, or a run of flat paths each — which is also what is now\n   *  selected in the text nodes' place. */\n  | { kind: 'applied'; resultIds: string[] }\n  /** Nothing selected is text with ink. */\n  | { kind: 'noop'; reason: 'no-text' }\n  /** Some selected text has no outline geometry; nothing was changed. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\n/**\n * Convert every text node in the selection to outlines, as one batch labeled\n * \"Create Outlines\". Other selected nodes are left alone and stay selected.\n * All or nothing: if any text node's face cannot supply outlines the scene is\n * untouched and the error comes back in the result.\n */\nexport function applyCreateOutlines(adapter: CreateOutlinesAdapter): CreateOutlinesResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const converted: { id: NodeId; paths: PaintedPath[] }[] = [];\n  try {\n    for (const id of sel) {\n      const text = adapter.getTextSource(id);\n      if (!text) continue;\n      const paths = textToPathsByPaint(text.data, text.pose);\n      if (paths.length > 0) converted.push({ id, paths });\n    }\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  if (converted.length === 0) return { kind: 'noop', reason: 'no-text' };\n\n  const replaced = replaceWithPaths(adapter, sel, converted, 'Create Outlines');\n  return { kind: 'applied', resultIds: converted.flatMap((c) => replaced.get(c.id)!) };\n}\n"],"mappings":";;;AAyFA,SAAgBA,EAAoB,GAAsD;CACxF,IAAMC,IAAM,CAAC,GAAGC,EAAQ,aAAa,CAAC,GAChCC,IAAoD,CAAC;CAC3D,IAAI;EACF,KAAK,IAAMC,KAAMH,GAAK;GACpB,IAAMI,IAAOH,EAAQ,cAAcE,CAAE;GACrC,IAAI,CAACC,GAAM;GACX,IAAMC,IAAQC,EAAmBF,EAAK,MAAMA,EAAK,IAAI;GACrD,AAAIC,EAAM,SAAS,KAAGH,EAAU,KAAK;IAAE;IAAI;GAAM,CAAC;EACpD;CACF,SAASK,GAAK;EACZ,IAAIA,aAAeC,GAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAOD;EAAI;EACnG,MAAMA;CACR;CACA,IAAIL,EAAU,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAU;CAErE,IAAMO,IAAWC,EAAiBT,GAASD,GAAKE,GAAW,iBAAiB;CAC5E,OAAO;EAAE,MAAM;EAAW,WAAWA,EAAU,SAAS,MAAMO,EAAS,IAAIE,EAAE,EAAE,CAAE;CAAE;AACrF"}

package/dist/interactions/actions/outlines/createOutlinesAction.js

@@ -0,0 +1,51 @@
+import { applyCreateOutlines as e } from "./createOutlines.js";
+import { CreateOutlinesIcon as t } from "../defaults/icons/outlineIcons.js";
+import { ActionDisabledReason as n } from "@weasel-js/routing";
+import { jsx as r } from "react/jsx-runtime";
+import { loadTextOutlines as i } from "@weasel-js/text";
+//#region src/interactions/actions/outlines/createOutlinesAction.tsx
+async function a(e, t, n) {
+	let r = (e) => e.kind === "failed" ? e.error : null, a = t();
+	if (r(a)?.reason === "outlines-loading") {
+		let n = [...e.getSelection()].map((t) => e.getTextSource(t)).filter((e) => e !== void 0);
+		await Promise.all(n.map((e) => i(e.data))), a = t();
+	}
+	let o = r(a);
+	return o && console.warn(`[${n}] ${o.message}`), a;
+}
+function o(t) {
+	return a(t, () => e(t), "createOutlines");
+}
+var s = {
+	id: "createOutlines",
+	label: "Create Outlines",
+	icon: /* @__PURE__ */ r(t, {}),
+	group: "text",
+	defaultBinding: {
+		kind: "key",
+		key: "o",
+		mods: {
+			mod: !0,
+			shift: !0
+		}
+	},
+	eligible: { capability: "creates-shapes" },
+	requires: ["selection", "createOutlinesAdapter"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let t = e.createOutlinesAdapter;
+			t && o(t);
+		}
+	},
+	enabled: (e) => {
+		let t = e?.selection?.get() ?? [];
+		if (t.length === 0) return n.SelectionRequired;
+		let r = e?.createOutlinesAdapter;
+		return r && t.some((e) => r.getTextSource(e) !== void 0) ? !0 : n.NotApplicable;
+	}
+};
+//#endregion
+export { s as createOutlinesAction, o as runCreateOutlines, a as withTextOutlines };
+
+//# sourceMappingURL=createOutlinesAction.js.map

package/dist/interactions/actions/outlines/createOutlinesAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createOutlinesAction.js","names":["withTextOutlines","failure","r","result","apply","texts","adapter","id","t","loadTextOutlines","error","tag","runCreateOutlines","applyCreateOutlines","createOutlinesAction","CreateOutlinesIcon","deps","ids","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/outlines/createOutlinesAction.tsx"],"sourcesContent":["import type { Action, ImmediateInvoker } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { loadTextOutlines, type TextNodeSource, type TextOutlinesError } from '@weasel-js/text';\nimport {\n  applyCreateOutlines, type CreateOutlinesAdapter, type CreateOutlinesResult,\n} from './createOutlines';\nimport { CreateOutlinesIcon } from '../defaults/icons/outlineIcons';\n\n/** What an outline conversion answers when a text face had no outlines. */\ntype OutlinesFailure = { kind: 'failed'; error: TextOutlinesError };\n\n/**\n * Run `apply`, an outline conversion of `adapter`'s selection, waiting first\n * for any face whose outlines are registered but not yet loaded — a face is\n * parsed on first use, so the first conversion in a session would otherwise\n * fail. Warns under `tag` with the reason when the selection still cannot be\n * converted.\n */\nexport async function withTextOutlines<R extends { kind: string } | OutlinesFailure>(\n  adapter: CreateOutlinesAdapter,\n  apply: () => R,\n  tag: string,\n): Promise<R> {\n  const failure = (r: R): TextOutlinesError | null => (r.kind === 'failed' ? (r as OutlinesFailure).error : null);\n  let result = apply();\n  if (failure(result)?.reason === 'outlines-loading') {\n    const texts = [...adapter.getSelection()]\n      .map((id) => adapter.getTextSource(id as NodeId))\n      .filter((t): t is TextNodeSource => t !== undefined);\n    await Promise.all(texts.map((t) => loadTextOutlines(t.data)));\n    result = apply();\n  }\n  const error = failure(result);\n  if (error) console.warn(`[${tag}] ${error.message}`);\n  return result;\n}\n\n/** {@link applyCreateOutlines} through {@link withTextOutlines}. */\nexport function runCreateOutlines(adapter: CreateOutlinesAdapter): Promise<CreateOutlinesResult> {\n  return withTextOutlines(adapter, () => applyCreateOutlines(adapter), 'createOutlines');\n}\n\n/**\n * @experimental Static descriptor for Create Outlines: replace the selected\n * text nodes with path nodes carrying their glyph outlines. Reads the\n * `createOutlinesAdapter` dep, published with `useCreateOutlinesAdapter`.\n */\nexport const createOutlinesAction: Action = {\n  id: 'createOutlines',\n  label: 'Create Outlines',\n  icon: <CreateOutlinesIcon />,\n  group: 'text',\n  defaultBinding: { kind: 'key', key: 'o', mods: { mod: true, shift: true } },\n  eligible: { capability: 'creates-shapes' },\n  requires: ['selection', 'createOutlinesAdapter'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const adapter = deps.createOutlinesAdapter;\n      if (adapter) void runCreateOutlines(adapter);\n    },\n  } satisfies ImmediateInvoker,\n  enabled: (deps) => {\n    const ids = deps?.selection?.get() ?? [];\n    if (ids.length === 0) return ActionDisabledReason.SelectionRequired;\n    const adapter = deps?.createOutlinesAdapter;\n    return adapter && ids.some((id) => adapter.getTextSource(id) !== undefined)\n      ? true\n      : ActionDisabledReason.NotApplicable;\n  },\n};\n"],"mappings":";;;;;;AAmBA,eAAsBA,EACpB,GACA,GACA,GACY;CACZ,IAAMC,KAAW,MAAoCC,EAAE,SAAS,WAAYA,EAAsB,QAAQ,MACtGC,IAASC,EAAM;CACnB,IAAIH,EAAQE,CAAM,CAAC,EAAE,WAAW,oBAAoB;EAClD,IAAME,IAAQ,CAAC,GAAGC,EAAQ,aAAa,CAAC,CAAC,CACtC,KAAK,MAAOA,EAAQ,cAAcC,CAAY,CAAC,CAAC,CAChD,QAAQ,MAA2BC,MAAM,KAAA,CAAS;EAErD,AADA,MAAM,QAAQ,IAAIH,EAAM,KAAK,MAAMI,EAAiBD,EAAE,IAAI,CAAC,CAAC,GAC5D,IAASJ,EAAM;CACjB;CACA,IAAMM,IAAQT,EAAQE,CAAM;CAE5B,OADIO,KAAO,QAAQ,KAAK,IAAIC,EAAI,IAAID,EAAM,SAAS,GAC5CP;AACT;AAGA,SAAgBS,EAAkB,GAA+D;CAC/F,OAAOZ,EAAiBM,SAAeO,EAAoBP,CAAO,GAAG,gBAAgB;AACvF;AAOA,IAAaQ,IAA+B;CAC1C,IAAI;CACJ,OAAO;CACP,MAAM,kBAACC,GAAD,CAAqB,CAAA;CAC3B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM;GAAE,KAAK;GAAM,OAAO;EAAK;CAAE;CAC1E,UAAU,EAAE,YAAY,iBAAiB;CACzC,UAAU,CAAC,aAAa,uBAAuB;CAC/C,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMT,IAAUU,EAAK;GACrB,AAAIV,KAASM,EAAuBN,CAAO;EAC7C;CACF;CACA,UAAU,MAAS;EACjB,IAAMW,IAAMD,GAAM,WAAW,IAAI,KAAK,CAAC;EACvC,IAAIC,EAAI,WAAW,GAAG,OAAOC,EAAqB;EAClD,IAAMZ,IAAUU,GAAM;EACtB,OAAOV,KAAWW,EAAI,MAAM,MAAOX,EAAQ,cAAcC,CAAE,MAAM,KAAA,CAAS,IACtE,KACAW,EAAqB;CAC3B;AACF"}

package/dist/interactions/actions/outlines/outlineStroke.js

@@ -0,0 +1,72 @@
+import { strokeRegion as e } from "./strokeRegion.js";
+import { replaceWithPaths as t } from "./replaceWithPaths.js";
+import { TextOutlinesError as n, textToPathsByPaint as r } from "@weasel-js/text";
+//#region src/interactions/actions/outlines/outlineStroke.ts
+function i(e) {
+	return e != null && (e.data.stroke != null || !!e.data.runs?.some((e) => e.stroke != null));
+}
+function a(e, t) {
+	let n = e.getWorldPath?.(t);
+	if (n) {
+		let r = e.getPaint?.(t);
+		return r ? [{
+			path: n,
+			...r
+		}] : [];
+	}
+	let a = e.getTextSource(t);
+	return !a || !i(a) ? [] : r(a.data, a.pose);
+}
+function o(r, i = {}) {
+	let o = [...r.getSelection()], s = [];
+	try {
+		for (let t of o) {
+			let n = r.getStrokeFrame?.(t), o = [], c = !1;
+			for (let { path: s, fill: l, stroke: u } of a(r, t)) {
+				let t = u?.paint == null ? null : e(s, u, n, i);
+				if (!t || t.commands.length === 0) {
+					o.push(u ? {
+						path: s,
+						fill: l,
+						stroke: u
+					} : {
+						path: s,
+						fill: l
+					});
+					continue;
+				}
+				c = !0, l !== null && o.push({
+					path: s,
+					fill: l
+				}), o.push({
+					path: t,
+					fill: { paint: u.paint }
+				});
+			}
+			c && s.push({
+				id: t,
+				paths: o
+			});
+		}
+	} catch (e) {
+		if (e instanceof n) return {
+			kind: "failed",
+			reason: "text-outlines",
+			error: e
+		};
+		throw e;
+	}
+	if (s.length === 0) return {
+		kind: "noop",
+		reason: "no-stroke"
+	};
+	let c = t(r, o, s, "Outline Stroke");
+	return {
+		kind: "applied",
+		resultIds: s.flatMap((e) => c.get(e.id))
+	};
+}
+//#endregion
+export { o as applyOutlineStroke, i as textIsStroked };
+
+//# sourceMappingURL=outlineStroke.js.map

package/dist/interactions/actions/outlines/outlineStroke.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlineStroke.js","names":["textIsStroked","text","r","paintedPaths","path","adapter","id","paint","textToPathsByPaint","applyOutlineStroke","sel","converted","frame","paths","outlined","outline","stroke","strokeRegion","opts","fill","err","TextOutlinesError","replaced","replaceWithPaths","c"],"sources":["../../../../src/interactions/actions/outlines/outlineStroke.ts"],"sourcesContent":["/**\n * Outline Stroke: replace each selected stroked path, or stroked text, with\n * the region its stroke covers, as a path filled in the stroke's paint. A node\n * that is also filled keeps its fill as a path of its own underneath. One\n * undoable batch; the replacement takes the node's slot.\n */\nimport { textToPathsByPaint, TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport type { NodeId } from 'core/scene/types';\nimport type { CreateOutlinesAdapter } from './createOutlines';\nimport { replaceWithPaths, type PaintedPath } from './replaceWithPaths';\nimport { strokeRegion, type StrokeRegionOptions } from './strokeRegion';\n\n/** Outcome of {@link applyOutlineStroke}. */\nexport type OutlineStrokeResult =\n  /** `resultIds` are what replaced the stroked nodes at their level — a\n   *  path, a container, or a run of flat paths each — and are now selected in\n   *  their place. */\n  | { kind: 'applied'; resultIds: string[] }\n  /** Nothing selected is a path or text with a stroke that has width. */\n  | { kind: 'noop'; reason: 'no-stroke' }\n  /** Some selected stroked text has no outline geometry; nothing was changed. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\n/** Whether a text node wears a stroke anywhere: its own, or a run's. */\nexport function textIsStroked(text: TextNodeSource | undefined): boolean {\n  return text != null && (text.data.stroke != null || !!text.data.runs?.some((r) => r.stroke != null));\n}\n\n/** What the adapter knows of `id` as painted world paths: a path node's one,\n *  or a text node's glyphs by paint. Throws as `textToPathsByPaint` does. */\nfunction paintedPaths(adapter: CreateOutlinesAdapter, id: NodeId): PaintedPath[] {\n  const path = adapter.getWorldPath?.(id);\n  if (path) {\n    const paint = adapter.getPaint?.(id);\n    return paint ? [{ path, ...paint }] : [];\n  }\n  const text = adapter.getTextSource(id);\n  // Text with no stroke stays text: its outlines are not read, so a face\n  // without them fails only the text this would convert.\n  if (!text || !textIsStroked(text)) return [];\n  return textToPathsByPaint(text.data, text.pose);\n}\n\n/**\n * Outline the stroke of every stroked path and stroked text in the selection,\n * as one batch labeled \"Outline Stroke\". Other selected nodes are left alone\n * and stay selected. Each stroke is outlined in the frame it is drawn in: see\n * {@link strokeRegion}. All or nothing: if a stroked text's face cannot\n * supply outlines the scene is untouched and the error comes back.\n */\nexport function applyOutlineStroke(\n  adapter: CreateOutlinesAdapter,\n  opts: StrokeRegionOptions = {},\n): OutlineStrokeResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const converted: { id: NodeId; paths: PaintedPath[] }[] = [];\n  try {\n    for (const id of sel) {\n      const frame = adapter.getStrokeFrame?.(id);\n      const paths: PaintedPath[] = [];\n      let outlined = false;\n      for (const { path, fill, stroke } of paintedPaths(adapter, id)) {\n        const outline = stroke?.paint == null ? null : strokeRegion(path, stroke, frame, opts);\n        if (!outline || outline.commands.length === 0) {\n          paths.push(stroke ? { path, fill, stroke } : { path, fill });\n          continue;\n        }\n        outlined = true;\n        if (fill !== null) paths.push({ path, fill });\n        paths.push({ path: outline, fill: { paint: stroke!.paint! } });\n      }\n      if (outlined) converted.push({ id, paths });\n    }\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  if (converted.length === 0) return { kind: 'noop', reason: 'no-stroke' };\n  const replaced = replaceWithPaths(adapter, sel, converted, 'Outline Stroke');\n  return { kind: 'applied', resultIds: converted.flatMap((c) => replaced.get(c.id)!) };\n}\n"],"mappings":";;;;AAwBA,SAAgBA,EAAc,GAA2C;CACvE,OAAOC,KAAQ,SAASA,EAAK,KAAK,UAAU,QAAQ,CAAC,CAACA,EAAK,KAAK,MAAM,MAAM,MAAMC,EAAE,UAAU,IAAI;AACpG;AAIA,SAASC,EAAa,GAAgC,GAA2B;CAC/E,IAAMC,IAAOC,EAAQ,eAAeC,CAAE;CACtC,IAAIF,GAAM;EACR,IAAMG,IAAQF,EAAQ,WAAWC,CAAE;EACnC,OAAOC,IAAQ,CAAC;GAAE;GAAM,GAAGA;EAAM,CAAC,IAAI,CAAC;CACzC;CACA,IAAMN,IAAOI,EAAQ,cAAcC,CAAE;CAIrC,OADI,CAACL,KAAQ,CAACD,EAAcC,CAAI,IAAU,CAAC,IACpCO,EAAmBP,EAAK,MAAMA,EAAK,IAAI;AAChD;AASA,SAAgBQ,EACd,GACA,IAA4B,CAAC,GACR;CACrB,IAAMC,IAAM,CAAC,GAAGL,EAAQ,aAAa,CAAC,GAChCM,IAAoD,CAAC;CAC3D,IAAI;EACF,KAAK,IAAML,KAAMI,GAAK;GACpB,IAAME,IAAQP,EAAQ,iBAAiBC,CAAE,GACnCO,IAAuB,CAAC,GAC1BC,IAAW;GACf,KAAK,IAAM,EAAE,SAAM,SAAM,eAAYX,EAAaE,GAASC,CAAE,GAAG;IAC9D,IAAMS,IAAUC,GAAQ,SAAS,OAAO,OAAOC,EAAab,GAAMY,GAAQJ,GAAOM,CAAI;IACrF,IAAI,CAACH,KAAWA,EAAQ,SAAS,WAAW,GAAG;KAC7C,EAAM,KAAKC,IAAS;MAAE;MAAM;MAAM;KAAO,IAAI;MAAE;MAAM;KAAK,CAAC;KAC3D;IACF;IAGA,AAFA,IAAW,IACPG,MAAS,QAAMN,EAAM,KAAK;KAAE;KAAM;IAAK,CAAC,GAC5CA,EAAM,KAAK;KAAE,MAAME;KAAS,MAAM,EAAE,OAAOC,EAAQ,MAAO;IAAE,CAAC;GAC/D;GACA,AAAIF,KAAUH,EAAU,KAAK;IAAE;IAAI;GAAM,CAAC;EAC5C;CACF,SAASS,GAAK;EACZ,IAAIA,aAAeC,GAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAOD;EAAI;EACnG,MAAMA;CACR;CACA,IAAIT,EAAU,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAY;CACvE,IAAMW,IAAWC,EAAiBlB,GAASK,GAAKC,GAAW,gBAAgB;CAC3E,OAAO;EAAE,MAAM;EAAW,WAAWA,EAAU,SAAS,MAAMW,EAAS,IAAIE,EAAE,EAAE,CAAE;CAAE;AACrF"}

package/dist/interactions/actions/outlines/outlineStrokeAction.js

@@ -0,0 +1,37 @@
+import { OutlineStrokeIcon as e } from "../defaults/icons/outlineIcons.js";
+import { withTextOutlines as t } from "./createOutlinesAction.js";
+import { applyOutlineStroke as n, textIsStroked as r } from "./outlineStroke.js";
+import { ActionDisabledReason as i } from "@weasel-js/routing";
+import { jsx as a } from "react/jsx-runtime";
+//#region src/interactions/actions/outlines/outlineStrokeAction.tsx
+var o = {
+	id: "outlineStroke",
+	label: "Outline Stroke",
+	icon: /* @__PURE__ */ a(e, {}),
+	group: "pathfinder",
+	eligible: { capability: "creates-shapes" },
+	requires: [
+		"selection",
+		"createOutlinesAdapter",
+		"view"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let r = e.createOutlinesAdapter;
+			if (!r) return;
+			let i = e.view?.get().scale;
+			t(r, () => n(r, i ? { scale: i } : {}), "outlineStroke");
+		}
+	},
+	enabled: (e) => {
+		let t = e?.selection?.get() ?? [];
+		if (t.length === 0) return i.SelectionRequired;
+		let n = e?.createOutlinesAdapter;
+		return n && t.some((e) => n.getPaint?.(e)?.stroke !== void 0 || r(n.getTextSource(e))) ? !0 : i.NotApplicable;
+	}
+};
+//#endregion
+export { o as outlineStrokeAction };
+
+//# sourceMappingURL=outlineStrokeAction.js.map

package/dist/interactions/actions/outlines/outlineStrokeAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlineStrokeAction.js","names":["outlineStrokeAction","OutlineStrokeIcon","adapter","deps","scale","applyOutlineStroke","ids","ActionDisabledReason","id","textIsStroked"],"sources":["../../../../src/interactions/actions/outlines/outlineStrokeAction.tsx"],"sourcesContent":["import type { Action, ImmediateInvoker } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport { applyOutlineStroke, textIsStroked } from './outlineStroke';\nimport { withTextOutlines } from './createOutlinesAction';\nimport { OutlineStrokeIcon } from '../defaults/icons/outlineIcons';\n\n/**\n * @experimental Static descriptor for Outline Stroke: replace each selected\n * stroked path, or stroked text, with the region its stroke covers, filled in\n * the stroke's paint. Reads the `createOutlinesAdapter` dep, published with\n * `useCreateOutlinesAdapter`, and needs its `getWorldPath` and `getPaint` for paths.\n */\nexport const outlineStrokeAction: Action = {\n  id: 'outlineStroke',\n  label: 'Outline Stroke',\n  icon: <OutlineStrokeIcon />,\n  group: 'pathfinder',\n  eligible: { capability: 'creates-shapes' },\n  requires: ['selection', 'createOutlinesAdapter', 'view'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const adapter = deps.createOutlinesAdapter;\n      if (!adapter) return;\n      const scale = deps.view?.get().scale;\n      void withTextOutlines(adapter, () => applyOutlineStroke(adapter, scale ? { scale } : {}), 'outlineStroke');\n    },\n  } satisfies ImmediateInvoker,\n  enabled: (deps) => {\n    const ids = deps?.selection?.get() ?? [];\n    if (ids.length === 0) return ActionDisabledReason.SelectionRequired;\n    const adapter = deps?.createOutlinesAdapter;\n    return adapter && ids.some((id) => adapter.getPaint?.(id)?.stroke !== undefined || textIsStroked(adapter.getTextSource(id)))\n      ? true\n      : ActionDisabledReason.NotApplicable;\n  },\n};\n"],"mappings":";;;;;;AAYA,IAAaA,IAA8B;CACzC,IAAI;CACJ,OAAO;CACP,MAAM,kBAACC,GAAD,CAAoB,CAAA;CAC1B,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,UAAU;EAAC;EAAa;EAAyB;CAAM;CACvD,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAUC,EAAK;GACrB,IAAI,CAACD,GAAS;GACd,IAAME,IAAQD,EAAK,MAAM,IAAI,CAAC,CAAC;GAC/B,EAAsBD,SAAeG,EAAmBH,GAASE,IAAQ,EAAE,SAAM,IAAI,CAAC,CAAC,GAAG,eAAe;EAC3G;CACF;CACA,UAAU,MAAS;EACjB,IAAME,IAAMH,GAAM,WAAW,IAAI,KAAK,CAAC;EACvC,IAAIG,EAAI,WAAW,GAAG,OAAOC,EAAqB;EAClD,IAAML,IAAUC,GAAM;EACtB,OAAOD,KAAWI,EAAI,MAAM,MAAOJ,EAAQ,WAAWM,CAAE,CAAC,EAAE,WAAW,KAAA,KAAaC,EAAcP,EAAQ,cAAcM,CAAE,CAAC,CAAC,IACvH,KACAD,EAAqB;CAC3B;AACF"}

package/dist/interactions/actions/outlines/replaceWithPaths.js

@@ -0,0 +1,54 @@
+import { unionBounds as e } from "../../../core/geometry/unionBounds.js";
+import { locateChild as t } from "../../../core/ops/slot.js";
+import { createDeleteOp as n } from "../../../core/ops/delete.js";
+import { createInsertOp as r } from "../../../core/ops/create.js";
+import { dispatchApplyBatch as i } from "../../../core/applyOps.js";
+import { createSetSelectionOp as a } from "../../../core/ops/select.js";
+import { boundsOfPath as o } from "@weasel-js/geom";
+//#region src/interactions/actions/outlines/replaceWithPaths.ts
+function s(s, l, u, d) {
+	let f = [], p = /* @__PURE__ */ new Map(), m = [...u.map((e) => ({
+		...e,
+		at: t(s, e.id)
+	}))].sort((e, t) => (t.at?.index ?? -1) - (e.at?.index ?? -1));
+	for (let { id: t, paths: i, at: a } of m) {
+		let l = s.getNode?.(t) ?? { id: t }, u = a?.index ?? -1, d = a?.parentId ?? s.getParent?.(t) ?? null, m = (e, t) => r(u >= 0 ? {
+			node: e,
+			index: u + t
+		} : { node: e });
+		f.push(n({
+			node: l,
+			index: u
+		}));
+		let h = i.length > 1 ? s.createContainerNode?.(t, {
+			parent: d,
+			bounds: e(i.map((e) => o(e.path)))
+		}) : void 0;
+		if (h) {
+			f.push(m(h, 0));
+			for (let e of i) f.push(r({ node: s.createPathNode(e.path, t, c(e, h.id)) }));
+			p.set(t, [h.id]);
+		} else {
+			let e = i.map((e) => s.createPathNode(e.path, t, c(e, d)));
+			e.forEach((e, t) => f.push(m(e, t))), p.set(t, e.map((e) => e.id));
+		}
+	}
+	return f.push(a({
+		from: [...l],
+		to: l.flatMap((e) => p.get(e) ?? [e])
+	})), i(s, f, d), p;
+}
+function c(e, t) {
+	return e.stroke === void 0 ? {
+		fill: e.fill,
+		parent: t
+	} : {
+		fill: e.fill,
+		stroke: e.stroke,
+		parent: t
+	};
+}
+//#endregion
+export { s as replaceWithPaths };
+
+//# sourceMappingURL=replaceWithPaths.js.map

package/dist/interactions/actions/outlines/replaceWithPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceWithPaths.js","names":["replaceWithPaths","ops","replaced","order","converted","c","locateChild","adapter","b","a","node","id","index","at","parent","place","createInsertOp","created","i","createDeleteOp","container","paths","unionBounds","boundsOfPath","p","specOf","n","createSetSelectionOp","sel","dispatchApplyBatch","label"],"sources":["../../../../src/interactions/actions/outlines/replaceWithPaths.ts"],"sourcesContent":["import { boundsOfPath, type Path } from '@weasel-js/geom';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport { locateChild } from 'core/ops/slot';\nimport { unionBounds } from 'core/geometry/unionBounds';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { CreateOutlinesAdapter, OutlinePathSpec } from './createOutlines';\n\n/** A world-space path and the paint it is to wear. */\nexport interface PaintedPath extends PathPaint {\n  path: Path;\n}\n\n/**\n * Replace each node in `converted` with its `paths`, back to front, as one\n * batch under `label`: in the node's own slot, inside a container when it has\n * several paths and the adapter mints one. The rest of `sel` stays selected.\n * Answers what took each node's place at its level.\n */\nexport function replaceWithPaths(\n  adapter: CreateOutlinesAdapter,\n  sel: readonly NodeId[],\n  converted: readonly { id: NodeId; paths: readonly PaintedPath[] }[],\n  label: string,\n): Map<NodeId, string[]> {\n  const ops: Op[] = [];\n  const replaced = new Map<NodeId, string[]>();\n  // Replacements in the same parent are inserted top slot first, so an\n  // earlier one widening the sibling list cannot shift a later one's index.\n  const located = converted.map((c) => ({ ...c, at: locateChild(adapter, c.id) }));\n  const order = [...located].sort((a, b) => (b.at?.index ?? -1) - (a.at?.index ?? -1));\n  for (const { id, paths, at } of order) {\n    const node = adapter.getNode?.(id) ?? { id };\n    const index = at?.index ?? -1;\n    const parent = at?.parentId ?? adapter.getParent?.(id) ?? null;\n    const place = (created: { id: string }, i: number) =>\n      createInsertOp(index >= 0 ? { node: created, index: index + i } : { node: created });\n    ops.push(createDeleteOp({ node, index }));\n\n    const container = paths.length > 1\n      ? adapter.createContainerNode?.(id, { parent, bounds: unionBounds(paths.map((p) => boundsOfPath(p.path)))! })\n      : undefined;\n    if (container) {\n      ops.push(place(container, 0));\n      for (const p of paths) {\n        ops.push(createInsertOp({ node: adapter.createPathNode(p.path, id, specOf(p, container.id)) }));\n      }\n      replaced.set(id, [container.id]);\n    } else {\n      const created = paths.map((p) => adapter.createPathNode(p.path, id, specOf(p, parent)));\n      created.forEach((n, i) => ops.push(place(n, i)));\n      replaced.set(id, created.map((n) => n.id));\n    }\n  }\n  ops.push(createSetSelectionOp({\n    from: [...sel],\n    to: sel.flatMap((id) => (replaced.get(id) ?? [id]) as NodeId[]),\n  }));\n  dispatchApplyBatch(adapter, ops, label);\n  return replaced;\n}\n\nfunction specOf(p: PaintedPath, parent: string | null): OutlinePathSpec {\n  return p.stroke !== undefined ? { fill: p.fill, stroke: p.stroke, parent } : { fill: p.fill, parent };\n}\n"],"mappings":";;;;;;;;AAuBA,SAAgBA,EACd,GACA,GACA,GACA,GACuB;CACvB,IAAMC,IAAY,CAAC,GACbC,oBAAW,IAAI,IAAsB,GAIrCC,IAAQ,CAAC,GADCC,EAAU,KAAK,OAAO;EAAE,GAAGC;EAAG,IAAIC,EAAYC,GAASF,EAAE,EAAE;CAAE,EAC3D,CAAO,CAAC,CAAC,MAAM,GAAG,OAAOG,EAAE,IAAI,SAAS,OAAOC,EAAE,IAAI,SAAS,GAAG;CACnF,KAAK,IAAM,EAAE,OAAI,UAAO,WAAQN,GAAO;EACrC,IAAMO,IAAOH,EAAQ,UAAUI,CAAE,KAAK,EAAE,MAAG,GACrCC,IAAQC,GAAI,SAAS,IACrBC,IAASD,GAAI,YAAYN,EAAQ,YAAYI,CAAE,KAAK,MACpDI,KAAS,GAAyB,MACtCC,EAAeJ,KAAS,IAAI;GAAE,MAAMK;GAAS,OAAOL,IAAQM;EAAE,IAAI,EAAE,MAAMD,EAAQ,CAAC;EACrF,EAAI,KAAKE,EAAe;GAAE;GAAM;EAAM,CAAC,CAAC;EAExC,IAAMC,IAAYC,EAAM,SAAS,IAC7Bd,EAAQ,sBAAsBI,GAAI;GAAE;GAAQ,QAAQW,EAAYD,EAAM,KAAK,MAAME,EAAaC,EAAE,IAAI,CAAC,CAAC;EAAG,CAAC,IAC1G,KAAA;EACJ,IAAIJ,GAAW;GACb,EAAI,KAAKL,EAAMK,GAAW,CAAC,CAAC;GAC5B,KAAK,IAAMI,KAAKH,GACd,EAAI,KAAKL,EAAe,EAAE,MAAMT,EAAQ,eAAeiB,EAAE,MAAMb,GAAIc,EAAOD,GAAGJ,EAAU,EAAE,CAAC,EAAE,CAAC,CAAC;GAEhG,EAAS,IAAIT,GAAI,CAACS,EAAU,EAAE,CAAC;EACjC,OAAO;GACL,IAAMH,IAAUI,EAAM,KAAK,MAAMd,EAAQ,eAAeiB,EAAE,MAAMb,GAAIc,EAAOD,GAAGV,CAAM,CAAC,CAAC;GAEtF,AADAG,EAAQ,SAAS,GAAG,MAAMhB,EAAI,KAAKc,EAAMW,GAAGR,CAAC,CAAC,CAAC,GAC/ChB,EAAS,IAAIS,GAAIM,EAAQ,KAAK,MAAMS,EAAE,EAAE,CAAC;EAC3C;CACF;CAMA,OALAzB,EAAI,KAAK0B,EAAqB;EAC5B,MAAM,CAAC,GAAGC,CAAG;EACb,IAAIA,EAAI,SAAS,MAAQ1B,EAAS,IAAIS,CAAE,KAAK,CAACA,CAAE,CAAc;CAChE,CAAC,CAAC,GACFkB,EAAmBtB,GAASN,GAAK6B,CAAK,GAC/B5B;AACT;AAEA,SAASuB,EAAO,GAAgB,GAAwC;CACtE,OAAOD,EAAE,WAAW,KAAA,IAAyD;EAAE,MAAMA,EAAE;EAAM;CAAO,IAApE;EAAE,MAAMA,EAAE;EAAM,QAAQA,EAAE;EAAQ;CAAO;AAC3E"}

package/dist/interactions/actions/outlines/strokeRegion.js

@@ -0,0 +1,27 @@
+import { strokeToPath as e } from "@weasel-js/stroke";
+//#region src/interactions/actions/outlines/strokeRegion.ts
+function t(t, n, r, { scale: i = 1, flattenTolerance: a } = {}) {
+	let o = a === void 0 ? {} : { flattenTolerance: a }, s = typeof i == "number" ? i : i.x, c = typeof i == "number" ? i : i.y, l = Math.sqrt(Math.abs(s * c));
+	return typeof n.width == "object" ? Math.abs(s) === Math.abs(c) ? e(t, n, {
+		...o,
+		scale: l
+	}) : e(t, n, {
+		...o,
+		frame: [
+			1 / s,
+			0,
+			0,
+			1 / c,
+			0,
+			0
+		]
+	}) : e(t, n, {
+		...o,
+		scale: l,
+		...r ? { frame: r } : {}
+	});
+}
+//#endregion
+export { t as strokeRegion };
+
+//# sourceMappingURL=strokeRegion.js.map

package/dist/interactions/actions/outlines/strokeRegion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strokeRegion.js","names":["strokeRegion","tolerance","flattenTolerance","sx","scale","sy","mean","stroke","strokeToPath","path","frame"],"sources":["../../../../src/interactions/actions/outlines/strokeRegion.ts"],"sourcesContent":["import { strokeToPath } from '@weasel-js/stroke';\nimport type { Mat3, Path, PolygonPath, Scale2 } from '@weasel-js/geom';\nimport type { Stroke } from '@weasel-js/paint';\n\n/** How Outline Stroke and a Boolean operation counting strokes measure one. */\nexport interface StrokeRegionOptions {\n  /** The view scale a `{ px }` width resolves against: one number, or the\n   *  view's own scale per axis. Default 1. */\n  scale?: number | Scale2;\n  /** Flatness tolerance for curves, in the units of the frame the stroke is\n   *  drawn in. */\n  flattenTolerance?: number;\n}\n\n/**\n * The region `stroke` covers along the world-space `path`, outlined in the\n * frame the canvas draws it in: the screen for a `{ px }` width, so a view\n * that scales its axes apart thins it on one of them, and otherwise `frame`,\n * the node's own (`poseFrameOf`, to world), which skews and stretches the\n * stroke with the node.\n */\nexport function strokeRegion(\n  path: Path,\n  stroke: Stroke,\n  frame: Mat3 | null | undefined,\n  { scale = 1, flattenTolerance }: StrokeRegionOptions = {},\n): PolygonPath {\n  const tolerance = flattenTolerance === undefined ? {} : { flattenTolerance };\n  const sx = typeof scale === 'number' ? scale : scale.x;\n  const sy = typeof scale === 'number' ? scale : scale.y;\n  const mean = Math.sqrt(Math.abs(sx * sy));\n  if (typeof stroke.width === 'object') {\n    if (Math.abs(sx) === Math.abs(sy)) return strokeToPath(path, stroke, { ...tolerance, scale: mean });\n    return strokeToPath(path, stroke, { ...tolerance, frame: [1 / sx, 0, 0, 1 / sy, 0, 0] });\n  }\n  return strokeToPath(path, stroke, { ...tolerance, scale: mean, ...(frame ? { frame } : {}) });\n}\n"],"mappings":";;AAqBA,SAAgBA,EACd,GACA,GACA,GACA,EAAE,WAAQ,GAAG,wBAA0C,CAAC,GAC3C;CACb,IAAMC,IAAYC,MAAqB,KAAA,IAAY,CAAC,IAAI,EAAE,oBAAiB,GACrEC,IAAK,OAAOC,KAAU,WAAWA,IAAQA,EAAM,GAC/CC,IAAK,OAAOD,KAAU,WAAWA,IAAQA,EAAM,GAC/CE,IAAO,KAAK,KAAK,KAAK,IAAIH,IAAKE,CAAE,CAAC;CAKxC,OAJI,OAAOE,EAAO,SAAU,WACtB,KAAK,IAAIJ,CAAE,MAAM,KAAK,IAAIE,CAAE,IAAUG,EAAaC,GAAMF,GAAQ;EAAE,GAAGN;EAAW,OAAOK;CAAK,CAAC,IAC3FE,EAAaC,GAAMF,GAAQ;EAAE,GAAGN;EAAW,OAAO;GAAC,IAAIE;GAAI;GAAG;GAAG,IAAIE;GAAI;GAAG;EAAC;CAAE,CAAC,IAElFG,EAAaC,GAAMF,GAAQ;EAAE,GAAGN;EAAW,OAAOK;EAAM,GAAII,IAAQ,EAAE,SAAM,IAAI,CAAC;CAAG,CAAC;AAC9F"}