@weasel-js/core 1.10.1 → 1.11.0

package/dist/interactions/actions/booleans/booleans.js.map

@@ -1 +1 @@
-{"version":3,"file":"booleans.js","names":["LABEL","planBooleanOp","resolved","sel","resolveOperand","adapter","id","opts","err","TextOutlinesError","entries","a","b","op","pieces","booleanPieces","i","paint","operand","previewBooleanOp","plan","piece","applyBooleanOp","slots","locateChild","made","newNodes","m","ops","captured","createDeleteOp","n","createInsertOp","placementOps","createSetSelectionOp","dispatchApplyBatch"],"sources":["../../../../src/interactions/actions/booleans/booleans.ts"],"sourcesContent":["/**\n * Pure action core for path boolean operations. Resolves the current\n * selection into z-ordered paths, runs the chosen op, and dispatches a\n * single batch of `Op`s (delete sources + insert results + set selection).\n */\nimport type { Affine, Path } from '@weasel-js/geom';\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 type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport { resolveOperand, type BooleanOpOptions, type BooleanOperand } from './operands';\nimport { booleanPieces, type ResultPiece } from './pieces';\nimport { placementOps } from './placement';\n\n/** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';\n\n/**\n * z-position descriptor for a path node. `parentId` is the direct parent\n * (or `null` for a top-level node); `index` is the position within that\n * parent's child order — never a global render index.\n */\n/** @internal */\nexport interface BooleanZOrder {\n  parentId: string | null;\n  index: number;\n}\n\n/** Adapter the hook and the pure core both consume. */\nexport interface BooleansAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  getWorldPath(id: NodeId): Path | undefined;\n  /**\n   * Optional: the text node behind `id`, for an id `getWorldPath` has no path\n   * for. Its glyph outlines (`textToPath`) become the operand, so text can be\n   * cut, united or intersected like any shape.\n   */\n  getTextSource?(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Optional: the paint the path node behind `id` wears. An operation told to\n   * count strokes (`BooleanOpOptions.strokes`) reads it to learn whether the\n   * node is stroked and whether it is filled; without it every operand is its\n   * path alone.\n   */\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. A counted world-width stroke is skewed and stretched\n   * with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Affine | null | undefined;\n  compareZ(a: NodeId, b: NodeId): number;\n  /**\n   * Mint a new node from a boolean-op result `Path`. `producedBy` names the\n   * op that synthesized it — adapters that store provenance (e.g. for a\n   * layer-panel icon) record it; others ignore the arg. `sourceId` is the\n   * source the result stands in for: the topmost, except that each piece of\n   * a Divide, Crop, Trim, or Merge names the topmost source it was cut from. Give the\n   * node that source's parent, or the kit's reorder cannot find it there.\n   * `paint` is passed when that source's stroke went into the geometry, and\n   * the node must wear it as given: wearing the source's stroke again would\n   * draw it twice. Without `paint`, give it that source's paint. The kit never\n   * reads a node's `data`: anything else the result should keep of its source,\n   * a name say, is the adapter's to copy from `sourceId`.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId, paint?: PathPaint): { id: string };\n  /**\n   * The full object for an id. The delete ops capture it, so their `invert`\n   * (an insert) restores the complete object on undo.\n   */\n  getNode(id: NodeId): { id: string } | undefined | null;\n  /**\n   * The tree. The kit reads each source's slot among its siblings through\n   * `getParent` and `getChildren`, and moves each result into the slot of\n   * the topmost source in its own source's parent through `setChildOrder`.\n   * `defaultCommitAdapter` supplies all three, and `getNode`.\n   */\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome reported back to callers (lets the hook surface no-op signals). */\nexport type BooleanOpResult =\n  | { kind: 'applied'; resultIds: string[] }\n  | { kind: 'noop'; reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result' }\n  /** A text operand had no outline geometry. Nothing was changed: an op that\n   *  quietly dropped the operand would commit a different shape than asked. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n  trim: 'Trim',\n  merge: 'Merge',\n};\n\n/** One path a Boolean operation would make. */\nexport interface BooleanPreviewPiece {\n  path: Path;\n  /** The source the piece stands in for; see `BooleansAdapter.createPathNode`. */\n  sourceId: NodeId;\n  /** Set when that source's stroke went into `path`: the paint the piece wears. */\n  paint?: PathPaint;\n}\n\n/** What {@link previewBooleanOp} answers: the pieces, or why there are none. */\nexport type BooleanOpPreview =\n  | { kind: 'pieces'; pieces: BooleanPreviewPiece[] }\n  | Exclude<BooleanOpResult, { kind: 'applied' }>;\n\ntype Entry = { id: NodeId; operand: BooleanOperand };\n\n/** The operands back to front and the pieces `op` makes of them, or the\n *  result that says why it makes none. Reads the adapter and changes nothing. */\nfunction planBooleanOp(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  op: BooleanOp,\n  opts: BooleanOpOptions,\n): { entries: Entry[]; pieces: ResultPiece[] } | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  // Sorted ascending by `compareZ` so the first entry is the bottommost\n  // (back) member. `subtract` relies on this: it computes `back − union(rest)`.\n  let resolved: { id: NodeId; operand: BooleanOperand | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, operand: resolveOperand(adapter, id, opts) }));\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  const entries = resolved\n    .filter((e): e is Entry => e.operand != null)\n    .sort((a, b) => adapter.compareZ(a.id, b.id));\n\n  if (entries.length === 0) return { kind: 'noop', reason: 'no-paths' };\n  if (op === 'subtract' && entries.length < 2) {\n    return { kind: 'noop', reason: 'too-few-for-subtract' };\n  }\n  if (entries.length < 2) return { kind: 'noop', reason: 'no-paths' };\n\n  // Merge unites the operands that wear one fill; one whose paint is unknown is united with nothing.\n  const fillKey = (i: number): unknown => {\n    const { id, operand } = entries[i]!;\n    const paint = operand.paint ?? adapter.getPaint?.(id);\n    return paint ? JSON.stringify(paint.fill ?? null) : i;\n  };\n  const pieces = booleanPieces(op, entries.map((e) => e.operand.path), fillKey);\n  if (pieces.length === 0) return { kind: 'noop', reason: 'empty-result' };\n  return { entries, pieces };\n}\n\n/**\n * What {@link applyBooleanOp} would make of the selection, without minting a\n * node or committing anything: for drawing an operation before it is applied.\n */\nexport function previewBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpPreview {\n  const plan = planBooleanOp(adapter, [...adapter.getSelection()] as NodeId[], op, opts);\n  if ('kind' in plan) return plan;\n  return {\n    kind: 'pieces',\n    pieces: plan.pieces.map((piece) => {\n      const { id, operand } = plan.entries[piece.source]!;\n      return operand.paint ? { path: piece.path, sourceId: id, paint: operand.paint } : { path: piece.path, sourceId: id };\n    }),\n  };\n}\n\n/**\n * Run one Boolean operation over the selected paths and commit the result as a\n * single undoable batch.\n *\n * Operands are ordered back-to-front, which is what makes `subtract` mean\n * \"everything in front removed from the backmost shape\". Returns without\n * mutating anything when the selection holds no paths, or too few for the\n * requested operation. `opts.strokes` says what a stroked operand gives.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const plan = planBooleanOp(adapter, sel, op, opts);\n  if ('kind' in plan) return plan;\n  const { entries, pieces } = plan;\n  // Every source's slot, read before the scene is mutated.\n  const slots: (BooleanZOrder | undefined)[] =\n    entries.map((e) => locateChild(adapter, e.id) ?? undefined);\n  // A piece stands in for its own source: it is minted from that source, wears\n  // the paint a stroke folded into that source left it, and takes its slot.\n  const made = pieces.map((piece) => {\n    const { id, operand } = entries[piece.source]!;\n    return { node: adapter.createPathNode(piece.path, op, id, operand.paint), slot: slots[piece.source] };\n  });\n  const newNodes = made.map((m) => m.node);\n  const ops: Op[] = [];\n  // Capture the full node so the delete's `invert()` (an insert) restores\n  // every field on undo. The index is -1 for a source its parent does not list.\n  const captured = entries.map((e, i) => ({\n    node: adapter.getNode(e.id) ?? { id: e.id },\n    index: slots[i]?.index ?? -1,\n  }));\n  // Order by index DESC so reverse-then-invert (history's undo path)\n  // re-inserts ASC — each splice lands on a correctly-sized array\n  // instead of clamping high indices to a still-growing length.\n  captured.sort((a, b) => b.index - a.index);\n  for (const { node, index } of captured) ops.push(createDeleteOp({ node, index }));\n  for (const n of newNodes) ops.push(createInsertOp({ node: n }));\n  ops.push(...placementOps(made.map((m) => ({ id: m.node.id, slot: m.slot })), slots));\n  ops.push(createSetSelectionOp({\n    from: sel,\n    to: newNodes.map((n) => n.id as NodeId),\n  }));\n  dispatchApplyBatch(adapter, ops, LABEL[op]);\n\n  return { kind: 'applied', resultIds: newNodes.map((n) => n.id) };\n}\n"],"mappings":";;;;;;;;;;AAoGA,IAAMA,IAAmC;CACvC,OAAO;CACP,WAAW;CACX,UAAU;CACV,SAAS;CACT,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;AACT;AAoBA,SAASC,EACP,GACA,GACA,GACA,GAC6F;CAG7F,IAAIC;CACJ,IAAI;EACF,IAAWC,EAAI,KAAK,OAAQ;GAAE;GAAI,SAASC,EAAeC,GAASC,GAAIC,CAAI;EAAE,EAAE;CACjF,SAASC,GAAK;EACZ,IAAIA,aAAeC,GAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAOD;EAAI;EACnG,MAAMA;CACR;CACA,IAAME,IAAUR,EACb,QAAQ,MAAkB,EAAE,WAAW,IAAI,CAAC,CAC5C,MAAM,GAAG,MAAMG,EAAQ,SAASM,EAAE,IAAIC,EAAE,EAAE,CAAC;CAE9C,IAAIF,EAAQ,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAW;CACpE,IAAIG,MAAO,cAAcH,EAAQ,SAAS,GACxC,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAuB;CAExD,IAAIA,EAAQ,SAAS,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAW;CAQlE,IAAMI,IAASC,EAAcF,GAAIH,EAAQ,KAAK,MAAM,EAAE,QAAQ,IAAI,IALjD,MAAuB;EACtC,IAAM,EAAE,OAAI,eAAYA,EAAQM,IAC1BC,IAAQC,EAAQ,SAASb,EAAQ,WAAWC,CAAE;EACpD,OAAOW,IAAQ,KAAK,UAAUA,EAAM,QAAQ,IAAI,IAAID;CACtD,CAC4E;CAE5E,OADIF,EAAO,WAAW,IAAU;EAAE,MAAM;EAAQ,QAAQ;CAAe,IAChE;EAAE;EAAS;CAAO;AAC3B;AAMA,SAAgBK,EACd,GACA,GACA,IAAyB,CAAC,GACR;CAClB,IAAMC,IAAOnB,EAAcI,GAAS,CAAC,GAAGA,EAAQ,aAAa,CAAC,GAAeQ,GAAIN,CAAI;CAErF,OADI,UAAUa,IAAaA,IACpB;EACL,MAAM;EACN,QAAQA,EAAK,OAAO,KAAK,MAAU;GACjC,IAAM,EAAE,OAAI,eAAYA,EAAK,QAAQC,EAAM;GAC3C,OAAOH,EAAQ,QAAQ;IAAE,MAAMG,EAAM;IAAM,UAAUf;IAAI,OAAOY,EAAQ;GAAM,IAAI;IAAE,MAAMG,EAAM;IAAM,UAAUf;GAAG;EACrH,CAAC;CACH;AACF;AAWA,SAAgBgB,EACd,GACA,GACA,IAAyB,CAAC,GACT;CACjB,IAAMnB,IAAM,CAAC,GAAGE,EAAQ,aAAa,CAAC,GAChCe,IAAOnB,EAAcI,GAASF,GAAKU,GAAIN,CAAI;CACjD,IAAI,UAAUa,GAAM,OAAOA;CAC3B,IAAM,EAAE,YAAS,cAAWA,GAEtBG,IACJb,EAAQ,KAAK,MAAMc,EAAYnB,GAAS,EAAE,EAAE,KAAK,KAAA,CAAS,GAGtDoB,IAAOX,EAAO,KAAK,MAAU;EACjC,IAAM,EAAE,OAAI,eAAYJ,EAAQW,EAAM;EACtC,OAAO;GAAE,MAAMhB,EAAQ,eAAegB,EAAM,MAAMR,GAAIP,GAAIY,EAAQ,KAAK;GAAG,MAAMK,EAAMF,EAAM;EAAQ;CACtG,CAAC,GACKK,IAAWD,EAAK,KAAK,MAAME,EAAE,IAAI,GACjCC,IAAY,CAAC,GAGbC,IAAWnB,EAAQ,KAAK,GAAG,OAAO;EACtC,MAAML,EAAQ,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG;EAC1C,OAAOkB,EAAMP,EAAE,EAAE,SAAS;CAC5B,EAAE;CAIF,EAAS,MAAM,GAAG,MAAMJ,EAAE,QAAQD,EAAE,KAAK;CACzC,KAAK,IAAM,EAAE,SAAM,cAAWkB,GAAU,EAAI,KAAKC,EAAe;EAAE;EAAM;CAAM,CAAC,CAAC;CAChF,KAAK,IAAMC,KAAKL,GAAU,EAAI,KAAKM,EAAe,EAAE,MAAMD,EAAE,CAAC,CAAC;CAQ9D,OAPAH,EAAI,KAAK,GAAGK,EAAaR,EAAK,KAAK,OAAO;EAAE,IAAIE,EAAE,KAAK;EAAI,MAAMA,EAAE;CAAK,EAAE,GAAGJ,CAAK,CAAC,GACnFK,EAAI,KAAKM,EAAqB;EAC5B,MAAM/B;EACN,IAAIuB,EAAS,KAAK,MAAMK,EAAE,EAAY;CACxC,CAAC,CAAC,GACFI,EAAmB9B,GAASuB,GAAK5B,EAAMa,EAAG,GAEnC;EAAE,MAAM;EAAW,WAAWa,EAAS,KAAK,MAAMK,EAAE,EAAE;CAAE;AACjE"}
+{"version":3,"file":"booleans.js","names":[],"sources":["../../../../src/interactions/actions/booleans/booleans.ts"],"sourcesContent":["/**\n * Pure action core for path boolean operations. Resolves the current\n * selection into z-ordered paths, runs the chosen op, and dispatches a\n * single batch of `Op`s (delete sources + insert results + set selection).\n */\nimport type { Affine, Path } from '@weasel-js/geom';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport { resolveOperand, type BooleanOpOptions, type BooleanOperand } from './operands';\nimport { booleanPieces, type ResultPiece } from './pieces';\nimport { commitPieces } from './commit';\n\n/** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';\n\n/**\n * z-position descriptor for a path node. `parentId` is the direct parent\n * (or `null` for a top-level node); `index` is the position within that\n * parent's child order — never a global render index.\n */\n/** @internal */\nexport interface BooleanZOrder {\n  parentId: string | null;\n  index: number;\n}\n\n/** Adapter the hook and the pure core both consume. */\nexport interface BooleansAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  getWorldPath(id: NodeId): Path | undefined;\n  /**\n   * Optional: the text node behind `id`, for an id `getWorldPath` has no path\n   * for. Its glyph outlines (`textToPath`) become the operand, so text can be\n   * cut, united or intersected like any shape.\n   */\n  getTextSource?(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Optional: the paint the path node behind `id` wears. An operation told to\n   * count strokes (`BooleanOpOptions.strokes`) reads it to learn whether the\n   * node is stroked and whether it is filled; without it every operand is its\n   * path alone.\n   */\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. A counted world-width stroke is skewed and stretched\n   * with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Affine | null | undefined;\n  compareZ(a: NodeId, b: NodeId): number;\n  /**\n   * Mint a new node from a boolean-op result `Path`. `producedBy` names the\n   * op that synthesized it — adapters that store provenance (e.g. for a\n   * layer-panel icon) record it; others ignore the arg. `sourceId` is the\n   * source the result stands in for: the topmost, except that each piece of\n   * a Divide, Crop, Trim, or Merge names the topmost source it was cut from. Give the\n   * node that source's parent, or the kit's reorder cannot find it there.\n   * `paint` is passed when that source's stroke went into the geometry, and\n   * the node must wear it as given: wearing the source's stroke again would\n   * draw it twice. Without `paint`, give it that source's paint. The kit never\n   * reads a node's `data`: anything else the result should keep of its source,\n   * a name say, is the adapter's to copy from `sourceId`.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId, paint?: PathPaint): { id: string };\n  /**\n   * The full object for an id. The delete ops capture it, so their `invert`\n   * (an insert) restores the complete object on undo.\n   */\n  getNode(id: NodeId): { id: string } | undefined | null;\n  /**\n   * The tree. The kit reads each source's slot among its siblings through\n   * `getParent` and `getChildren`, and moves each result into the slot of\n   * the topmost source in its own source's parent through `setChildOrder`.\n   * `defaultCommitAdapter` supplies all three, and `getNode`.\n   */\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome reported back to callers (lets the hook surface no-op signals). */\nexport type BooleanOpResult =\n  | { kind: 'applied'; resultIds: string[] }\n  | { kind: 'noop'; reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result' }\n  /** A text operand had no outline geometry. Nothing was changed: an op that\n   *  quietly dropped the operand would commit a different shape than asked. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n  trim: 'Trim',\n  merge: 'Merge',\n};\n\n/** One path a Boolean operation would make. */\nexport interface BooleanPreviewPiece {\n  path: Path;\n  /** The source the piece stands in for; see `BooleansAdapter.createPathNode`. */\n  sourceId: NodeId;\n  /** Set when that source's stroke went into `path`: the paint the piece wears. */\n  paint?: PathPaint;\n}\n\n/** What {@link previewBooleanOp} answers: the pieces, or why there are none. */\nexport type BooleanOpPreview =\n  | { kind: 'pieces'; pieces: BooleanPreviewPiece[] }\n  | Exclude<BooleanOpResult, { kind: 'applied' }>;\n\n/** @internal A selected node and the operand it gives. */\nexport type BooleanEntry = { id: NodeId; operand: BooleanOperand };\ntype Entry = BooleanEntry;\n\n/** @internal The operands behind `sel`, back to front, or the result that\n *  says why there are too few. Reads the adapter and changes nothing. */\nexport function resolveEntries(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  op: BooleanOp,\n  opts: BooleanOpOptions,\n): Entry[] | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  // Sorted ascending by `compareZ` so the first entry is the bottommost\n  // (back) member. `subtract` relies on this: it computes `back − union(rest)`.\n  let resolved: { id: NodeId; operand: BooleanOperand | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, operand: resolveOperand(adapter, id, opts) }));\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  const entries = resolved\n    .filter((e): e is Entry => e.operand != null)\n    .sort((a, b) => adapter.compareZ(a.id, b.id));\n\n  if (entries.length === 0) return { kind: 'noop', reason: 'no-paths' };\n  if (op === 'subtract' && entries.length < 2) {\n    return { kind: 'noop', reason: 'too-few-for-subtract' };\n  }\n  if (entries.length < 2) return { kind: 'noop', reason: 'no-paths' };\n  return entries;\n}\n\n/** The operands back to front and the pieces `op` makes of them, or the\n *  result that says why it makes none. Reads the adapter and changes nothing. */\nfunction planBooleanOp(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  op: BooleanOp,\n  opts: BooleanOpOptions,\n): { entries: Entry[]; pieces: ResultPiece[] } | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  const entries = resolveEntries(adapter, sel, op, opts);\n  if ('kind' in entries) return entries;\n  // Merge unites the operands that wear one fill; one whose paint is unknown is united with nothing.\n  const fillKey = (i: number): unknown => {\n    const { id, operand } = entries[i]!;\n    const paint = operand.paint ?? adapter.getPaint?.(id);\n    return paint ? JSON.stringify(paint.fill ?? null) : i;\n  };\n  const pieces = booleanPieces(op, entries.map((e) => e.operand.path), fillKey);\n  if (pieces.length === 0) return { kind: 'noop', reason: 'empty-result' };\n  return { entries, pieces };\n}\n\n/**\n * What {@link applyBooleanOp} would make of the selection, without minting a\n * node or committing anything: for drawing an operation before it is applied.\n */\nexport function previewBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpPreview {\n  const plan = planBooleanOp(adapter, [...adapter.getSelection()] as NodeId[], op, opts);\n  if ('kind' in plan) return plan;\n  return {\n    kind: 'pieces',\n    pieces: plan.pieces.map((piece) => {\n      const { id, operand } = plan.entries[piece.source]!;\n      return operand.paint ? { path: piece.path, sourceId: id, paint: operand.paint } : { path: piece.path, sourceId: id };\n    }),\n  };\n}\n\n/**\n * Run one Boolean operation over the selected paths and commit the result as a\n * single undoable batch.\n *\n * Operands are ordered back-to-front, which is what makes `subtract` mean\n * \"everything in front removed from the backmost shape\". Returns without\n * mutating anything when the selection holds no paths, or too few for the\n * requested operation. `opts.strokes` says what a stroked operand gives.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const plan = planBooleanOp(adapter, sel, op, opts);\n  if ('kind' in plan) return plan;\n  const { entries, pieces } = plan;\n  const made = pieces.map((piece) => ({ path: piece.path, source: piece.source, producedBy: op }));\n  return { kind: 'applied', resultIds: commitPieces(adapter, sel, entries, made, LABEL[op]) };\n}\n"],"mappings":";;;;;;AA+FA,IAAM,QAAmC;CACvC,OAAO;CACP,WAAW;CACX,UAAU;CACV,SAAS;CACT,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;AACT;;;AAsBA,SAAgB,eACd,SACA,KACA,IACA,MACyD;CAGzD,IAAI;CACJ,IAAI;EACF,WAAW,IAAI,KAAK,QAAQ;GAAE;GAAI,SAAS,eAAe,SAAS,IAAI,IAAI;EAAE,EAAE;CACjF,SAAS,KAAK;EACZ,IAAI,eAAe,mBAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAO;EAAI;EACnG,MAAM;CACR;CACA,MAAM,UAAU,SACb,QAAQ,MAAkB,EAAE,WAAW,IAAI,CAAC,CAC5C,MAAM,GAAG,MAAM,QAAQ,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;CAE9C,IAAI,QAAQ,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAW;CACpE,IAAI,OAAO,cAAc,QAAQ,SAAS,GACxC,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAuB;CAExD,IAAI,QAAQ,SAAS,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAW;CAClE,OAAO;AACT;;;AAIA,SAAS,cACP,SACA,KACA,IACA,MAC6F;CAC7F,MAAM,UAAU,eAAe,SAAS,KAAK,IAAI,IAAI;CACrD,IAAI,UAAU,SAAS,OAAO;CAE9B,MAAM,WAAW,MAAuB;EACtC,MAAM,EAAE,IAAI,YAAY,QAAQ;EAChC,MAAM,QAAQ,QAAQ,SAAS,QAAQ,WAAW,EAAE;EACpD,OAAO,QAAQ,KAAK,UAAU,MAAM,QAAQ,IAAI,IAAI;CACtD;CACA,MAAM,SAAS,cAAc,IAAI,QAAQ,KAAK,MAAM,EAAE,QAAQ,IAAI,GAAG,OAAO;CAC5E,IAAI,OAAO,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAe;CACvE,OAAO;EAAE;EAAS;CAAO;AAC3B;;;;;AAMA,SAAgB,iBACd,SACA,IACA,OAAyB,CAAC,GACR;CAClB,MAAM,OAAO,cAAc,SAAS,CAAC,GAAG,QAAQ,aAAa,CAAC,GAAe,IAAI,IAAI;CACrF,IAAI,UAAU,MAAM,OAAO;CAC3B,OAAO;EACL,MAAM;EACN,QAAQ,KAAK,OAAO,KAAK,UAAU;GACjC,MAAM,EAAE,IAAI,YAAY,KAAK,QAAQ,MAAM;GAC3C,OAAO,QAAQ,QAAQ;IAAE,MAAM,MAAM;IAAM,UAAU;IAAI,OAAO,QAAQ;GAAM,IAAI;IAAE,MAAM,MAAM;IAAM,UAAU;GAAG;EACrH,CAAC;CACH;AACF;;;;;;;;;;AAWA,SAAgB,eACd,SACA,IACA,OAAyB,CAAC,GACT;CACjB,MAAM,MAAM,CAAC,GAAG,QAAQ,aAAa,CAAC;CACtC,MAAM,OAAO,cAAc,SAAS,KAAK,IAAI,IAAI;CACjD,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,EAAE,SAAS,WAAW;CAC5B,MAAM,OAAO,OAAO,KAAK,WAAW;EAAE,MAAM,MAAM;EAAM,QAAQ,MAAM;EAAQ,YAAY;CAAG,EAAE;CAC/F,OAAO;EAAE,MAAM;EAAW,WAAW,aAAa,SAAS,KAAK,SAAS,MAAM,MAAM,GAAG;CAAE;AAC5F"}

package/dist/interactions/actions/booleans/commit.js

@@ -0,0 +1,49 @@
+import { dispatchApplyBatch } from "../../../core/applyOps.js";
+import { locateChild } from "../../../core/ops/slot.js";
+import { createDeleteOp } from "../../../core/ops/delete.js";
+import { createInsertOp } from "../../../core/ops/create.js";
+import { createSetSelectionOp } from "../../../core/ops/select.js";
+import { placementOps } from "./placement.js";
+
+//#region src/interactions/actions/booleans/commit.ts
+/**
+* Replace every entry with `pieces` as one undoable batch, and select what
+* was made. Each piece is minted from its own source, wears the paint a stroke
+* folded into that source left it, and takes its slot. Returns the new ids.
+*/
+function commitPieces(adapter, sel, entries, pieces, label) {
+	const slots = entries.map((e) => locateChild(adapter, e.id) ?? void 0);
+	const made = pieces.map((piece) => {
+		const { id, operand } = entries[piece.source];
+		return {
+			node: adapter.createPathNode(piece.path, piece.producedBy, id, operand.paint),
+			slot: slots[piece.source]
+		};
+	});
+	const newNodes = made.map((m) => m.node);
+	const ops = [];
+	const captured = entries.map((e, i) => ({
+		node: adapter.getNode(e.id) ?? { id: e.id },
+		index: slots[i]?.index ?? -1
+	}));
+	captured.sort((a, b) => b.index - a.index);
+	for (const { node, index } of captured) ops.push(createDeleteOp({
+		node,
+		index
+	}));
+	for (const n of newNodes) ops.push(createInsertOp({ node: n }));
+	ops.push(...placementOps(made.map((m) => ({
+		id: m.node.id,
+		slot: m.slot
+	})), slots));
+	ops.push(createSetSelectionOp({
+		from: sel,
+		to: newNodes.map((n) => n.id)
+	}));
+	dispatchApplyBatch(adapter, ops, label);
+	return newNodes.map((n) => n.id);
+}
+
+//#endregion
+export { commitPieces };
+//# sourceMappingURL=commit.js.map

package/dist/interactions/actions/booleans/commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":[],"sources":["../../../../src/interactions/actions/booleans/commit.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\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 type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { BooleanEntry, BooleanOp, BooleansAdapter, BooleanZOrder } from './booleans';\nimport { placementOps } from './placement';\n\n/** One path to mint: the index of the source it stands in for, and the op it\n *  is recorded as made by. */\nexport interface BooleanCommitPiece {\n  path: Path;\n  source: number;\n  producedBy: BooleanOp;\n}\n\n/**\n * Replace every entry with `pieces` as one undoable batch, and select what\n * was made. Each piece is minted from its own source, wears the paint a stroke\n * folded into that source left it, and takes its slot. Returns the new ids.\n */\nexport function commitPieces(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  entries: readonly BooleanEntry[],\n  pieces: readonly BooleanCommitPiece[],\n  label: string,\n): string[] {\n  // Every source's slot, read before the scene is mutated.\n  const slots: (BooleanZOrder | undefined)[] =\n    entries.map((e) => locateChild(adapter, e.id) ?? undefined);\n  const made = pieces.map((piece) => {\n    const { id, operand } = entries[piece.source]!;\n    return { node: adapter.createPathNode(piece.path, piece.producedBy, id, operand.paint), slot: slots[piece.source] };\n  });\n  const newNodes = made.map((m) => m.node);\n  const ops: Op[] = [];\n  // Capture the full node so the delete's `invert()` (an insert) restores\n  // every field on undo. The index is -1 for a source its parent does not list.\n  const captured = entries.map((e, i) => ({\n    node: adapter.getNode(e.id) ?? { id: e.id },\n    index: slots[i]?.index ?? -1,\n  }));\n  // Order by index DESC so reverse-then-invert (history's undo path)\n  // re-inserts ASC — each splice lands on a correctly-sized array\n  // instead of clamping high indices to a still-growing length.\n  captured.sort((a, b) => b.index - a.index);\n  for (const { node, index } of captured) ops.push(createDeleteOp({ node, index }));\n  for (const n of newNodes) ops.push(createInsertOp({ node: n }));\n  ops.push(...placementOps(made.map((m) => ({ id: m.node.id, slot: m.slot })), slots));\n  ops.push(createSetSelectionOp({ from: sel, to: newNodes.map((n) => n.id as NodeId) }));\n  dispatchApplyBatch(adapter, ops, label);\n  return newNodes.map((n) => n.id);\n}\n"],"mappings":";;;;;;;;;;;;;AAwBA,SAAgB,aACd,SACA,KACA,SACA,QACA,OACU;CAEV,MAAM,QACJ,QAAQ,KAAK,MAAM,YAAY,SAAS,EAAE,EAAE,KAAK,MAAS;CAC5D,MAAM,OAAO,OAAO,KAAK,UAAU;EACjC,MAAM,EAAE,IAAI,YAAY,QAAQ,MAAM;EACtC,OAAO;GAAE,MAAM,QAAQ,eAAe,MAAM,MAAM,MAAM,YAAY,IAAI,QAAQ,KAAK;GAAG,MAAM,MAAM,MAAM;EAAQ;CACpH,CAAC;CACD,MAAM,WAAW,KAAK,KAAK,MAAM,EAAE,IAAI;CACvC,MAAM,MAAY,CAAC;CAGnB,MAAM,WAAW,QAAQ,KAAK,GAAG,OAAO;EACtC,MAAM,QAAQ,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG;EAC1C,OAAO,MAAM,EAAE,EAAE,SAAS;CAC5B,EAAE;CAIF,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;CACzC,KAAK,MAAM,EAAE,MAAM,WAAW,UAAU,IAAI,KAAK,eAAe;EAAE;EAAM;CAAM,CAAC,CAAC;CAChF,KAAK,MAAM,KAAK,UAAU,IAAI,KAAK,eAAe,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9D,IAAI,KAAK,GAAG,aAAa,KAAK,KAAK,OAAO;EAAE,IAAI,EAAE,KAAK;EAAI,MAAM,EAAE;CAAK,EAAE,GAAG,KAAK,CAAC;CACnF,IAAI,KAAK,qBAAqB;EAAE,MAAM;EAAK,IAAI,SAAS,KAAK,MAAM,EAAE,EAAY;CAAE,CAAC,CAAC;CACrF,mBAAmB,SAAS,KAAK,KAAK;CACtC,OAAO,SAAS,KAAK,MAAM,EAAE,EAAE;AACjC"}

package/dist/interactions/actions/booleans/custom.js

@@ -0,0 +1,48 @@
+import { commitPieces } from "./commit.js";
+import { resolveEntries } from "./booleans.js";
+
+//#region src/interactions/actions/booleans/custom.ts
+/**
+* The operands the selected nodes give a Boolean operation, back to front, as
+* the built-in operations resolve them; or why there are fewer than two.
+* Reads the adapter and changes nothing.
+*/
+function resolveBooleanOperands(adapter, opts = {}) {
+	const selection = [...adapter.getSelection()];
+	const entries = resolveEntries(adapter, selection, "divide", opts);
+	if ("kind" in entries) return entries;
+	return {
+		selection,
+		sources: entries.map(({ id, operand: { path, paint } }) => paint ? {
+			id,
+			path,
+			paint
+		} : {
+			id,
+			path
+		})
+	};
+}
+/**
+* Replace `operands`' sources with `pieces` as one undo step named `label`,
+* and select what was made. Each piece is minted from the source it names, as
+* `BooleansAdapter.createPathNode` says, and stacks in that source's slot. An
+* empty `pieces` deletes every source.
+*/
+function commitBooleanPieces(adapter, operands, pieces, label) {
+	const entries = operands.sources.map(({ id, path, paint }) => ({
+		id,
+		operand: paint ? {
+			path,
+			paint
+		} : { path }
+	}));
+	return {
+		kind: "applied",
+		resultIds: commitPieces(adapter, operands.selection, entries, pieces, label)
+	};
+}
+
+//#endregion
+export { commitBooleanPieces, resolveBooleanOperands };
+//# sourceMappingURL=custom.js.map

package/dist/interactions/actions/booleans/custom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.js","names":[],"sources":["../../../../src/interactions/actions/booleans/custom.ts"],"sourcesContent":["/**\n * A Boolean operation of the caller's own over the selection: the operands the\n * kit resolves from it, and the commit that replaces them with the pieces the\n * caller cut from those operands, as one undo step.\n */\nimport type { Path } from '@weasel-js/geom';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { NodeId } from 'core/scene/types';\nimport { resolveEntries, type BooleanEntry, type BooleanOpResult, type BooleansAdapter } from './booleans';\nimport { commitPieces, type BooleanCommitPiece } from './commit';\nimport type { BooleanOpOptions } from './operands';\n\n/** One selected node's operand. */\nexport interface BooleanSource {\n  id: NodeId;\n  /** In world: its path, its glyph outlines, or the region its ink covers\n   *  once a stroke is counted. */\n  path: Path;\n  /** Set when a stroke went into `path`: what a piece standing in for this\n   *  source wears. */\n  paint?: PathPaint;\n}\n\n/** What {@link resolveBooleanOperands} answers. */\nexport interface BooleanOperands {\n  /** The selection the operands were read from. */\n  selection: readonly NodeId[];\n  /** Back to front. */\n  sources: readonly BooleanSource[];\n}\n\n/**\n * The operands the selected nodes give a Boolean operation, back to front, as\n * the built-in operations resolve them; or why there are fewer than two.\n * Reads the adapter and changes nothing.\n */\nexport function resolveBooleanOperands(\n  adapter: BooleansAdapter,\n  opts: BooleanOpOptions = {},\n): BooleanOperands | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  const selection = [...adapter.getSelection()] as NodeId[];\n  const entries = resolveEntries(adapter, selection, 'divide', opts);\n  if ('kind' in entries) return entries;\n  return {\n    selection,\n    sources: entries.map(({ id, operand: { path, paint } }) => (paint ? { id, path, paint } : { id, path })),\n  };\n}\n\n/**\n * Replace `operands`' sources with `pieces` as one undo step named `label`,\n * and select what was made. Each piece is minted from the source it names, as\n * `BooleansAdapter.createPathNode` says, and stacks in that source's slot. An\n * empty `pieces` deletes every source.\n */\nexport function commitBooleanPieces(\n  adapter: BooleansAdapter,\n  operands: BooleanOperands,\n  pieces: readonly BooleanCommitPiece[],\n  label: string,\n): Extract<BooleanOpResult, { kind: 'applied' }> {\n  const entries = operands.sources.map(({ id, path, paint }): BooleanEntry => ({\n    id,\n    operand: paint ? { path, paint } : { path },\n  }));\n  return { kind: 'applied', resultIds: commitPieces(adapter, operands.selection, entries, pieces, label) };\n}\n\nexport type { BooleanCommitPiece };\n"],"mappings":";;;;;;;;;AAoCA,SAAgB,uBACd,SACA,OAAyB,CAAC,GACuC;CACjE,MAAM,YAAY,CAAC,GAAG,QAAQ,aAAa,CAAC;CAC5C,MAAM,UAAU,eAAe,SAAS,WAAW,UAAU,IAAI;CACjE,IAAI,UAAU,SAAS,OAAO;CAC9B,OAAO;EACL;EACA,SAAS,QAAQ,KAAK,EAAE,IAAI,SAAS,EAAE,MAAM,cAAe,QAAQ;GAAE;GAAI;GAAM;EAAM,IAAI;GAAE;GAAI;EAAK,CAAE;CACzG;AACF;;;;;;;AAQA,SAAgB,oBACd,SACA,UACA,QACA,OAC+C;CAC/C,MAAM,UAAU,SAAS,QAAQ,KAAK,EAAE,IAAI,MAAM,aAA2B;EAC3E;EACA,SAAS,QAAQ;GAAE;GAAM;EAAM,IAAI,EAAE,KAAK;CAC5C,EAAE;CACF,OAAO;EAAE,MAAM;EAAW,WAAW,aAAa,SAAS,SAAS,WAAW,SAAS,QAAQ,KAAK;CAAE;AACzG"}

package/dist/interactions/actions/booleans/operands.js

@@ -1,40 +1,51 @@
-import { strokeRegion as e } from "../outlines/strokeRegion.js";
-import { textToPath as t, textToPathsByPaint as n } from "@weasel-js/text";
-import { pathUnion as r } from "@weasel-js/geom/booleans";
+import { strokeRegion } from "../outlines/strokeRegion.js";
+import { textToPath, textToPathsByPaint } from "@weasel-js/text";
+import { pathUnion } from "@weasel-js/geom/booleans";
+
 //#region src/interactions/actions/booleans/operands.ts
-function i(t, n, i, a) {
-	let { path: o, fill: s } = t, { stroke: c } = t, l = c?.paint;
-	if (!c || l == null || n === "ignore" || n === "unfilled" && s !== null) return { path: o };
-	let u = e(o, c, i, a === void 0 ? {} : { scale: a });
-	return u.commands.length === 0 ? { path: o } : {
-		path: s === null ? u : r(o, u),
-		paint: { fill: s ?? { paint: l } }
+function inkOf(source, strokes, frame, scale) {
+	const { path, fill } = source;
+	const { stroke } = source;
+	const strokePaint = stroke?.paint;
+	if (!stroke || strokePaint == null) return { path };
+	if (strokes === "ignore" || strokes === "unfilled" && fill !== null) return { path };
+	const ribbon = strokeRegion(path, stroke, frame, scale === void 0 ? {} : { scale });
+	if (ribbon.commands.length === 0) return { path };
+	return {
+		path: fill !== null ? pathUnion(path, ribbon) : ribbon,
+		paint: { fill: fill ?? { paint: strokePaint } }
 	};
 }
-function a(e, a, { strokes: o = "ignore", scale: s }) {
-	let c = e.getWorldPath(a);
-	if (c) {
-		let t = o === "ignore" ? void 0 : e.getPaint?.(a);
-		return t ? i({
-			path: c,
-			...t
-		}, o, e.getStrokeFrame?.(a), s) : { path: c };
+/**
+* The operand behind `id`, or `undefined` for a node that is not one: a group,
+* blank text, anything the adapter has neither a path nor text for. Throws
+* `TextOutlinesError` for text whose face has no outlines.
+*/
+function resolveOperand(adapter, id, { strokes = "ignore", scale }) {
+	const path = adapter.getWorldPath(id);
+	if (path) {
+		const paint = strokes === "ignore" ? void 0 : adapter.getPaint?.(id);
+		return paint ? inkOf({
+			path,
+			...paint
+		}, strokes, adapter.getStrokeFrame?.(id), scale) : { path };
 	}
-	let l = e.getTextSource?.(a);
-	if (!l) return;
-	if (o === "ignore") {
-		let e = t(l.data, l.pose);
-		return e.commands.length > 0 ? { path: e } : void 0;
+	const text = adapter.getTextSource?.(id);
+	if (!text) return void 0;
+	if (strokes === "ignore") {
+		const glyphs = textToPath(text.data, text.pose);
+		return glyphs.commands.length > 0 ? { path: glyphs } : void 0;
 	}
-	let u = n(l.data, l.pose).map((t) => i(t, o, e.getStrokeFrame?.(a), s));
-	if (u.length === 0) return;
-	let d = u.find((e) => e.paint)?.paint, f = u.length === 1 ? u[0].path : r(...u.map((e) => e.path));
-	return d ? {
-		path: f,
-		paint: d
-	} : { path: f };
+	const inks = textToPathsByPaint(text.data, text.pose).map((p) => inkOf(p, strokes, adapter.getStrokeFrame?.(id), scale));
+	if (inks.length === 0) return void 0;
+	const paint = inks.find((ink) => ink.paint)?.paint;
+	const whole = inks.length === 1 ? inks[0].path : pathUnion(...inks.map((ink) => ink.path));
+	return paint ? {
+		path: whole,
+		paint
+	} : { path: whole };
 }
-//#endregion
-export { a as resolveOperand };
 
+//#endregion
+export { resolveOperand };
 //# sourceMappingURL=operands.js.map

package/dist/interactions/actions/booleans/operands.js.map

@@ -1 +1 @@
-{"version":3,"file":"operands.js","names":["inkOf","source","strokePaint","stroke","strokes","fill","ribbon","strokeRegion","path","frame","scale","pathUnion","resolveOperand","adapter","id","paint","text","glyphs","textToPath","inks","textToPathsByPaint","p","ink","whole"],"sources":["../../../../src/interactions/actions/booleans/operands.ts"],"sourcesContent":["/**\n * What each selected node gives a Boolean operation: its path, its glyph\n * outlines, or the region its ink covers once a stroke is counted.\n */\nimport type { Affine, Path, Scale2 } from '@weasel-js/geom';\nimport { pathUnion } from '@weasel-js/geom/booleans';\nimport { textToPath, textToPathsByPaint } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { NodeId } from 'core/scene/types';\nimport type { PaintedPath } from '../outlines/replaceWithPaths';\nimport { strokeRegion } from '../outlines/strokeRegion';\nimport type { BooleansAdapter } from './booleans';\n\n/**\n * What a stroked operand gives a Boolean operation.\n *\n * - `'ignore'`: its path, as though it had no stroke.\n * - `'unfilled'`: the region its stroke covers when it has no fill, as a line\n *   or an open pencil stroke has none; its path when it is filled.\n * - `'include'`: what it paints — its fill and its stroke together, or the\n *   stroke alone when it has no fill.\n *\n * Any mode but `'ignore'` needs {@link BooleansAdapter.getPaint}.\n */\nexport type BooleanStrokes = 'ignore' | 'unfilled' | 'include';\n\n/** Options for `applyBooleanOp`. */\nexport interface BooleanOpOptions {\n  /** Default `'ignore'`. */\n  strokes?: BooleanStrokes;\n  /** The view scale a `{ px }` stroke width resolves against: one number, or\n   *  the view's own scale per axis. Default 1. */\n  scale?: number | Scale2;\n}\n\n/** @internal */\nexport interface BooleanOperand {\n  path: Path;\n  /** Set when a stroke went into `path`: what a result standing in for this\n   *  operand wears, the stroke being part of its shape now. */\n  paint?: PathPaint;\n}\n\nfunction inkOf(\n  source: PaintedPath,\n  strokes: BooleanStrokes,\n  frame: Affine | null | undefined,\n  scale: number | Scale2 | undefined,\n): BooleanOperand {\n  const { path, fill } = source;\n  const { stroke } = source;\n  const strokePaint = stroke?.paint;\n  if (!stroke || strokePaint == null) return { path };\n  if (strokes === 'ignore' || (strokes === 'unfilled' && fill !== null)) return { path };\n  const ribbon = strokeRegion(path, stroke, frame, scale === undefined ? {} : { scale });\n  if (ribbon.commands.length === 0) return { path };\n  return { path: fill !== null ? pathUnion(path, ribbon) : ribbon, paint: { fill: fill ?? { paint: strokePaint } } };\n}\n\n/**\n * The operand behind `id`, or `undefined` for a node that is not one: a group,\n * blank text, anything the adapter has neither a path nor text for. Throws\n * `TextOutlinesError` for text whose face has no outlines.\n */\nexport function resolveOperand(\n  adapter: BooleansAdapter,\n  id: NodeId,\n  { strokes = 'ignore', scale }: BooleanOpOptions,\n): BooleanOperand | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) {\n    const paint = strokes === 'ignore' ? undefined : adapter.getPaint?.(id);\n    return paint ? inkOf({ path, ...paint }, strokes, adapter.getStrokeFrame?.(id), scale) : { path };\n  }\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  if (strokes === 'ignore') {\n    const glyphs = textToPath(text.data, text.pose);\n    return glyphs.commands.length > 0 ? { path: glyphs } : undefined;\n  }\n  const inks = textToPathsByPaint(text.data, text.pose).map((p) => inkOf(p, strokes, adapter.getStrokeFrame?.(id), scale));\n  if (inks.length === 0) return undefined;\n  const paint = inks.find((ink) => ink.paint)?.paint;\n  const whole = inks.length === 1 ? inks[0]!.path : pathUnion(...inks.map((ink) => ink.path));\n  return paint ? { path: whole, paint } : { path: whole };\n}\n"],"mappings":";;;;AA2CA,SAASA,EACP,GACA,GACA,GACA,GACgB;CAChB,IAAM,EAAE,SAAM,YAASC,GACjB,EAAE,cAAWA,GACbC,IAAcC,GAAQ;CAE5B,IADI,CAACA,KAAUD,KAAe,QAC1BE,MAAY,YAAaA,MAAY,cAAcC,MAAS,MAAO,OAAO,EAAE,QAAK;CACrF,IAAMC,IAASC,EAAaC,GAAML,GAAQM,GAAOC,MAAU,KAAA,IAAY,CAAC,IAAI,EAAE,SAAM,CAAC;CAErF,OADIJ,EAAO,SAAS,WAAW,IAAU,EAAE,QAAK,IACzC;EAAE,MAAMD,MAAS,OAAiCC,IAA1BK,EAAUH,GAAMF,CAAM;EAAY,OAAO,EAAE,MAAMD,KAAQ,EAAE,OAAOH,EAAY,EAAE;CAAE;AACnH;AAOA,SAAgBU,EACd,GACA,GACA,EAAE,aAAU,UAAU,YACM;CAC5B,IAAMJ,IAAOK,EAAQ,aAAaC,CAAE;CACpC,IAAIN,GAAM;EACR,IAAMO,IAAQX,MAAY,WAAW,KAAA,IAAYS,EAAQ,WAAWC,CAAE;EACtE,OAAOC,IAAQf,EAAM;GAAE;GAAM,GAAGe;EAAM,GAAGX,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,IAAI,EAAE,QAAK;CAClG;CACA,IAAMM,IAAOH,EAAQ,gBAAgBC,CAAE;CACvC,IAAI,CAACE,GAAM;CACX,IAAIZ,MAAY,UAAU;EACxB,IAAMa,IAASC,EAAWF,EAAK,MAAMA,EAAK,IAAI;EAC9C,OAAOC,EAAO,SAAS,SAAS,IAAI,EAAE,MAAMA,EAAO,IAAI,KAAA;CACzD;CACA,IAAME,IAAOC,EAAmBJ,EAAK,MAAMA,EAAK,IAAI,CAAC,CAAC,KAAK,MAAMhB,EAAMqB,GAAGjB,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,CAAC;CACvH,IAAIS,EAAK,WAAW,GAAG;CACvB,IAAMJ,IAAQI,EAAK,MAAM,MAAQG,EAAI,KAAK,CAAC,EAAE,OACvCC,IAAQJ,EAAK,WAAW,IAAIA,EAAK,EAAE,CAAE,OAAOR,EAAU,GAAGQ,EAAK,KAAK,MAAQG,EAAI,IAAI,CAAC;CAC1F,OAAOP,IAAQ;EAAE,MAAMQ;EAAO;CAAM,IAAI,EAAE,MAAMA,EAAM;AACxD"}
+{"version":3,"file":"operands.js","names":[],"sources":["../../../../src/interactions/actions/booleans/operands.ts"],"sourcesContent":["/**\n * What each selected node gives a Boolean operation: its path, its glyph\n * outlines, or the region its ink covers once a stroke is counted.\n */\nimport type { Affine, Path, Scale2 } from '@weasel-js/geom';\nimport { pathUnion } from '@weasel-js/geom/booleans';\nimport { textToPath, textToPathsByPaint } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { NodeId } from 'core/scene/types';\nimport type { PaintedPath } from '../outlines/replaceWithPaths';\nimport { strokeRegion } from '../outlines/strokeRegion';\nimport type { BooleansAdapter } from './booleans';\n\n/**\n * What a stroked operand gives a Boolean operation.\n *\n * - `'ignore'`: its path, as though it had no stroke.\n * - `'unfilled'`: the region its stroke covers when it has no fill, as a line\n *   or an open pencil stroke has none; its path when it is filled.\n * - `'include'`: what it paints — its fill and its stroke together, or the\n *   stroke alone when it has no fill.\n *\n * Any mode but `'ignore'` needs {@link BooleansAdapter.getPaint}.\n */\nexport type BooleanStrokes = 'ignore' | 'unfilled' | 'include';\n\n/** Options for `applyBooleanOp`. */\nexport interface BooleanOpOptions {\n  /** Default `'ignore'`. */\n  strokes?: BooleanStrokes;\n  /** The view scale a `{ px }` stroke width resolves against: one number, or\n   *  the view's own scale per axis. Default 1. */\n  scale?: number | Scale2;\n}\n\n/** @internal */\nexport interface BooleanOperand {\n  path: Path;\n  /** Set when a stroke went into `path`: what a result standing in for this\n   *  operand wears, the stroke being part of its shape now. */\n  paint?: PathPaint;\n}\n\nfunction inkOf(\n  source: PaintedPath,\n  strokes: BooleanStrokes,\n  frame: Affine | null | undefined,\n  scale: number | Scale2 | undefined,\n): BooleanOperand {\n  const { path, fill } = source;\n  const { stroke } = source;\n  const strokePaint = stroke?.paint;\n  if (!stroke || strokePaint == null) return { path };\n  if (strokes === 'ignore' || (strokes === 'unfilled' && fill !== null)) return { path };\n  const ribbon = strokeRegion(path, stroke, frame, scale === undefined ? {} : { scale });\n  if (ribbon.commands.length === 0) return { path };\n  return { path: fill !== null ? pathUnion(path, ribbon) : ribbon, paint: { fill: fill ?? { paint: strokePaint } } };\n}\n\n/**\n * The operand behind `id`, or `undefined` for a node that is not one: a group,\n * blank text, anything the adapter has neither a path nor text for. Throws\n * `TextOutlinesError` for text whose face has no outlines.\n */\nexport function resolveOperand(\n  adapter: BooleansAdapter,\n  id: NodeId,\n  { strokes = 'ignore', scale }: BooleanOpOptions,\n): BooleanOperand | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) {\n    const paint = strokes === 'ignore' ? undefined : adapter.getPaint?.(id);\n    return paint ? inkOf({ path, ...paint }, strokes, adapter.getStrokeFrame?.(id), scale) : { path };\n  }\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  if (strokes === 'ignore') {\n    const glyphs = textToPath(text.data, text.pose);\n    return glyphs.commands.length > 0 ? { path: glyphs } : undefined;\n  }\n  const inks = textToPathsByPaint(text.data, text.pose).map((p) => inkOf(p, strokes, adapter.getStrokeFrame?.(id), scale));\n  if (inks.length === 0) return undefined;\n  const paint = inks.find((ink) => ink.paint)?.paint;\n  const whole = inks.length === 1 ? inks[0]!.path : pathUnion(...inks.map((ink) => ink.path));\n  return paint ? { path: whole, paint } : { path: whole };\n}\n"],"mappings":";;;;;AA2CA,SAAS,MACP,QACA,SACA,OACA,OACgB;CAChB,MAAM,EAAE,MAAM,SAAS;CACvB,MAAM,EAAE,WAAW;CACnB,MAAM,cAAc,QAAQ;CAC5B,IAAI,CAAC,UAAU,eAAe,MAAM,OAAO,EAAE,KAAK;CAClD,IAAI,YAAY,YAAa,YAAY,cAAc,SAAS,MAAO,OAAO,EAAE,KAAK;CACrF,MAAM,SAAS,aAAa,MAAM,QAAQ,OAAO,UAAU,SAAY,CAAC,IAAI,EAAE,MAAM,CAAC;CACrF,IAAI,OAAO,SAAS,WAAW,GAAG,OAAO,EAAE,KAAK;CAChD,OAAO;EAAE,MAAM,SAAS,OAAO,UAAU,MAAM,MAAM,IAAI;EAAQ,OAAO,EAAE,MAAM,QAAQ,EAAE,OAAO,YAAY,EAAE;CAAE;AACnH;;;;;;AAOA,SAAgB,eACd,SACA,IACA,EAAE,UAAU,UAAU,SACM;CAC5B,MAAM,OAAO,QAAQ,aAAa,EAAE;CACpC,IAAI,MAAM;EACR,MAAM,QAAQ,YAAY,WAAW,SAAY,QAAQ,WAAW,EAAE;EACtE,OAAO,QAAQ,MAAM;GAAE;GAAM,GAAG;EAAM,GAAG,SAAS,QAAQ,iBAAiB,EAAE,GAAG,KAAK,IAAI,EAAE,KAAK;CAClG;CACA,MAAM,OAAO,QAAQ,gBAAgB,EAAE;CACvC,IAAI,CAAC,MAAM,OAAO;CAClB,IAAI,YAAY,UAAU;EACxB,MAAM,SAAS,WAAW,KAAK,MAAM,KAAK,IAAI;EAC9C,OAAO,OAAO,SAAS,SAAS,IAAI,EAAE,MAAM,OAAO,IAAI;CACzD;CACA,MAAM,OAAO,mBAAmB,KAAK,MAAM,KAAK,IAAI,CAAC,CAAC,KAAK,MAAM,MAAM,GAAG,SAAS,QAAQ,iBAAiB,EAAE,GAAG,KAAK,CAAC;CACvH,IAAI,KAAK,WAAW,GAAG,OAAO;CAC9B,MAAM,QAAQ,KAAK,MAAM,QAAQ,IAAI,KAAK,CAAC,EAAE;CAC7C,MAAM,QAAQ,KAAK,WAAW,IAAI,KAAK,EAAE,CAAE,OAAO,UAAU,GAAG,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC;CAC1F,OAAO,QAAQ;EAAE,MAAM;EAAO;CAAM,IAAI,EAAE,MAAM,MAAM;AACxD"}

package/dist/interactions/actions/booleans/pieces.js

@@ -1,45 +1,51 @@
-import { pathCropPieces as e, pathDividePieces as t, pathExclude as n, pathIntersect as r, pathMerge as i, pathSubtract as a, pathTrim as o, pathUnion as s } from "@weasel-js/geom/booleans";
+import { pathCropPieces, pathDividePieces, pathExclude, pathIntersect, pathMerge, pathSubtract, pathTrim, pathUnion } from "@weasel-js/geom/booleans";
+
 //#region src/interactions/actions/booleans/pieces.ts
-function c(e) {
-	return e.map((e) => ({
-		path: e.path,
-		source: e.sources[e.sources.length - 1]
+/** A piece stands in for the topmost input left in it. */
+function bySource(pieces) {
+	return pieces.map((p) => ({
+		path: p.path,
+		source: p.sources[p.sources.length - 1]
 	}));
 }
-function l(l, u, d) {
-	let f = u.length - 1, p = (e) => [{
-		path: e,
-		source: f
-	}], m;
-	switch (l) {
+/** Run `op` over `paths`, back to front, dropping empty results. `mergeKey`
+*  answers alike for the paths a Merge unites. */
+function booleanPieces(op, paths, mergeKey) {
+	const top = paths.length - 1;
+	const whole = (path) => [{
+		path,
+		source: top
+	}];
+	let pieces;
+	switch (op) {
 		case "union":
-			m = p(s(...u));
+			pieces = whole(pathUnion(...paths));
 			break;
 		case "intersect":
-			m = p(r(...u));
+			pieces = whole(pathIntersect(...paths));
 			break;
 		case "exclude":
-			m = p(n(...u));
+			pieces = whole(pathExclude(...paths));
 			break;
 		case "subtract": {
-			let e = u.length === 2 ? u[1] : s(...u.slice(1));
-			m = p(a(u[0], e));
+			const front = paths.length === 2 ? paths[1] : pathUnion(...paths.slice(1));
+			pieces = whole(pathSubtract(paths[0], front));
 			break;
 		}
 		case "divide":
-			m = c(t(...u));
+			pieces = bySource(pathDividePieces(...paths));
 			break;
 		case "crop":
-			m = c(e(...u));
+			pieces = bySource(pathCropPieces(...paths));
 			break;
 		case "trim":
-			m = c(o(...u));
+			pieces = bySource(pathTrim(...paths));
 			break;
-		case "merge": m = c(i(u, d));
+		case "merge": pieces = bySource(pathMerge(paths, mergeKey));
 	}
-	return m.filter((e) => e.path.commands.length > 0);
+	return pieces.filter((p) => p.path.commands.length > 0);
 }
-//#endregion
-export { l as booleanPieces };
 
+//#endregion
+export { booleanPieces };
 //# sourceMappingURL=pieces.js.map

package/dist/interactions/actions/booleans/pieces.js.map

@@ -1 +1 @@
-{"version":3,"file":"pieces.js","names":["bySource","pieces","p","booleanPieces","top","paths","whole","op","pathUnion","pathIntersect","pathExclude","front","pathSubtract","pathDividePieces","pathCropPieces","pathTrim","pathMerge","mergeKey"],"sources":["../../../../src/interactions/actions/booleans/pieces.ts"],"sourcesContent":["import {\n  pathUnion,\n  pathIntersect,\n  pathSubtract,\n  pathExclude,\n  pathDividePieces,\n  pathCropPieces,\n  pathTrim,\n  pathMerge,\n  type BooleanPiece,\n} from '@weasel-js/geom/booleans';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport type { BooleanOp } from './booleans';\n\n/** One result path, and the operand it stands in for: an index into the\n *  operands, back to front. */\nexport interface ResultPiece {\n  path: PolygonPath;\n  source: number;\n}\n\n/** A piece stands in for the topmost input left in it. */\nfunction bySource(pieces: BooleanPiece[]): ResultPiece[] {\n  return pieces.map((p) => ({ path: p.path, source: p.sources[p.sources.length - 1]! }));\n}\n\n/** Run `op` over `paths`, back to front, dropping empty results. `mergeKey`\n *  answers alike for the paths a Merge unites. */\nexport function booleanPieces(op: BooleanOp, paths: Path[], mergeKey: (index: number) => unknown): ResultPiece[] {\n  const top = paths.length - 1;\n  const whole = (path: PolygonPath): ResultPiece[] => [{ path, source: top }];\n  let pieces: ResultPiece[];\n  switch (op) {\n    case 'union':     pieces = whole(pathUnion(...paths)); break;\n    case 'intersect': pieces = whole(pathIntersect(...paths)); break;\n    case 'exclude':   pieces = whole(pathExclude(...paths)); break;\n    case 'subtract': {\n      // Illustrator \"Minus Front\": back − union(everything in front).\n      const front = paths.length === 2 ? paths[1]! : pathUnion(...paths.slice(1));\n      pieces = whole(pathSubtract(paths[0]!, front));\n      break;\n    }\n    case 'divide':    pieces = bySource(pathDividePieces(...paths)); break;\n    // Illustrator \"Crop\": every source below the topmost, clipped to it; the\n    // topmost is consumed as the mask.\n    case 'crop':      pieces = bySource(pathCropPieces(...paths)); break;\n    case 'trim':      pieces = bySource(pathTrim(...paths)); break;\n    case 'merge':     pieces = bySource(pathMerge(paths, mergeKey)); break;\n  }\n  return pieces.filter((p) => p.path.commands.length > 0);\n}\n"],"mappings":";;AAsBA,SAASA,EAAS,GAAuC;CACvD,OAAOC,EAAO,KAAK,OAAO;EAAE,MAAMC,EAAE;EAAM,QAAQA,EAAE,QAAQA,EAAE,QAAQ,SAAS;CAAI,EAAE;AACvF;AAIA,SAAgBC,EAAc,GAAe,GAAe,GAAqD;CAC/G,IAAMC,IAAMC,EAAM,SAAS,GACrBC,KAAS,MAAqC,CAAC;EAAE;EAAM,QAAQF;CAAI,CAAC,GACtEH;CACJ,QAAQM,GAAR;EACE,KAAK;GAAa,IAASD,EAAME,EAAU,GAAGH,CAAK,CAAC;GAAG;EACvD,KAAK;GAAa,IAASC,EAAMG,EAAc,GAAGJ,CAAK,CAAC;GAAG;EAC3D,KAAK;GAAa,IAASC,EAAMI,EAAY,GAAGL,CAAK,CAAC;GAAG;EACzD,KAAK,YAAY;GAEf,IAAMM,IAAQN,EAAM,WAAW,IAAIA,EAAM,KAAMG,EAAU,GAAGH,EAAM,MAAM,CAAC,CAAC;GAC1E,IAASC,EAAMM,EAAaP,EAAM,IAAKM,CAAK,CAAC;GAC7C;EACF;EACA,KAAK;GAAa,IAASX,EAASa,EAAiB,GAAGR,CAAK,CAAC;GAAG;EAGjE,KAAK;GAAa,IAASL,EAASc,EAAe,GAAGT,CAAK,CAAC;GAAG;EAC/D,KAAK;GAAa,IAASL,EAASe,EAAS,GAAGV,CAAK,CAAC;GAAG;EACzD,KAAK,SAAa,IAASL,EAASgB,EAAUX,GAAOY,CAAQ,CAAC;CAChE;CACA,OAAOhB,EAAO,QAAQ,MAAMC,EAAE,KAAK,SAAS,SAAS,CAAC;AACxD"}
+{"version":3,"file":"pieces.js","names":[],"sources":["../../../../src/interactions/actions/booleans/pieces.ts"],"sourcesContent":["import {\n  pathUnion,\n  pathIntersect,\n  pathSubtract,\n  pathExclude,\n  pathDividePieces,\n  pathCropPieces,\n  pathTrim,\n  pathMerge,\n  type BooleanPiece,\n} from '@weasel-js/geom/booleans';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport type { BooleanOp } from './booleans';\n\n/** One result path, and the operand it stands in for: an index into the\n *  operands, back to front. */\nexport interface ResultPiece {\n  path: PolygonPath;\n  source: number;\n}\n\n/** A piece stands in for the topmost input left in it. */\nfunction bySource(pieces: BooleanPiece[]): ResultPiece[] {\n  return pieces.map((p) => ({ path: p.path, source: p.sources[p.sources.length - 1]! }));\n}\n\n/** Run `op` over `paths`, back to front, dropping empty results. `mergeKey`\n *  answers alike for the paths a Merge unites. */\nexport function booleanPieces(op: BooleanOp, paths: Path[], mergeKey: (index: number) => unknown): ResultPiece[] {\n  const top = paths.length - 1;\n  const whole = (path: PolygonPath): ResultPiece[] => [{ path, source: top }];\n  let pieces: ResultPiece[];\n  switch (op) {\n    case 'union':     pieces = whole(pathUnion(...paths)); break;\n    case 'intersect': pieces = whole(pathIntersect(...paths)); break;\n    case 'exclude':   pieces = whole(pathExclude(...paths)); break;\n    case 'subtract': {\n      // Illustrator \"Minus Front\": back − union(everything in front).\n      const front = paths.length === 2 ? paths[1]! : pathUnion(...paths.slice(1));\n      pieces = whole(pathSubtract(paths[0]!, front));\n      break;\n    }\n    case 'divide':    pieces = bySource(pathDividePieces(...paths)); break;\n    // Illustrator \"Crop\": every source below the topmost, clipped to it; the\n    // topmost is consumed as the mask.\n    case 'crop':      pieces = bySource(pathCropPieces(...paths)); break;\n    case 'trim':      pieces = bySource(pathTrim(...paths)); break;\n    case 'merge':     pieces = bySource(pathMerge(paths, mergeKey)); break;\n  }\n  return pieces.filter((p) => p.path.commands.length > 0);\n}\n"],"mappings":";;;;AAsBA,SAAS,SAAS,QAAuC;CACvD,OAAO,OAAO,KAAK,OAAO;EAAE,MAAM,EAAE;EAAM,QAAQ,EAAE,QAAQ,EAAE,QAAQ,SAAS;CAAI,EAAE;AACvF;;;AAIA,SAAgB,cAAc,IAAe,OAAe,UAAqD;CAC/G,MAAM,MAAM,MAAM,SAAS;CAC3B,MAAM,SAAS,SAAqC,CAAC;EAAE;EAAM,QAAQ;CAAI,CAAC;CAC1E,IAAI;CACJ,QAAQ,IAAR;EACE,KAAK;GAAa,SAAS,MAAM,UAAU,GAAG,KAAK,CAAC;GAAG;EACvD,KAAK;GAAa,SAAS,MAAM,cAAc,GAAG,KAAK,CAAC;GAAG;EAC3D,KAAK;GAAa,SAAS,MAAM,YAAY,GAAG,KAAK,CAAC;GAAG;EACzD,KAAK,YAAY;GAEf,MAAM,QAAQ,MAAM,WAAW,IAAI,MAAM,KAAM,UAAU,GAAG,MAAM,MAAM,CAAC,CAAC;GAC1E,SAAS,MAAM,aAAa,MAAM,IAAK,KAAK,CAAC;GAC7C;EACF;EACA,KAAK;GAAa,SAAS,SAAS,iBAAiB,GAAG,KAAK,CAAC;GAAG;EAGjE,KAAK;GAAa,SAAS,SAAS,eAAe,GAAG,KAAK,CAAC;GAAG;EAC/D,KAAK;GAAa,SAAS,SAAS,SAAS,GAAG,KAAK,CAAC;GAAG;EACzD,KAAK,SAAa,SAAS,SAAS,UAAU,OAAO,QAAQ,CAAC;CAChE;CACA,OAAO,OAAO,QAAQ,MAAM,EAAE,KAAK,SAAS,SAAS,CAAC;AACxD"}

package/dist/interactions/actions/booleans/placement.js

@@ -1,24 +1,37 @@
-import { createMoveToIndexOp as e } from "../../../core/ops/reorder/index.js";
+import { createMoveToIndexOp } from "../../../core/ops/reorder/index.js";
+
 //#region src/interactions/actions/booleans/placement.ts
-function t(t, n) {
-	let r = /* @__PURE__ */ new Map();
-	for (let e of t) {
-		if (!e.slot) continue;
-		let t = r.get(e.slot.parentId);
-		t ? t.push(e.id) : r.set(e.slot.parentId, [e.id]);
+/**
+* The ops that put each result where its source was. Results are grouped by
+* their source's parent, and each group lands as one block, in result order,
+* in the slot of the topmost source in that parent.
+*
+* `sourceSlots` holds every source's slot, read before anything is deleted.
+* The sources below a slot in the same parent are deleted before the reorder
+* runs, so the block goes that many places lower. A result whose source has
+* no slot is left wherever the insert put it.
+*/
+function placementOps(results, sourceSlots) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const r of results) {
+		if (!r.slot) continue;
+		const group = groups.get(r.slot.parentId);
+		if (group) group.push(r.id);
+		else groups.set(r.slot.parentId, [r.id]);
 	}
-	let i = [];
-	for (let [t, a] of r) {
-		let r = n.flatMap((e) => e && e.parentId === t ? [e.index] : []), o = Math.max(...r);
-		i.push(e({
-			ids: a,
-			parentId: t,
-			index: o - (r.length - 1)
+	const ops = [];
+	for (const [parentId, ids] of groups) {
+		const indices = sourceSlots.flatMap((s) => s && s.parentId === parentId ? [s.index] : []);
+		const top = Math.max(...indices);
+		ops.push(createMoveToIndexOp({
+			ids,
+			parentId,
+			index: top - (indices.length - 1)
 		}));
 	}
-	return i;
+	return ops;
 }
-//#endregion
-export { t as placementOps };
 
+//#endregion
+export { placementOps };
 //# sourceMappingURL=placement.js.map

package/dist/interactions/actions/booleans/placement.js.map

@@ -1 +1 @@
-{"version":3,"file":"placement.js","names":["placementOps","groups","r","results","group","ops","parentId","ids","indices","sourceSlots","s","top","createMoveToIndexOp"],"sources":["../../../../src/interactions/actions/booleans/placement.ts"],"sourcesContent":["import { createMoveToIndexOp } from 'core/ops/reorder';\nimport type { Op } from 'core/ops/types';\nimport type { BooleanZOrder } from './booleans';\n\n/**\n * The ops that put each result where its source was. Results are grouped by\n * their source's parent, and each group lands as one block, in result order,\n * in the slot of the topmost source in that parent.\n *\n * `sourceSlots` holds every source's slot, read before anything is deleted.\n * The sources below a slot in the same parent are deleted before the reorder\n * runs, so the block goes that many places lower. A result whose source has\n * no slot is left wherever the insert put it.\n */\nexport function placementOps(\n  results: readonly { id: string; slot: BooleanZOrder | undefined }[],\n  sourceSlots: readonly (BooleanZOrder | undefined)[],\n): Op[] {\n  const groups = new Map<string | null, string[]>();\n  for (const r of results) {\n    if (!r.slot) continue;\n    const group = groups.get(r.slot.parentId);\n    if (group) group.push(r.id);\n    else groups.set(r.slot.parentId, [r.id]);\n  }\n  const ops: Op[] = [];\n  for (const [parentId, ids] of groups) {\n    const indices = sourceSlots.flatMap((s) => (s && s.parentId === parentId ? [s.index] : []));\n    const top = Math.max(...indices);\n    ops.push(createMoveToIndexOp({ ids, parentId, index: top - (indices.length - 1) }));\n  }\n  return ops;\n}\n"],"mappings":";;AAcA,SAAgBA,EACd,GACA,GACM;CACN,IAAMC,oBAAS,IAAI,IAA6B;CAChD,KAAK,IAAMC,KAAKC,GAAS;EACvB,IAAI,CAACD,EAAE,MAAM;EACb,IAAME,IAAQH,EAAO,IAAIC,EAAE,KAAK,QAAQ;EACxC,AAAIE,IAAOA,EAAM,KAAKF,EAAE,EAAE,IACrBD,EAAO,IAAIC,EAAE,KAAK,UAAU,CAACA,EAAE,EAAE,CAAC;CACzC;CACA,IAAMG,IAAY,CAAC;CACnB,KAAK,IAAM,CAACC,GAAUC,MAAQN,GAAQ;EACpC,IAAMO,IAAUC,EAAY,SAAS,MAAOC,KAAKA,EAAE,aAAaJ,IAAW,CAACI,EAAE,KAAK,IAAI,CAAC,CAAE,GACpFC,IAAM,KAAK,IAAI,GAAGH,CAAO;EAC/B,EAAI,KAAKI,EAAoB;GAAE;GAAK;GAAU,OAAOD,KAAOH,EAAQ,SAAS;EAAG,CAAC,CAAC;CACpF;CACA,OAAOH;AACT"}
+{"version":3,"file":"placement.js","names":[],"sources":["../../../../src/interactions/actions/booleans/placement.ts"],"sourcesContent":["import { createMoveToIndexOp } from 'core/ops/reorder';\nimport type { Op } from 'core/ops/types';\nimport type { BooleanZOrder } from './booleans';\n\n/**\n * The ops that put each result where its source was. Results are grouped by\n * their source's parent, and each group lands as one block, in result order,\n * in the slot of the topmost source in that parent.\n *\n * `sourceSlots` holds every source's slot, read before anything is deleted.\n * The sources below a slot in the same parent are deleted before the reorder\n * runs, so the block goes that many places lower. A result whose source has\n * no slot is left wherever the insert put it.\n */\nexport function placementOps(\n  results: readonly { id: string; slot: BooleanZOrder | undefined }[],\n  sourceSlots: readonly (BooleanZOrder | undefined)[],\n): Op[] {\n  const groups = new Map<string | null, string[]>();\n  for (const r of results) {\n    if (!r.slot) continue;\n    const group = groups.get(r.slot.parentId);\n    if (group) group.push(r.id);\n    else groups.set(r.slot.parentId, [r.id]);\n  }\n  const ops: Op[] = [];\n  for (const [parentId, ids] of groups) {\n    const indices = sourceSlots.flatMap((s) => (s && s.parentId === parentId ? [s.index] : []));\n    const top = Math.max(...indices);\n    ops.push(createMoveToIndexOp({ ids, parentId, index: top - (indices.length - 1) }));\n  }\n  return ops;\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,SAAgB,aACd,SACA,aACM;CACN,MAAM,yBAAS,IAAI,IAA6B;CAChD,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,CAAC,EAAE,MAAM;EACb,MAAM,QAAQ,OAAO,IAAI,EAAE,KAAK,QAAQ;EACxC,IAAI,OAAO,MAAM,KAAK,EAAE,EAAE;OACrB,OAAO,IAAI,EAAE,KAAK,UAAU,CAAC,EAAE,EAAE,CAAC;CACzC;CACA,MAAM,MAAY,CAAC;CACnB,KAAK,MAAM,CAAC,UAAU,QAAQ,QAAQ;EACpC,MAAM,UAAU,YAAY,SAAS,MAAO,KAAK,EAAE,aAAa,WAAW,CAAC,EAAE,KAAK,IAAI,CAAC,CAAE;EAC1F,MAAM,MAAM,KAAK,IAAI,GAAG,OAAO;EAC/B,IAAI,KAAK,oBAAoB;GAAE;GAAK;GAAU,OAAO,OAAO,QAAQ,SAAS;EAAG,CAAC,CAAC;CACpF;CACA,OAAO;AACT"}

package/dist/interactions/actions/booleans/useBooleans.js

@@ -1,22 +1,35 @@
-import { applyBooleanOp as e } from "./booleans.js";
-import { useCallback as t } from "react";
-import { useLatest as n } from "@weasel-js/react";
-function r(r, i = {}) {
-	let a = n(r), o = n(i), s = t((t) => {
-		e(a.current, t, o.current);
-	}, [a, o]);
+import { applyBooleanOp } from "./booleans.js";
+import { useCallback } from "react";
+import { isDev, useLatest } from "@weasel-js/react";
+
+//#region src/interactions/actions/booleans/useBooleans.ts
+/**
+* `useBooleans` — selection-driven Boolean ops on path layers. No-ops are
+* silent in production; in dev, `subtract` with < 2 selected paths emits a
+* `console.warn`.
+*/
+var dev = isDev();
+/** Bind the Boolean path operations to an adapter that knows how to read the
+*  selection, fetch world-space paths and mint result nodes. */
+function useBooleans(adapter, options = {}) {
+	const adapterRef = useLatest(adapter);
+	const optionsRef = useLatest(options);
+	const run = useCallback((op) => {
+		const result = applyBooleanOp(adapterRef.current, op, optionsRef.current);
+		if (dev && result.kind === "noop" && result.reason === "too-few-for-subtract") console.warn("[useBooleans] subtract requires at least 2 selected paths");
+	}, [adapterRef, optionsRef]);
 	return {
-		union: t(() => s("union"), [s]),
-		intersect: t(() => s("intersect"), [s]),
-		subtract: t(() => s("subtract"), [s]),
-		exclude: t(() => s("exclude"), [s]),
-		divide: t(() => s("divide"), [s]),
-		crop: t(() => s("crop"), [s]),
-		trim: t(() => s("trim"), [s]),
-		merge: t(() => s("merge"), [s])
+		union: useCallback(() => run("union"), [run]),
+		intersect: useCallback(() => run("intersect"), [run]),
+		subtract: useCallback(() => run("subtract"), [run]),
+		exclude: useCallback(() => run("exclude"), [run]),
+		divide: useCallback(() => run("divide"), [run]),
+		crop: useCallback(() => run("crop"), [run]),
+		trim: useCallback(() => run("trim"), [run]),
+		merge: useCallback(() => run("merge"), [run])
 	};
 }
-//#endregion
-export { r as useBooleans };
 
+//#endregion
+export { useBooleans };
 //# sourceMappingURL=useBooleans.js.map

package/dist/interactions/actions/booleans/useBooleans.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBooleans.js","names":["useBooleans","adapterRef","useLatest","adapter","optionsRef","options","run","useCallback","op"],"sources":["../../../../src/interactions/actions/booleans/useBooleans.ts"],"sourcesContent":["/**\n * `useBooleans` — selection-driven Boolean ops on path layers. No-ops are\n * silent in production; in dev, `subtract` with < 2 selected paths emits a\n * `console.warn`.\n */\nimport { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { applyBooleanOp, type BooleansAdapter, type BooleanOp } from './booleans';\nimport type { BooleanOpOptions } from './operands';\n\n/** The Boolean path operations, each acting on the current selection and\n *  committing as one undo step. */\nexport interface UseBooleansReturn {\n  union(): void;\n  intersect(): void;\n  subtract(): void;\n  exclude(): void;\n  divide(): void;\n  crop(): void;\n  trim(): void;\n  merge(): void;\n}\n\n/** Options for `useBooleans`. */\nexport interface UseBooleansOptions extends BooleanOpOptions {\n  /** No-op. Retained for source-compatibility; `useStandardActions`\n   *  registers the actions. */\n  enableActions?: boolean;\n}\n\nconst isDev = typeof import.meta !== 'undefined'\n  && (import.meta as { env?: { DEV?: boolean } }).env?.DEV;\n\n/** Bind the Boolean path operations to an adapter that knows how to read the\n *  selection, fetch world-space paths and mint result nodes. */\nexport function useBooleans(\n  adapter: BooleansAdapter,\n  options: UseBooleansOptions = {},\n): UseBooleansReturn {\n  const adapterRef = useLatest(adapter);\n  const optionsRef = useLatest(options);\n\n  const run = useCallback((op: BooleanOp) => {\n    const result = applyBooleanOp(adapterRef.current, op, optionsRef.current);\n    if (isDev && result.kind === 'noop' && result.reason === 'too-few-for-subtract') {\n      console.warn('[useBooleans] subtract requires at least 2 selected paths');\n    }\n  }, [adapterRef, optionsRef]);\n\n  return {\n    union: useCallback(() => run('union'), [run]),\n    intersect: useCallback(() => run('intersect'), [run]),\n    subtract: useCallback(() => run('subtract'), [run]),\n    exclude: useCallback(() => run('exclude'), [run]),\n    divide: useCallback(() => run('divide'), [run]),\n    crop: useCallback(() => run('crop'), [run]),\n    trim: useCallback(() => run('trim'), [run]),\n    merge: useCallback(() => run('merge'), [run]),\n  };\n}\n"],"mappings":";;;AAmCA,SAAgBA,EACd,GACA,IAA8B,CAAC,GACZ;CACnB,IAAMC,IAAaC,EAAUC,CAAO,GAC9BC,IAAaF,EAAUG,CAAO,GAE9BC,IAAMC,GAAa,MAAkB;EAC1B,EAAeN,EAAW,SAASO,GAAIJ,EAAW,OAAO;CAI1E,GAAG,CAACH,GAAYG,CAAU,CAAC;CAE3B,OAAO;EACL,OAAOG,QAAkBD,EAAI,OAAO,GAAG,CAACA,CAAG,CAAC;EAC5C,WAAWC,QAAkBD,EAAI,WAAW,GAAG,CAACA,CAAG,CAAC;EACpD,UAAUC,QAAkBD,EAAI,UAAU,GAAG,CAACA,CAAG,CAAC;EAClD,SAASC,QAAkBD,EAAI,SAAS,GAAG,CAACA,CAAG,CAAC;EAChD,QAAQC,QAAkBD,EAAI,QAAQ,GAAG,CAACA,CAAG,CAAC;EAC9C,MAAMC,QAAkBD,EAAI,MAAM,GAAG,CAACA,CAAG,CAAC;EAC1C,MAAMC,QAAkBD,EAAI,MAAM,GAAG,CAACA,CAAG,CAAC;EAC1C,OAAOC,QAAkBD,EAAI,OAAO,GAAG,CAACA,CAAG,CAAC;CAC9C;AACF"}
+{"version":3,"file":"useBooleans.js","names":[],"sources":["../../../../src/interactions/actions/booleans/useBooleans.ts"],"sourcesContent":["/**\n * `useBooleans` — selection-driven Boolean ops on path layers. No-ops are\n * silent in production; in dev, `subtract` with < 2 selected paths emits a\n * `console.warn`.\n */\nimport { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { applyBooleanOp, type BooleansAdapter, type BooleanOp } from './booleans';\nimport type { BooleanOpOptions } from './operands';\nimport { isDev } from '@weasel-js/react';\n\n/** The Boolean path operations, each acting on the current selection and\n *  committing as one undo step. */\nexport interface UseBooleansReturn {\n  union(): void;\n  intersect(): void;\n  subtract(): void;\n  exclude(): void;\n  divide(): void;\n  crop(): void;\n  trim(): void;\n  merge(): void;\n}\n\n/** Options for `useBooleans`. */\nexport interface UseBooleansOptions extends BooleanOpOptions {\n  /** No-op. Retained for source-compatibility; `useStandardActions`\n   *  registers the actions. */\n  enableActions?: boolean;\n}\n\nconst dev = isDev();\n\n/** Bind the Boolean path operations to an adapter that knows how to read the\n *  selection, fetch world-space paths and mint result nodes. */\nexport function useBooleans(\n  adapter: BooleansAdapter,\n  options: UseBooleansOptions = {},\n): UseBooleansReturn {\n  const adapterRef = useLatest(adapter);\n  const optionsRef = useLatest(options);\n\n  const run = useCallback((op: BooleanOp) => {\n    const result = applyBooleanOp(adapterRef.current, op, optionsRef.current);\n    if (dev && result.kind === 'noop' && result.reason === 'too-few-for-subtract') {\n      console.warn('[useBooleans] subtract requires at least 2 selected paths');\n    }\n  }, [adapterRef, optionsRef]);\n\n  return {\n    union: useCallback(() => run('union'), [run]),\n    intersect: useCallback(() => run('intersect'), [run]),\n    subtract: useCallback(() => run('subtract'), [run]),\n    exclude: useCallback(() => run('exclude'), [run]),\n    divide: useCallback(() => run('divide'), [run]),\n    crop: useCallback(() => run('crop'), [run]),\n    trim: useCallback(() => run('trim'), [run]),\n    merge: useCallback(() => run('merge'), [run]),\n  };\n}\n"],"mappings":";;;;;;;;;;AA+BA,IAAM,MAAM,MAAM;;;AAIlB,SAAgB,YACd,SACA,UAA8B,CAAC,GACZ;CACnB,MAAM,aAAa,UAAU,OAAO;CACpC,MAAM,aAAa,UAAU,OAAO;CAEpC,MAAM,MAAM,aAAa,OAAkB;EACzC,MAAM,SAAS,eAAe,WAAW,SAAS,IAAI,WAAW,OAAO;EACxE,IAAI,OAAO,OAAO,SAAS,UAAU,OAAO,WAAW,wBACrD,QAAQ,KAAK,2DAA2D;CAE5E,GAAG,CAAC,YAAY,UAAU,CAAC;CAE3B,OAAO;EACL,OAAO,kBAAkB,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC;EAC5C,WAAW,kBAAkB,IAAI,WAAW,GAAG,CAAC,GAAG,CAAC;EACpD,UAAU,kBAAkB,IAAI,UAAU,GAAG,CAAC,GAAG,CAAC;EAClD,SAAS,kBAAkB,IAAI,SAAS,GAAG,CAAC,GAAG,CAAC;EAChD,QAAQ,kBAAkB,IAAI,QAAQ,GAAG,CAAC,GAAG,CAAC;EAC9C,MAAM,kBAAkB,IAAI,MAAM,GAAG,CAAC,GAAG,CAAC;EAC1C,MAAM,kBAAkB,IAAI,MAAM,GAAG,CAAC,GAAG,CAAC;EAC1C,OAAO,kBAAkB,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC;CAC9C;AACF"}

package/dist/interactions/actions/booleans/useBooleansAdapter.js

@@ -1,9 +1,12 @@
-import { useDepSource as e } from "@weasel-js/routing/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/interactions/actions/booleans/useBooleansAdapter.ts
-function t(t) {
-	e("booleansAdapter", () => t);
+/** Publish a Boolean-ops adapter so the built-in Pathfinder actions can run.
+*  Silently does nothing outside a `<DepRegistryProvider>`. */
+function useBooleansAdapter(adapter) {
+	useDepSource("booleansAdapter", () => adapter);
 }
-//#endregion
-export { t as useBooleansAdapter };
 
+//#endregion
+export { useBooleansAdapter };
 //# sourceMappingURL=useBooleansAdapter.js.map

package/dist/interactions/actions/booleans/useBooleansAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBooleansAdapter.js","names":["useBooleansAdapter","adapter"],"sources":["../../../../src/interactions/actions/booleans/useBooleansAdapter.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport type { BooleansAdapter } from './booleans';\n\n/** Publish a Boolean-ops adapter so the built-in Pathfinder actions can run.\n *  Silently does nothing outside a `<DepRegistryProvider>`. */\nexport function useBooleansAdapter(adapter: BooleansAdapter): void {\n  useDepSource('booleansAdapter', () => adapter);\n}\n"],"mappings":";;AAKA,SAAgBA,EAAmB,GAAgC;CACjE,EAAa,yBAAyBC,CAAO;AAC/C"}
+{"version":3,"file":"useBooleansAdapter.js","names":[],"sources":["../../../../src/interactions/actions/booleans/useBooleansAdapter.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport type { BooleansAdapter } from './booleans';\n\n/** Publish a Boolean-ops adapter so the built-in Pathfinder actions can run.\n *  Silently does nothing outside a `<DepRegistryProvider>`. */\nexport function useBooleansAdapter(adapter: BooleansAdapter): void {\n  useDepSource('booleansAdapter', () => adapter);\n}\n"],"mappings":";;;;;AAKA,SAAgB,mBAAmB,SAAgC;CACjE,aAAa,yBAAyB,OAAO;AAC/C"}