@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/deps/editAnchors.js.map

@@ -1 +1 @@
-{"version":3,"file":"editAnchors.js","names":["classifyStorage","node","data","isRectPose","resolveEditablePathOf","storage","pathInWorld","EMPTY_ANCHOR_SELECTION","useEditAnchorsDepSource","sceneRef","useLatest","scene","selectionRef","selection","adapterRef","adapter","allowedRef","options","localEditingId","setLocalEditingIdState","useState","setLocalEditingId","useCallback","id","externalRef","externalState","setLocalEditingIdRef","readEditingId","sc","ad","s","ext","effectiveId","inSelection","permitted","selectedAnchors","marquee","editOps","wp","worldPath","createTransformOp","newPose","aligned","worldEditToStorage","createSetDataOp","next","recordModeSwitch","rect","ops","label"],"sources":["../../../src/canvas/deps/editAnchors.ts"],"sourcesContent":["/**\n * `useEditAnchorsDepSource` — wires the `editAnchors` dep consumed by\n * `editAnchorsAction`, `enterPathEditAction`, `exitPathEditAction`, and\n * `insertPathAnchorAction`.\n *\n * `editingId` is explicit, set by `enterPathEditAction` (double-click)\n * and cleared by `exitPathEditAction` (Escape, or when the target leaves\n * the selection / is deleted).\n *\n * `getEditablePath(id)` returns the COMMITTED polygon in **world coords**,\n * regardless of where it's stored:\n *   - `node.pose.kind === 'polygon'` → pose IS the polygon.\n *   - `node.data.path` is a polygon → kit pen-tool default. Polygon's\n *     stored coords are pose-local (aligned to pose origin); we project\n *     to world via `pathInWorld` (translate + bake `pose.rotation`).\n *\n * `getStorageKind(id)` returns where the polygon lives (`'pose'` /\n * `'data'` / `null`). Actions use this to emit the right preview-ghost\n * axes: `previewPose` only for pose-as-polygon, `previewPose +\n * previewData` for data.path.\n *\n * `applyEdit(id, worldPath, label)` commits in the correct storage shape,\n * as one undoable batch. Pose-as-polygon is a `transform` op; data.path is\n * a `transform` (new bounds) plus a `setData` (re-aligned local path), so\n * the kit's render invariant (`pathInWorld(stored, pose) === world`) is\n * preserved. `editOps` returns those same ops unapplied, for a caller\n * folding the edit into a larger batch.\n *\n * Live previews ride the standard `OngoingHandle.previewIds/Pose/Data`\n * triple — this dep doesn't own preview state.\n */\nimport { useCallback, useState } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId, RectPose } from 'core/scene/types';\nimport { isRectPose } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport { pathInWorld, worldEditToStorage } from 'features/paths/pathInWorld';\nimport { recordModeSwitch } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { createSetDataOp } from 'core/ops/setData';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/** Optional shared state for the edit-mode `editingId`. Pass when the\n *  consumer needs to read the current editingId from a sibling component\n *  (e.g. the path-editing overlay layer rendered above the SceneCanvas\n *  subtree where the dep is published). When omitted, the hook owns\n *  local state. */\nexport interface EditAnchorsStateRef {\n  getEditingId(): string;\n  setEditingId(id: string | null): void;\n  /** Selected anchors (flat indices) for the node in `editingId`. */\n  getSelectedAnchors(): ReadonlySet<number>;\n  setSelectedAnchors(next: ReadonlySet<number>): void;\n  /** In-flight anchor-marquee rect in world coords. */\n  getMarquee(): { x: number; y: number; width: number; height: number } | null;\n  setMarquee(rect: { x: number; y: number; width: number; height: number } | null): void;\n}\n\n/** Extra wiring for {@link useEditAnchorsDepSource}. */\nexport interface EditAnchorsDepOptions {\n  /**\n   * Whether the host currently permits anchor editing — i.e. whether the\n   * active mode allows the `edits-anchors` capability.\n   *\n   * **Omit this when no mode registry is wired.** Absent means \"no\n   * modality, so nothing revokes edit mode\", which is the correct\n   * behavior for the many consumers that never opt into modes; passing a\n   * predicate built from an empty capability set would revoke edit mode\n   * instantly. Same trap as `DEFAULT_ALLOWED_CAPABILITIES` guards against\n   * on the chrome side.\n   *\n   * When supplied and it returns false, `editingId` reads as empty — the\n   * overlay stops drawing, the anchors stop being hittable, and the\n   * anchor selection is dropped. This is what makes leaving path-edit\n   * mode by ANY route (Escape, breadcrumb, a consumer calling\n   * `exitMode()` directly) tear down edit state, rather than only the one\n   * route that happens to reach `exitPathEditAction`.\n   */\n  anchorEditingAllowed?: () => boolean;\n}\n\n/** Resolve where a node's editable polygon lives. Returns null when the\n *  node has neither a polygon pose nor a polygon on `data.path`. */\nfunction classifyStorage(\n  node: { pose: unknown; data: unknown } | undefined | null,\n): { kind: 'pose' } | { kind: 'data'; pose: RectPose; data: { path: PolygonPath } } | null {\n  if (!node) return null;\n  const pose = node.pose as { kind?: string } | undefined;\n  if (pose?.kind === 'polygon') return { kind: 'pose' };\n  const data = node.data as { path?: Path } | null;\n  if (data?.path && (data.path as { kind?: string }).kind === 'polygon' && isRectPose(node.pose)) {\n    return {\n      kind: 'data',\n      pose: node.pose,\n      data: data as { path: PolygonPath },\n    };\n  }\n  return null;\n}\n\n/** Resolve a node's editable polygon in world coords. Shared between the\n *  dep source and SceneCanvas's chrome wiring so both apply the same\n *  \"pose IS the polygon vs data.path with rect pose\" routing. Does NOT\n *  consult any preview state — callers that want live state read\n *  in-flight handles themselves. */\nexport function resolveEditablePathOf(\n  node: { pose: unknown; data: unknown } | undefined | null,\n): PolygonPath | null {\n  if (!node) return null;\n  const storage = classifyStorage(node);\n  if (!storage) return null;\n  // Pose-as-polygon: the pose IS the polygon (polygon poses can't carry\n  // rotation), so it's already world.\n  if (storage.kind === 'pose') return (node as { pose: PolygonPath }).pose;\n  // data.path: project to world via the world seam — translate to the pose\n  // origin AND bake `pose.rotation`, so anchors render on the rotated contour\n  // the renderer draws (not the unrotated one).\n  return pathInWorld(storage.data.path, storage.pose) as PolygonPath;\n}\n\nconst EMPTY_ANCHOR_SELECTION: ReadonlySet<number> = new Set<number>();\n\nexport function useEditAnchorsDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  externalState?: EditAnchorsStateRef,\n  options?: EditAnchorsDepOptions,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n  const allowedRef = useLatest(options?.anchorEditingAllowed);\n\n  const [localEditingId, setLocalEditingIdState] = useState<string>('');\n  const setLocalEditingId = useCallback((id: string | null) => {\n    setLocalEditingIdState(id ?? '');\n  }, []);\n  const externalRef = useLatest(externalState);\n  const setLocalEditingIdRef = useLatest(setLocalEditingId);\n\n  const readEditingId = (): string => {\n    return externalRef.current ? externalRef.current.getEditingId() : localEditingId;\n  };\n\n  useDepSource('editAnchors', (): EditAnchorsDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n    const s = selectionRef.current;\n    const ext = externalRef.current;\n    let effectiveId = readEditingId();\n    if (effectiveId) {\n      const node = sc.get(effectiveId as NodeId);\n      const inSelection = (s.current as NodeId[]).includes(effectiveId as NodeId);\n      // A mode registry that no longer permits `edits-anchors` revokes\n      // edit mode wholesale — see EditAnchorsDepOptions.anchorEditingAllowed.\n      const permitted = allowedRef.current ? allowedRef.current() : true;\n      if (!node || !inSelection || !permitted) effectiveId = '';\n    }\n    // Anchor selection and the marquee belong to one specific edited\n    // node. The moment `editingId` reads as empty — exited, deselected,\n    // deleted, or revoked by a mode change — they are stale by\n    // definition, so never hand them out alongside an empty id.\n    const selectedAnchors = effectiveId\n      ? (ext?.getSelectedAnchors() ?? EMPTY_ANCHOR_SELECTION)\n      : EMPTY_ANCHOR_SELECTION;\n    const marquee = effectiveId ? (ext?.getMarquee() ?? null) : null;\n  const editOps = (id: string, worldPath: unknown, label: string): Op[] => {\n      const wp = worldPath as PolygonPath;\n      const node = sc.get(id as NodeId);\n      if (!node) return [];\n      const storage = classifyStorage(node as { pose: unknown; data: unknown });\n      if (!storage) return [];\n      if (storage.kind === 'pose') return [createTransformOp({ id, from: node.pose, to: wp, label })];\n      // Edited path arrives in world coords (rotation baked in by\n      // resolveEditablePathOf); invert it back to the unrotated stored\n      // shape so `pose.rotation` is preserved and edits round-trip.\n      const { pose: newPose, path: aligned } = worldEditToStorage(storage.pose, wp);\n      return [\n        createTransformOp({ id, from: node.pose, to: newPose, label }),\n        createSetDataOp({ id, from: node.data, to: { ...(node.data as object), path: aligned }, label }),\n      ];\n    };\n    return {\n      editingId: effectiveId,\n      setEditingId(id: string | null) {\n        const next = id ?? '';\n        if (effectiveId !== next) {\n          recordModeSwitch(\n            'editAnchors.editingId',\n            effectiveId || null,\n            next || null,\n            next ? 'enter' : 'exit',\n          );\n          // Anchor indices only mean something relative to one path.\n          ext?.setSelectedAnchors(EMPTY_ANCHOR_SELECTION);\n          ext?.setMarquee(null);\n        }\n        if (externalRef.current) externalRef.current.setEditingId(id);\n        else setLocalEditingIdRef.current(id);\n      },\n      selectedAnchors,\n      setSelectedAnchors(next: Iterable<number>) {\n        if (!effectiveId) return;\n        ext?.setSelectedAnchors(new Set(next));\n      },\n      marquee,\n      setMarquee(rect) {\n        if (!effectiveId) return;\n        ext?.setMarquee(rect);\n      },\n      getEditablePath(id: string): PolygonPath | null {\n        const node = sc.get(id as NodeId);\n        return resolveEditablePathOf(node as { pose: unknown; data: unknown });\n      },\n      getStorageKind(id: string): 'pose' | 'data' | null {\n        const node = sc.get(id as NodeId);\n        const storage = classifyStorage(node as { pose: unknown; data: unknown });\n        return storage?.kind ?? null;\n      },\n      getNodeShape(id: string): { pose: unknown; data: unknown } | null {\n        const node = sc.get(id as NodeId);\n        if (!node) return null;\n        return { pose: node.pose, data: node.data };\n      },\n      applyEdit(id: string, worldPath: unknown, label: string) {\n        const ops = editOps(id, worldPath, label);\n        if (ops.length > 0) ad.applyOps(ops, label);\n      },\n      editOps,\n    };\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"editAnchors.js","names":["EMPTY_ANCHOR_SELECTION","useEditAnchorsDepSource","sceneRef","useLatest","scene","selectionRef","selection","adapterRef","adapter","ownState","useState","createPathEditState","isSelectedNode","id","stateRef","externalState","sc","ad","state","effectiveId","selectedAnchors","marquee","editOps","wp","worldPath","node","next","storeEditablePath","skin","reskinned","origins","remapSkin","reshape","createTransformOp","data","withoutShapeGenerator","createSetDataOp","recordModeSwitch","rect","resolveEditablePathOf","classifyPathStorage","ops","label"],"sources":["../../../src/canvas/deps/editAnchors.ts"],"sourcesContent":["/**\n * `useEditAnchorsDepSource` — wires the `editAnchors` dep.\n *\n * A node's editable polygon lives in one of two places: the pose itself\n * (`pose.kind === 'polygon'`), or `data.path` with a rect pose, stored pose-local.\n * `getEditablePath` returns it in **world coords** either way, and `applyEdit` commits in the\n * correct storage shape as one undoable batch, preserving the render invariant\n * `pathInWorld(stored, pose) === world`. A node with a `data.skin` has it renumbered in that\n * batch when the caller says where the points came from. Live previews ride the standard\n * `OngoingHandle.previewIds/Pose/Data` triple — this dep doesn't own preview state.\n */\nimport { useState } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PointOrigin, PolygonPath } from '@weasel-js/geom';\nimport type { Skin } from '@weasel-js/animator';\nimport { remapSkin } from '../../animation/rig/skinBinding';\nimport { classifyPathStorage, resolveEditablePathOf, storeEditablePath } from 'features/paths/editablePath';\nimport { withoutShapeGenerator } from 'features/paths/shapeGenerator';\nimport { createPathEditState, isSelectedNode, type PathEditState } from 'features/paths/pathEditState';\nimport { recordModeSwitch } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { createSetDataOp } from 'core/ops/setData';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/** The part of a `PathEditState` the dep reads and writes. */\nexport type EditAnchorsStateRef = Omit<PathEditState, 'subscribe' | 'getEditingIds'>;\n\nexport { resolveEditablePathOf };\n\nconst EMPTY_ANCHOR_SELECTION: ReadonlySet<number> = new Set<number>();\n\nexport function useEditAnchorsDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  externalState?: EditAnchorsStateRef,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n\n  // A caller that shares the state with nothing else gets one of its own.\n  const [ownState] = useState(() => createPathEditState({\n    isSelectedNode: (id) => isSelectedNode(sceneRef.current, selectionRef.current, id),\n  }));\n  const stateRef = useLatest(externalState ?? ownState);\n\n  useDepSource('editAnchors', (): EditAnchorsDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n    const state = stateRef.current;\n    const effectiveId = state.getEditingId();\n    // Anchor selection and the marquee belong to one specific edited node, so never\n    // hand them out alongside an empty id.\n    const selectedAnchors = effectiveId ? state.getSelectedAnchors() : EMPTY_ANCHOR_SELECTION;\n    const marquee = effectiveId ? state.getMarquee() : null;\n    const editOps = (id: string, worldPath: unknown, label: string, origins?: readonly (PointOrigin | null)[]): Op[] => {\n      const wp = worldPath as PolygonPath;\n      const node = sc.get(id as NodeId);\n      if (!node) return [];\n      const next = storeEditablePath(node as { pose: unknown; data: unknown }, wp);\n      if (!next) return [];\n      const skin = (node.data as { skin?: Skin } | null)?.skin;\n      const reskinned = skin && origins ? { skin: remapSkin(skin, origins) } : null;\n      const reshape = createTransformOp({ id, from: node.pose, to: next.pose, label });\n      // A path edited by hand is no longer what its generator makes: it becomes plain geometry.\n      const data = next.data === node.data ? node.data : withoutShapeGenerator(next.data);\n      if (data === node.data && !reskinned) return [reshape];\n      return [reshape, createSetDataOp({ id, from: node.data, to: { ...(data as object), ...reskinned }, label })];\n    };\n    return {\n      editingId: effectiveId,\n      setEditingId(id: string | null) {\n        const next = id ?? '';\n        if (effectiveId !== next) {\n          recordModeSwitch(\n            'editAnchors.editingId',\n            effectiveId || null,\n            next || null,\n            next ? 'enter' : 'exit',\n          );\n          // Anchor indices only mean something relative to one path.\n          state.setSelectedAnchors(EMPTY_ANCHOR_SELECTION);\n          state.setMarquee(null);\n        }\n        stateRef.current.setEditingId(id);\n      },\n      selectedAnchors,\n      setSelectedAnchors(next: Iterable<number>) {\n        if (!effectiveId) return;\n        state.setSelectedAnchors(new Set(next));\n      },\n      marquee,\n      setMarquee(rect) {\n        if (!effectiveId) return;\n        state.setMarquee(rect);\n      },\n      getEditablePath(id: string): PolygonPath | null {\n        const node = sc.get(id as NodeId);\n        return resolveEditablePathOf(node as { pose: unknown; data: unknown });\n      },\n      getStorageKind(id: string): 'pose' | 'data' | null {\n        const node = sc.get(id as NodeId);\n        const storage = classifyPathStorage(node as { pose: unknown; data: unknown });\n        return storage?.kind ?? null;\n      },\n      getNodeShape(id: string): { pose: unknown; data: unknown } | null {\n        const node = sc.get(id as NodeId);\n        if (!node) return null;\n        return { pose: node.pose, data: node.data };\n      },\n      applyEdit(id: string, worldPath: unknown, label: string, origins?: readonly (PointOrigin | null)[]) {\n        const ops = editOps(id, worldPath, label, origins);\n        if (ops.length > 0) ad.applyOps(ops, label);\n      },\n      editOps,\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;AAqCA,IAAMA,oBAA8C,IAAI,IAAY;AAEpE,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAaJ,EAAUK,CAAO,GAG9B,CAACC,KAAYC,QAAeC,EAAoB,EACpD,iBAAiB,MAAOC,EAAeV,EAAS,SAASG,EAAa,SAASQ,CAAE,EACnF,CAAC,CAAC,GACIC,IAAWX,EAAUY,KAAiBN,CAAQ;CAEpD,EAAa,qBAAqC;EAChD,IAAMO,IAAKd,EAAS,SACde,IAAKV,EAAW,SAChBW,IAAQJ,EAAS,SACjBK,IAAcD,EAAM,aAAa,GAGjCE,IAAkBD,IAAcD,EAAM,mBAAmB,IAAIlB,GAC7DqB,IAAUF,IAAcD,EAAM,WAAW,IAAI,MAC7CI,KAAW,GAAY,GAAoB,GAAe,MAAoD;GAClH,IAAMC,IAAKC,GACLC,IAAOT,EAAG,IAAIH,CAAY;GAChC,IAAI,CAACY,GAAM,OAAO,CAAC;GACnB,IAAMC,IAAOC,EAAkBF,GAA0CF,CAAE;GAC3E,IAAI,CAACG,GAAM,OAAO,CAAC;GACnB,IAAME,IAAQH,EAAK,MAAiC,MAC9CI,IAAYD,KAAQE,IAAU,EAAE,MAAMC,EAAUH,GAAME,CAAO,EAAE,IAAI,MACnEE,IAAUC,EAAkB;IAAE;IAAI,MAAMR,EAAK;IAAM,IAAIC,EAAK;IAAM;GAAM,CAAC,GAEzEQ,IAAOR,EAAK,SAASD,EAAK,OAAOA,EAAK,OAAOU,EAAsBT,EAAK,IAAI;GAElF,OADIQ,MAAST,EAAK,QAAQ,CAACI,IAAkB,CAACG,CAAO,IAC9C,CAACA,GAASI,EAAgB;IAAE;IAAI,MAAMX,EAAK;IAAM,IAAI;KAAE,GAAIS;KAAiB,GAAGL;IAAU;IAAG;GAAM,CAAC,CAAC;EAC7G;EACA,OAAO;GACL,WAAWV;GACX,aAAa,GAAmB;IAC9B,IAAMO,IAAOb,KAAM;IAYnB,AAXIM,MAAgBO,MAClBW,EACE,yBACAlB,KAAe,MACfO,KAAQ,MACRA,IAAO,UAAU,MACnB,GAEAR,EAAM,mBAAmBlB,CAAsB,GAC/CkB,EAAM,WAAW,IAAI,IAEvBJ,EAAS,QAAQ,aAAaD,CAAE;GAClC;GACA;GACA,mBAAmB,GAAwB;IACzC,AAAKM,KACLD,EAAM,mBAAmB,IAAI,IAAIQ,CAAI,CAAC;GACxC;GACA;GACA,WAAW,GAAM;IACf,AAAKP,KACLD,EAAM,WAAWoB,CAAI;GACvB;GACA,gBAAgB,GAAgC;IAC9C,IAAMb,IAAOT,EAAG,IAAIH,CAAY;IAChC,OAAO0B,EAAsBd,CAAwC;GACvE;GACA,eAAe,GAAoC;IACjD,IAAMA,IAAOT,EAAG,IAAIH,CAAY;IAEhC,OADgB2B,EAAoBf,CAC7B,CAAA,EAAS,QAAQ;GAC1B;GACA,aAAa,GAAqD;IAChE,IAAMA,IAAOT,EAAG,IAAIH,CAAY;IAEhC,OADKY,IACE;KAAE,MAAMA,EAAK;KAAM,MAAMA,EAAK;IAAK,IADxB;GAEpB;GACA,UAAU,GAAY,GAAoB,GAAe,GAA2C;IAClG,IAAMgB,IAAMnB,EAAQT,GAAIW,GAAWkB,GAAOZ,CAAO;IACjD,AAAIW,EAAI,SAAS,KAAGxB,EAAG,SAASwB,GAAKC,CAAK;GAC5C;GACA;EACF;CACF,CAAC;AACH"}

package/dist/canvas/deps/geometryProjection.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometryProjection.js","names":["useGeometryProjection","ref","useLatest","projection"],"sources":["../../../src/canvas/deps/geometryProjection.ts"],"sourcesContent":["/**\n * `useGeometryProjection` — wires the `geometryProjection` dep consumed by\n * pose-transform actions (move, resize, nudge, flip).\n *\n * When the prop is absent (`undefined`), calling this hook with `undefined`\n * registers a source that returns `undefined`, which is indistinguishable from\n * no registration — actions treat a missing dep as \"no geometry rewrite\".\n * The canonical usage is to mount a `<GeometryProjectionRegistrar>` only when\n * the consumer has supplied a projection, which avoids registering at all.\n *\n * @see GeometryProjection — the dep schema entry.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\n\nexport function useGeometryProjection(\n  projection: GeometryProjection | undefined,\n): void {\n  const ref = useLatest(projection);\n  useDepSource('geometryProjection', () => ref.current);\n}\n"],"mappings":";;;AAgBA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAU;CAChC,EAAa,4BAA4BF,EAAI,OAAO;AACtD"}
+{"version":3,"file":"geometryProjection.js","names":["useGeometryProjection","ref","useLatest","projection"],"sources":["../../../src/canvas/deps/geometryProjection.ts"],"sourcesContent":["/**\n * Wires the `geometryProjection` dep consumed by pose-transform actions.\n * A source that returns `undefined` is indistinguishable from no registration:\n * actions treat a missing dep as \"no geometry rewrite\".\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\n\nexport function useGeometryProjection(\n  projection: GeometryProjection | undefined,\n): void {\n  const ref = useLatest(projection);\n  useDepSource('geometryProjection', () => ref.current);\n}\n"],"mappings":";;;AASA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAU;CAChC,EAAa,4BAA4BF,EAAI,OAAO;AACtD"}

package/dist/canvas/deps/hitTestArea.js

@@ -1,51 +1,71 @@
 import { rectToPlane as e, toPlane as t } from "../../core/viewport/parallax.js";
 import { poseDescriptorForNode as n, visualBoundsViaDescriptor as r } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as i } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-import { findShapeSilhouette as a } from "../NodeShape.js";
-import { pickWalk as o, scenePickSource as s } from "../pickWalk.js";
-import { polygonRegion as c, poseOutline as l, rectRegion as u, regionBoundsOf as d, regionOf as f, regionTakes as p } from "../../core/geometry/regionHit.js";
-import { pathIntersectsRect as m } from "@weasel-js/geom";
+import { AUTO_POSE_DESCRIPTOR as i } from "../../core/geometry/autoPoseDescriptor.js";
+import { findShapeInk as a, findShapeSilhouette as o } from "../NodeShape.js";
+import { pickWalk as s, scenePickSource as c } from "../pickWalk.js";
+import { polygonRegion as l, poseOutline as u, rectRegion as d, regionBoundsOf as f, regionOf as p, regionTakes as m } from "../../core/geometry/regionHit.js";
+import { applyToPoint as h, pathIntersectsRect as g } from "@weasel-js/geom";
 //#region src/canvas/deps/hitTestArea.ts
-function h(e, t, n) {
-	let r = e?.get?.();
+function _(e, t) {
+	let n = e?.get?.();
 	return {
-		...n ? { poseComposition: n } : {},
 		...t ? { alphaOf: t } : {},
 		...e?.layerIsPainted ? { layerIsPainted: (t) => e.layerIsPainted(t) } : {},
-		...r ? { camera: r } : {}
+		...n ? { camera: n } : {}
 	};
 }
-function g(e, t, n, r = i, a = {}) {
-	return v(e, u(t), "intersect", n, r, a);
+function v(e, t, n, r = i, a = {}) {
+	return x(e, d(t), "intersect", n, r, a);
 }
-function _(e, t, n, r, a = i, o = {}) {
-	let s = c(t);
-	return s ? v(e, s, n, r, a, o) : [];
+function y(e, t, n, r, a = i, o = {}) {
+	let s = l(t);
+	return s ? x(e, s, n, r, a, o) : [];
 }
-function v(e, t, i, c, u, f) {
+function b(e, t) {
+	return t?.kind === "polygon" ? e() ? t : {
+		...t,
+		openFill: "none"
+	} : t;
+}
+function x(e, t, i, l, d, p) {
 	let h = (e) => ({
-		includeContainers: f.includeContainers === !0,
+		includeContainers: p.includeContainers === !0,
 		clipAdmits: (t, i, a) => {
-			let o = n(u, i);
-			return m(t, r(a, o)) && m(t, e.bounds);
+			let o = n(d, i);
+			return g(t, r(a, o)) && g(t, e.bounds);
 		},
 		hits: (t, r) => {
-			let o = n(u, t), s = d(t, r, o);
-			return p(e, i, r, s, () => a(t, r) ?? l(r, s));
+			let s = n(d, t), c = f(t, r, s), l, p = () => l ??= a(t, r)?.filled !== !1;
+			return m(e, i, b(p, r), c, () => b(p, o(t, r) ?? u(r, c)), p);
 		},
-		inPlane: (t) => h(y(e, t))
+		inPlane: (t) => h(S(e, t)),
+		inCopy: (t) => h(C(e, t))
 	});
-	return o(s(e, c), h(t));
+	return s(c(e, l), h(t));
 }
-function y(n, r) {
+function S(n, r) {
 	let i = [];
 	for (let e of n.verts) {
 		let n = t(r, e);
 		i.push(n.x, n.y);
 	}
-	return f(i, e(r, n.bounds), n.isRect);
+	return p(i, e(r, n.bounds), n.isRect);
+}
+function C(e, t) {
+	let n = [], r = Infinity, i = Infinity, a = -Infinity, o = -Infinity;
+	for (let s of e.verts) {
+		let [e, c] = h(t, s.x, s.y);
+		n.push(e, c), r = Math.min(r, e), i = Math.min(i, c), a = Math.max(a, e), o = Math.max(o, c);
+	}
+	let s = t[1] === 0 && t[2] === 0 || t[0] === 0 && t[3] === 0;
+	return p(n, {
+		x: r,
+		y: i,
+		width: a - r,
+		height: o - i
+	}, e.isRect && s);
 }
 //#endregion
-export { g as hitTestArea, _ as hitTestLassoPolygon, h as regionPickOptions };
+export { v as hitTestArea, y as hitTestLassoPolygon, _ as regionPickOptions };
 
 //# sourceMappingURL=hitTestArea.js.map

package/dist/canvas/deps/hitTestArea.js.map

@@ -1 +1 @@
-{"version":3,"file":"hitTestArea.js","names":["regionPickOptions","camera","view","poseComposition","alphaOf","layer","hitTestArea","AUTO_POSE_DESCRIPTOR","walkArea","scene","rectRegion","bounds","opts","descriptor","query","hitTestLassoPolygon","region","polygonRegion","polygon","mode","regionQuery","g","poseDescriptorForNode","node","pathIntersectsRect","clip","visualBoundsViaDescriptor","pose","r","b","regionBoundsOf","regionTakes","findShapeSilhouette","poseOutline","regionInPlane","m","pickWalk","scenePickSource","coords","v","p","toPlane","regionOf","rectToPlane"],"sources":["../../../src/canvas/deps/hitTestArea.ts"],"sourcesContent":["/**\n * Shared, silhouette-aware area hit-test used by both `areaSelect` (marquee)\n * and `lassoSelect` dep sources, and by `sceneToAdapter`.\n *\n * The per-node decision is `regionTakes` (`core/geometry/regionHit`), which\n * `arrayAdapter` shares. This module supplies the scene walk — layers, clips,\n * pose composition, containers — and the node's drawn outline: the painter's\n * world-frame silhouette (`findShapeSilhouette`), which is what reaches the\n * kit's own inserted shapes, whose geometry sits on `node.data` behind a bare\n * `{x,y,w,h}` pose. With no painter the outline is the pose rect, rotated if\n * the pose is.\n */\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { pathIntersectsRect } from '@weasel-js/geom';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport {\n  poseDescriptorForNode,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport {\n  pickWalk,\n  scenePickSource,\n  type PickQuery,\n  type ScenePickSourceOptions,\n} from 'canvas/pickWalk';\nimport { rectToPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\n\nexport { hiddenLayerIds } from 'canvas/pickWalk';\nimport type { HitTestView } from 'interactions/actions/depSchema';\nimport type { PoseComposition } from 'features/groups/composePose';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\nimport {\n  polygonRegion,\n  poseOutline,\n  rectRegion,\n  regionBoundsOf,\n  regionOf,\n  regionTakes,\n  type SelectRegion,\n} from 'core/geometry/regionHit';\n\nexport interface AABBBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** What a region query takes back beyond leaves. */\nexport interface RegionQueryOptions {\n  /** Default `false`: a region that takes a container and its children\n   *  selects the same ink twice. A bare-adapter consumer, which has nothing\n   *  to fold children back into their container, asks for them. */\n  includeContainers?: boolean;\n}\n\n\n/** The pick options a region dep hands the shared walk: the asking view's\n *  layer gate and camera, the surface's alpha, and the scene's pose\n *  composition. */\nexport function regionPickOptions(\n  view: HitTestView | undefined,\n  alphaOf: ((id: string) => number) | undefined,\n  poseComposition: PoseComposition<unknown> | undefined,\n): ScenePickSourceOptions<unknown> {\n  const camera = view?.get?.();\n  return {\n    ...(poseComposition ? { poseComposition } : {}),\n    ...(alphaOf ? { alphaOf } : {}),\n    ...(view?.layerIsPainted ? { layerIsPainted: (layer: string) => view.layerIsPainted!(layer) } : {}),\n    ...(camera ? { camera } : {}),\n  };\n}\n\n/** Marquee entry point: every node the rect `bounds` meets. */\nexport function hitTestArea(\n  scene: Scene<unknown, string, unknown>,\n  bounds: AABBBounds,\n  opts?: ScenePickSourceOptions<unknown>,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  return walkArea(scene, rectRegion(bounds), 'intersect', opts, descriptor, query);\n}\n\n/**\n * Every node an arbitrary closed area polygon meets. `area` is interleaved\n * `[x0,y0,x1,y1,…]`; `areaBounds` is its AABB, derived when omitted.\n */\nexport function hitTestAreaPolygon(\n  scene: Scene<unknown, string, unknown>,\n  area: ArrayLike<number>,\n  areaBounds?: AABBBounds,\n  /** True when `area` IS its own bounding rect, so `areaBounds` containment\n   *  implies containment in the area proper. Never pass this for a lasso\n   *  polygon — a node inside the hull's box can miss the hull. */\n  areaIsRect = false,\n  /** The asking view's alpha and layer accessors. A bare scene answers for\n   *  itself; a view that dims or reorders layers has to supply its own. */\n  opts?: ScenePickSourceOptions<unknown>,\n  /** How to read this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  const region = regionOf(area, areaBounds, areaIsRect);\n  return region ? walkArea(scene, region, 'intersect', opts, descriptor, query) : [];\n}\n\n/**\n * Lasso entry point: which nodes a closed lasso polygon picks under `mode`\n * (see `regionTakes`).\n */\nexport function hitTestLassoPolygon(\n  scene: Scene<unknown, string, unknown>,\n  polygon: ReadonlyArray<{ x: number; y: number }>,\n  mode: LassoHitMode,\n  opts?: ScenePickSourceOptions<unknown>,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  const region = polygonRegion(polygon);\n  return region ? walkArea(scene, region, mode, opts, descriptor, query) : [];\n}\n\n/** The walk every region query shares: skip containers unless asked, gate on\n *  the clip, and let `regionTakes` decide each node. */\nfunction walkArea(\n  scene: Scene<unknown, string, unknown>,\n  region: SelectRegion,\n  mode: LassoHitMode,\n  opts: ScenePickSourceOptions<unknown> | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  query: RegionQueryOptions,\n): NodeId[] {\n  const regionQuery = (r: SelectRegion): PickQuery<unknown> => ({\n    includeContainers: query.includeContainers === true,\n    clipAdmits: (clip, node, pose) => {\n      const g = poseDescriptorForNode(descriptor, node);\n      return pathIntersectsRect(clip, visualBoundsViaDescriptor(pose, g))\n        && pathIntersectsRect(clip, r.bounds);\n    },\n    hits: (node, pose) => {\n      // The descriptor sees the node here, so a pose shape whose extent\n      // depends on `node.data` bounds itself rather than its pose's default.\n      const g = poseDescriptorForNode(descriptor, node);\n      const b = regionBoundsOf(node as object, pose, g);\n      return regionTakes(r, mode, pose, b, () =>\n        findShapeSilhouette(node as never, pose) ?? poseOutline(pose, b));\n    },\n    inPlane: (m) => regionQuery(regionInPlane(r, m)),\n  });\n  return pickWalk<unknown>(scenePickSource(scene, opts), regionQuery(region)) as NodeId[];\n}\n\n/** `r` carried into a plane's world. The map is axis-aligned, so a rect stays\n *  one; a flipped axis reverses the winding, which no region test reads. */\nfunction regionInPlane(r: SelectRegion, m: PlaneMap): SelectRegion {\n  const coords: number[] = [];\n  for (const v of r.verts) {\n    const p = toPlane(m, v);\n    coords.push(p.x, p.y);\n  }\n  return regionOf(coords, rectToPlane(m, r.bounds), r.isRect)!;\n}\n"],"mappings":";;;;;;;;AA8DA,SAAgBA,EACd,GACA,GACA,GACiC;CACjC,IAAMC,IAASC,GAAM,MAAM;CAC3B,OAAO;EACL,GAAIC,IAAkB,EAAE,mBAAgB,IAAI,CAAC;EAC7C,GAAIC,IAAU,EAAE,WAAQ,IAAI,CAAC;EAC7B,GAAIF,GAAM,iBAAiB,EAAE,iBAAiB,MAAkBA,EAAK,eAAgBG,CAAK,EAAE,IAAI,CAAC;EACjG,GAAIJ,IAAS,EAAE,UAAO,IAAI,CAAC;CAC7B;AACF;AAGA,SAAgBK,EACd,GACA,GACA,GACA,IAAsCC,GACtC,IAA4B,CAAC,GACnB;CACV,OAAOC,EAASC,GAAOC,EAAWC,CAAM,GAAG,aAAaC,GAAMC,GAAYC,CAAK;AACjF;AA6BA,SAAgBC,EACd,GACA,GACA,GACA,GACA,IAAsCR,GACtC,IAA4B,CAAC,GACnB;CACV,IAAMS,IAASC,EAAcC,CAAO;CACpC,OAAOF,IAASR,EAASC,GAAOO,GAAQG,GAAMP,GAAMC,GAAYC,CAAK,IAAI,CAAC;AAC5E;AAIA,SAASN,EACP,GACA,GACA,GACA,GACA,GACA,GACU;CACV,IAAMY,KAAe,OAAyC;EAC5D,mBAAmBN,EAAM,sBAAsB;EAC/C,aAAa,GAAM,GAAM,MAAS;GAChC,IAAMO,IAAIC,EAAsBT,GAAYU,CAAI;GAChD,OAAOC,EAAmBC,GAAMC,EAA0BC,GAAMN,CAAC,CAAC,KAC7DG,EAAmBC,GAAMG,EAAE,MAAM;EACxC;EACA,OAAO,GAAM,MAAS;GAGpB,IAAMP,IAAIC,EAAsBT,GAAYU,CAAI,GAC1CM,IAAIC,EAAeP,GAAgBI,GAAMN,CAAC;GAChD,OAAOU,EAAYH,GAAGT,GAAMQ,GAAME,SAChCG,EAAoBT,GAAeI,CAAI,KAAKM,EAAYN,GAAME,CAAC,CAAC;EACpE;EACA,UAAU,MAAMT,EAAYc,EAAcN,GAAGO,CAAC,CAAC;CACjD;CACA,OAAOC,EAAkBC,EAAgB5B,GAAOG,CAAI,GAAGQ,EAAYJ,CAAM,CAAC;AAC5E;AAIA,SAASkB,EAAc,GAAiB,GAA2B;CACjE,IAAMI,IAAmB,CAAC;CAC1B,KAAK,IAAMC,KAAKX,EAAE,OAAO;EACvB,IAAMY,IAAIC,EAAQN,GAAGI,CAAC;EACtB,EAAO,KAAKC,EAAE,GAAGA,EAAE,CAAC;CACtB;CACA,OAAOE,EAASJ,GAAQK,EAAYR,GAAGP,EAAE,MAAM,GAAGA,EAAE,MAAM;AAC5D"}
+{"version":3,"file":"hitTestArea.js","names":["regionPickOptions","camera","view","alphaOf","layer","hitTestArea","AUTO_POSE_DESCRIPTOR","walkArea","scene","rectRegion","bounds","opts","descriptor","query","hitTestLassoPolygon","region","polygonRegion","polygon","mode","asInked","shape","filled","regionQuery","g","poseDescriptorForNode","node","pathIntersectsRect","clip","visualBoundsViaDescriptor","pose","r","b","regionBoundsOf","ink","findShapeInk","regionTakes","findShapeSilhouette","poseOutline","regionInPlane","m","regionInCopy","pickWalk","scenePickSource","coords","v","p","toPlane","regionOf","rectToPlane","x0","y0","x1","y1","x","y","applyToPoint","keepsAxes"],"sources":["../../../src/canvas/deps/hitTestArea.ts"],"sourcesContent":["/**\n * Silhouette-aware area hit-test for marquee and lasso selection.\n *\n * The per-node decision is `regionTakes` (`core/geometry/regionHit`). This\n * module supplies the scene walk and the node's drawn outline: the painter's\n * world-frame silhouette (`findShapeSilhouette`), or with no painter the pose\n * rect, rotated if the pose is.\n */\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { applyToPoint, pathIntersectsRect, type Affine } from '@weasel-js/geom';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport {\n  poseDescriptorForNode,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport {\n  pickWalk,\n  scenePickSource,\n  type PickQuery,\n  type ScenePickSourceOptions,\n} from 'canvas/pickWalk';\nimport { rectToPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\n\nexport { hiddenLayerIds } from 'canvas/pickWalk';\nimport type { HitTestView } from 'interactions/actions/depSchema';\nimport { findShapeInk, findShapeSilhouette } from 'canvas/NodeShape';\nimport {\n  polygonRegion,\n  poseOutline,\n  rectRegion,\n  regionBoundsOf,\n  regionOf,\n  regionTakes,\n  type SelectRegion,\n} from 'core/geometry/regionHit';\n\nexport interface AABBBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** What a region query takes back beyond leaves. */\nexport interface RegionQueryOptions {\n  /** Default `false`: a region that takes a container and its children\n   *  selects the same ink twice. A bare-adapter consumer, which has nothing\n   *  to fold children back into their container, asks for them. */\n  includeContainers?: boolean;\n}\n\n\n/** The pick options a region dep hands the shared walk: the asking view's\n *  layer gate and camera, and the surface's alpha. */\nexport function regionPickOptions(\n  view: HitTestView | undefined,\n  alphaOf: ((id: string) => number) | undefined,\n): ScenePickSourceOptions<unknown> {\n  const camera = view?.get?.();\n  return {\n    ...(alphaOf ? { alphaOf } : {}),\n    ...(view?.layerIsPainted ? { layerIsPainted: (layer: string) => view.layerIsPainted!(layer) } : {}),\n    ...(camera ? { camera } : {}),\n  };\n}\n\n/** Marquee entry point: every node the rect `bounds` meets. */\nexport function hitTestArea(\n  scene: Scene<unknown, string, unknown>,\n  bounds: AABBBounds,\n  opts?: ScenePickSourceOptions<unknown>,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  return walkArea(scene, rectRegion(bounds), 'intersect', opts, descriptor, query);\n}\n\n/**\n * Every node an arbitrary closed area polygon meets. `area` is interleaved\n * `[x0,y0,x1,y1,…]`; `areaBounds` is its AABB, derived when omitted.\n */\nexport function hitTestAreaPolygon(\n  scene: Scene<unknown, string, unknown>,\n  area: ArrayLike<number>,\n  areaBounds?: AABBBounds,\n  /** True when `area` IS its own bounding rect, so `areaBounds` containment\n   *  implies containment in the area proper. Never pass this for a lasso\n   *  polygon — a node inside the hull's box can miss the hull. */\n  areaIsRect = false,\n  /** The asking view's alpha and layer accessors. A bare scene answers for\n   *  itself; a view that dims or reorders layers has to supply its own. */\n  opts?: ScenePickSourceOptions<unknown>,\n  /** How to read this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  const region = regionOf(area, areaBounds, areaIsRect);\n  return region ? walkArea(scene, region, 'intersect', opts, descriptor, query) : [];\n}\n\n/**\n * Lasso entry point: which nodes a closed lasso polygon picks under `mode`\n * (see `regionTakes`).\n */\nexport function hitTestLassoPolygon(\n  scene: Scene<unknown, string, unknown>,\n  polygon: ReadonlyArray<{ x: number; y: number }>,\n  mode: LassoHitMode,\n  opts?: ScenePickSourceOptions<unknown>,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  const region = polygonRegion(polygon);\n  return region ? walkArea(scene, region, mode, opts, descriptor, query) : [];\n}\n\n/** `shape` as a region reads it: a polygon path's open subpaths enclose\n *  nothing when the node's painter lays down no fill. */\nfunction asInked<T>(filled: () => boolean, shape: T): T {\n  if ((shape as { kind?: unknown } | null)?.kind !== 'polygon') return shape;\n  return filled() ? shape : { ...shape, openFill: 'none' };\n}\n\n/** The walk every region query shares: skip containers unless asked, gate on\n *  the clip, and let `regionTakes` decide each node. */\nfunction walkArea(\n  scene: Scene<unknown, string, unknown>,\n  region: SelectRegion,\n  mode: LassoHitMode,\n  opts: ScenePickSourceOptions<unknown> | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  query: RegionQueryOptions,\n): NodeId[] {\n  const regionQuery = (r: SelectRegion): PickQuery<unknown> => ({\n    includeContainers: query.includeContainers === true,\n    clipAdmits: (clip, node, pose) => {\n      const g = poseDescriptorForNode(descriptor, node);\n      return pathIntersectsRect(clip, visualBoundsViaDescriptor(pose, g))\n        && pathIntersectsRect(clip, r.bounds);\n    },\n    hits: (node, pose) => {\n      // The descriptor sees the node here, so a pose shape whose extent\n      // depends on `node.data` bounds itself rather than its pose's default.\n      const g = poseDescriptorForNode(descriptor, node);\n      const b = regionBoundsOf(node as object, pose, g);\n      let ink: boolean | undefined;\n      const filled = (): boolean => ink ??= findShapeInk(node as never, pose)?.filled !== false;\n      return regionTakes(r, mode, asInked(filled, pose), b, () =>\n        asInked(filled, findShapeSilhouette(node as never, pose) ?? poseOutline(pose, b)), filled);\n    },\n    inPlane: (m) => regionQuery(regionInPlane(r, m)),\n    inCopy: (m) => regionQuery(regionInCopy(r, m)),\n  });\n  return pickWalk<unknown>(scenePickSource(scene, opts), regionQuery(region)) as NodeId[];\n}\n\n/** `r` carried into a plane's world. The map is axis-aligned, so a rect stays\n *  one; a flipped axis reverses the winding, which no region test reads. */\nfunction regionInPlane(r: SelectRegion, m: PlaneMap): SelectRegion {\n  const coords: number[] = [];\n  for (const v of r.verts) {\n    const p = toPlane(m, v);\n    coords.push(p.x, p.y);\n  }\n  return regionOf(coords, rectToPlane(m, r.bounds), r.isRect)!;\n}\n\n/** `r` carried by an affine into a copy's source frame. A rect stays one only\n *  while the map keeps the axes; a turn makes it a polygon. */\nfunction regionInCopy(r: SelectRegion, m: Affine): SelectRegion {\n  const coords: number[] = [];\n  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;\n  for (const v of r.verts) {\n    const [x, y] = applyToPoint(m, v.x, v.y);\n    coords.push(x, y);\n    x0 = Math.min(x0, x); y0 = Math.min(y0, y); x1 = Math.max(x1, x); y1 = Math.max(y1, y);\n  }\n  const keepsAxes = (m[1] === 0 && m[2] === 0) || (m[0] === 0 && m[3] === 0);\n  return regionOf(coords, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 }, r.isRect && keepsAxes)!;\n}\n"],"mappings":"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"}

package/dist/canvas/deps/insert.js

@@ -1,144 +1,189 @@
-import { insertPreviewExtent as e } from "../insertPreviewExtent.js";
-import { cycleFill as t, solid as n, strokeOf as r } from "../../util/paint.js";
-import { createInsertOp as i } from "../../core/ops/create.js";
-import { ellipsePath as a, linePath as o, polygonFromPoints as s, rectPath as c, regularPolygonPath as l, schneiderFit as u, starPath as d } from "@weasel-js/geom";
-import { useRef as f } from "react";
-import { useLatest as p } from "@weasel-js/react";
-import { useDepSource as m } from "@weasel-js/routing/react";
+import { composeWorldPose as e, composesFrames as t } from "../../core/scene/composeFrame.js";
+import { definesFrame as n } from "../../core/scene/effectivePose.js";
+import { insertPreviewExtent as r } from "../insertPreviewExtent.js";
+import { cycleFill as i, solid as a, strokeOf as o } from "../../util/paint.js";
+import { createInsertOp as s } from "../../core/ops/create.js";
+import { ellipsePath as c, linePath as l, polygonFromPoints as u, rectPath as d, regularPolygonPath as f, schneiderFit as p, starPath as m } from "@weasel-js/geom";
+import { useRef as h } from "react";
+import { useLatest as g } from "@weasel-js/react";
+import { useDepRegistry as _, useDepSource as v } from "@weasel-js/routing/react";
 //#region src/canvas/deps/insert.ts
-var h = (e, i) => {
-	let a = t(i);
-	return e === "pencil" ? { stroke: r(a, 2) } : e === "line" || e === "path" ? {
-		fill: n(a),
-		stroke: r(a, 2)
-	} : { fill: n(a) };
+function y({ fill: e, stroke: t }) {
+	return {
+		...e === void 0 ? {} : { fill: e },
+		...t === void 0 ? {} : { stroke: t }
+	};
+}
+function b(e, t) {
+	let n = e?.path;
+	return t === void 0 || n === void 0 || !("fillRule" in n) ? e : {
+		...e,
+		path: {
+			...n,
+			fillRule: t
+		}
+	};
+}
+var x = (e, t) => {
+	let n = i(t);
+	return e === "line" || e === "pencil" ? { stroke: o(n, 2) } : e === "path" ? {
+		fill: { paint: a(n) },
+		stroke: o(n, 2)
+	} : { fill: { paint: a(n) } };
 };
-function g(t, n, r, g = h) {
-	let _ = p(t), v = p(n), y = p(r), b = p(g), x = f(0), S = f({ gesture: null });
-	m("insertLive", () => S.current), m("insert", () => {
-		let t = _.current, n = v.current, r = t.layers[0]?.id ?? "default", f = (n, f) => {
-			let p = f.kind, m = ++x.current, h = t.mintId(), g = (e = p) => {
-				let { fill: t, stroke: n } = b.current(e, m);
-				return {
-					...t === void 0 ? {} : { fill: t },
-					...n === void 0 ? {} : { stroke: n }
-				};
-			}, _ = e({
-				shape: p,
-				bounds: n,
-				extras: f
-			}), v = _.bounds, S = y.current?.[p];
-			if (S) {
-				let e = S(n, f);
+function S(e, t, n, r) {
+	switch (e) {
+		case "rect": return {
+			path: d(0, 0, t.width, t.height),
+			...r()
+		};
+		case "ellipse": return {
+			path: c(t),
+			...r()
+		};
+		case "path": {
+			let e = n;
+			return {
+				path: e.path,
+				...r(),
+				...e.closed ? {} : { fill: null }
+			};
+		}
+		case "text": return { text: n.text ?? "" };
+		case "image": {
+			let e = n;
+			return { image: {
+				src: e.src ?? "",
+				...e.opacity === void 0 ? {} : { opacity: e.opacity }
+			} };
+		}
+		default: return null;
+	}
+}
+function C(r, i) {
+	let a = i == null ? void 0 : r.get(i);
+	if (a === void 0 || a.kind !== "container") return {
+		parent: null,
+		layer: r.layers[0]?.id ?? "default",
+		local: (e) => e
+	};
+	let o = r.composition;
+	if (o === void 0 || !t(o)) return {
+		parent: a.id,
+		layer: a.layer,
+		local: (e) => e
+	};
+	let s = e({
+		getPose: (e) => r.get(e).pose,
+		getParent: (e) => r.get(e)?.parent ?? null,
+		definesFrame: (e) => n(r.get(e) ?? {})
+	}, a.id, o.compose);
+	return {
+		parent: a.id,
+		layer: a.layer,
+		local: (e) => o.decompose(s, e)
+	};
+}
+function w(e, t, n, i = x) {
+	let a = g(e), o = g(t), c = g(n), w = g(i), T = _(), E = h(0), D = h({ gesture: null });
+	v("insertLive", () => D.current), v("insert", () => {
+		let e = a.current, t = o.current, n = () => C(e, T.get("insertInto")?.get()), i = (t, i) => {
+			let a = i.kind, { parent: o, layer: h, local: g } = n(), _ = ++E.current, v = e.mintId(), x, C = (e = a) => y(x = w.current(e, _)), T = r({
+				shape: a,
+				bounds: t,
+				extras: i
+			}), D = T.bounds, O = c.current?.[a];
+			if (O) {
+				let e = O(t, i);
 				return e === null ? null : {
-					id: h,
-					ops: [i({
+					id: v,
+					ops: [s({
 						node: {
-							id: h,
+							id: v,
 							kind: "leaf",
-							layer: r,
-							pose: e.pose ?? v,
+							layer: h,
+							parent: o,
+							pose: g(e.pose ?? D),
 							data: e.data
 						},
-						label: `Insert ${p}`
+						label: `Insert ${a}`
 					})]
 				};
 			}
-			let C = _.geometry, w;
-			switch (C.kind) {
+			let k = T.geometry, A;
+			switch (k.kind) {
 				case "line":
-					w = {
-						path: o(C.a, C.b),
-						...g()
+					A = {
+						path: l(k.a, k.b),
+						...C(),
+						fill: null
 					};
 					break;
 				case "polygon":
-					w = {
-						path: l(C.center, C.radius, C.sides, C.rotation),
-						...g()
+					A = {
+						path: f(k.center, k.radius, k.sides, k.rotation),
+						generator: {
+							kind: "polygon",
+							sides: k.sides,
+							rotation: k.rotation
+						},
+						...C()
 					};
 					break;
 				case "star":
-					w = {
-						path: d(C.center, C.outerRadius, C.points, C.innerRadius, C.rotation),
-						...g()
+					A = {
+						path: m(k.center, k.outerRadius, k.points, k.innerRadius, k.rotation),
+						generator: {
+							kind: "star",
+							points: k.points,
+							innerRadiusRatio: k.outerRadius === 0 ? .5 : k.innerRadius / k.outerRadius,
+							rotation: k.rotation
+						},
+						...C()
 					};
 					break;
 				case "pencil": {
-					let e = C.samples;
-					w = e.length >= 4 ? {
-						path: u(e, 2),
-						...g()
+					let e = k.samples;
+					A = e.length >= 4 ? {
+						path: p(e, 2),
+						...C()
 					} : e.length >= 2 ? {
-						path: s(e),
-						...g()
+						path: u(e),
+						...C()
 					} : {
-						path: c(0, 0, _.bounds.width, _.bounds.height),
-						...g("rect")
+						path: d(0, 0, T.bounds.width, T.bounds.height),
+						...C("rect")
 					};
 					break;
 				}
-				case "box": switch (p) {
-					case "rect":
-						w = {
-							path: c(0, 0, _.bounds.width, _.bounds.height),
-							...g()
-						};
-						break;
-					case "ellipse":
-						w = {
-							path: a(_.bounds),
-							...g()
-						};
-						break;
-					case "path": {
-						let e = f;
-						w = {
-							path: e.path,
-							...g(),
-							...e.closed ? {} : { fill: null }
-						};
-						break;
-					}
-					case "text":
-						w = { text: f.text ?? "" };
-						break;
-					case "image": {
-						let e = f;
-						w = { image: {
-							src: e.src ?? "",
-							...e.opacity === void 0 ? {} : { opacity: e.opacity }
-						} };
-						break;
-					}
-					default: return console.warn(`weasel insertDep: no factory for kind="${p}". Skipping insert.`), null;
-				}
+				case "box": if (A = S(a, T.bounds, i, C), A === null) return console.warn(`weasel insertDep: no factory for kind="${a}". Skipping insert.`), null;
 			}
-			return {
-				id: h,
-				ops: [i({
+			return A = b(A, x?.fillRule), {
+				id: v,
+				ops: [s({
 					node: {
-						id: h,
+						id: v,
 						kind: "leaf",
-						layer: r,
-						pose: v,
-						data: w
+						layer: h,
+						parent: o,
+						pose: g(D),
+						data: A
 					},
-					label: `Insert ${p}`
+					label: `Insert ${a}`
 				})]
 			};
 		};
 		return {
-			layer: () => r,
-			build: f,
-			commit(e, t) {
-				let r = f(e, t);
-				return r === null ? null : (n.applyOps(r.ops, `Insert ${t.kind}`), r.id);
+			layer: () => n().layer,
+			build: i,
+			commit(e, n) {
+				let r = i(e, n);
+				return r === null ? null : (t.applyOps(r.ops, `Insert ${n.kind}`), r.id);
 			}
 		};
 	});
 }
 //#endregion
-export { h as paletteInsertPaint, g as useInsertDepSource };
+export { x as paletteInsertPaint, w as useInsertDepSource };
 
 //# sourceMappingURL=insert.js.map

package/dist/canvas/deps/insert.js.map

@@ -1 +1 @@
-{"version":3,"file":"insert.js","names":["e","paletteInsertPaint","color","cycleFill","seq","kind","strokeOf","solid","useInsertDepSource","sceneRef","useLatest","scene","adapterRef","adapter","factoriesRef","factories","paintRef","paint","insertSeqRef","useRef","liveRef","useDepSource","sc","ad","layer","build","extras","id","painted","as","fill","stroke","extent","insertPreviewExtent","pose","factory","built","bounds","createInsertOp","geom","data","linePath","regularPolygonPath","starPath","samples","schneiderFit","polygonFromPoints","rectPath","ellipsePath"],"sources":["../../../src/canvas/deps/insert.ts"],"sourcesContent":["/**\n * `useInsertDepSource` — wires the `insert` dep consumed by `insertAction`.\n *\n * Provides kit-side kind→data factories for the 6 builtin shape kinds\n * (`rect`, `ellipse`, `line`, `polygon`, `star`, `pencil`). Acceptable because\n * these kinds are kit-shipped tools; a future phase can expose a\n * `nodeFactories` prop for consumer-defined kinds.\n *\n * `line`, `polygon`, `star` and `pencil` receive the drag AABB from the\n * insertAction invoker, but `extras` may carry richer geometry (endpoints,\n * center+radius+rotation, point trail). `insertPreviewExtent` resolves the\n * two into the node's real extent — the same resolution the live preview\n * and the reported gesture bounds use.\n */\nimport { useRef } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { InsertDep, InsertExtras, InsertLive } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport {\n  rectPath,\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  linePath,\n  polygonFromPoints,\n  schneiderFit,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport { insertPreviewExtent } from '../insertPreviewExtent';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * Consumer-supplied node factory for one insert `kind`. Given the drag AABB\n * and the tool's `extras`, returns the node's `data` (in the consumer's own\n * data shape) plus an optional `pose` override — the dep supplies id, layer,\n * and the undoable insert op. Return `null` to reject the insert.\n *\n * A factory registered for a kit kind (`rect`, `line`, …) fully replaces the\n * kit's default `{ path, fill }` factory for that kind; a factory for a novel\n * kind adds support the kit doesn't ship (e.g. `text`). To change only the\n * paint of a kit shape, pass an {@link InsertPaint}. See\n * `SceneCanvas`'s `insertNodeFactories` prop.\n */\nexport type InsertNodeFactory = (\n  bounds: { x: number; y: number; width: number; height: number },\n  extras: InsertExtras,\n) => { data: unknown; pose?: unknown } | null;\n\n/**\n * The paint a kit-built shape is inserted with. `kind` is the shape being\n * built and `seq` counts this canvas's inserts from 1. A key left out stays\n * off the node, so its painter's default applies; `null` is \"none\". A pencil\n * trail too short to fit is built as a rect and asks as one.\n *\n * It paints only the shapes the kit builds: an `InsertNodeFactory` owns its\n * node's whole `data`. See `SceneCanvas`'s `insertPaint` prop.\n */\nexport type InsertPaint = (kind: string, seq: number) => { fill?: FillStyle | null; stroke?: Stroke | null };\n\n/** The default {@link InsertPaint}: the next color of the kit palette, as a\n *  fill on a closed shape, a fill and a stroke on a line or a pen path, and a\n *  stroke alone on a pencil trail. */\nexport const paletteInsertPaint: InsertPaint = (kind, seq) => {\n  const color = cycleFill(seq);\n  if (kind === 'pencil') return { stroke: strokeOf(color, 2) };\n  if (kind === 'line' || kind === 'path') return { fill: solid(color), stroke: strokeOf(color, 2) };\n  return { fill: solid(color) };\n};\n\nexport function useInsertDepSource(\n  scene: Scene<unknown, string, unknown>,\n  adapter: OpsApplier,\n  factories?: Record<string, InsertNodeFactory>,\n  paint: InsertPaint = paletteInsertPaint,\n): void {\n  const sceneRef = useLatest(scene);\n  const adapterRef = useLatest(adapter);\n  const factoriesRef = useLatest(factories);\n  const paintRef = useLatest(paint);\n  const insertSeqRef = useRef(0);\n  const liveRef = useRef<InsertLive>({ gesture: null });\n  useDepSource('insertLive', () => liveRef.current);\n\n  useDepSource('insert', (): InsertDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n\n    const layer = (sc.layers[0]?.id ?? 'default') as string;\n    const build = (\n      bounds: { x: number; y: number; width: number; height: number },\n      extras: InsertExtras,\n    ): { id: NodeId; ops: Op[] } | null => {\n        const kind = extras.kind;\n        const seq = ++insertSeqRef.current;\n        const id = sc.mintId();\n        const painted = (as: string = kind): { fill?: FillStyle | null; stroke?: Stroke | null } => {\n          const { fill, stroke } = paintRef.current(as, seq);\n          return { ...(fill !== undefined ? { fill } : {}), ...(stroke !== undefined ? { stroke } : {}) };\n        };\n\n        // The nascent node's extent — drag AABB reconciled with whatever\n        // richer geometry `extras` carries.\n        const extent = insertPreviewExtent({ shape: kind, bounds, extras });\n        const pose: unknown = extent.bounds;\n\n        // Consumer factory wins over the kit default for this kind (and is the\n        // only way to insert consumer-defined kinds like `text`). It owns the\n        // node's data + optional pose; the dep still supplies id/layer/op.\n        const factory = factoriesRef.current?.[kind];\n        if (factory) {\n          const built = factory(bounds, extras);\n          if (built === null) return null;\n          return {\n            id,\n            ops: [createInsertOp({ node: { id, kind: 'leaf', layer, pose: built.pose ?? pose, data: built.data } as unknown as { id: string }, label: `Insert ${kind}` })],\n          };\n        }\n\n        const geom = extent.geometry;\n        let data: unknown;\n\n        switch (geom.kind) {\n          case 'line':\n            data = { path: linePath(geom.a, geom.b), ...painted() };\n            break;\n          case 'polygon':\n            data = {\n              path: regularPolygonPath(geom.center, geom.radius, geom.sides, geom.rotation),\n              ...painted(),\n            };\n            break;\n          case 'star':\n            data = {\n              path: starPath(geom.center, geom.outerRadius, geom.points, geom.innerRadius, geom.rotation),\n              ...painted(),\n            };\n            break;\n          case 'pencil': {\n            const samples = geom.samples as { x: number; y: number }[];\n            if (samples.length >= 4) {\n              data = { path: schneiderFit(samples, 2.0), ...painted() };\n            } else if (samples.length >= 2) {\n              data = { path: polygonFromPoints(samples), ...painted() };\n            } else {\n              data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), ...painted('rect') };\n            }\n            break;\n          }\n          case 'box':\n            switch (kind) {\n              case 'rect':\n                // Geometry-in-local-frame: the rect path lives at the origin and\n                // the pose carries position. `pathInPoseFrame` rebases a rect path\n                // onto the pose box regardless of the stored coords, so origin vs.\n                // duplicated-pose-coords render identically — don't double-count\n                // the position. (#13)\n                data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), ...painted() };\n                break;\n              case 'ellipse':\n                data = { path: ellipsePath(extent.bounds), ...painted() };\n                break;\n              case 'path': {\n                const e = extras as { path: PolygonPath; closed: boolean };\n                data = { path: e.path, ...painted(), ...(e.closed ? {} : { fill: null }) };\n                break;\n              }\n              case 'text': {\n                // The built-in `useTextTool` drags an empty text box you then type\n                // into (edit is entered via `enterTextEdit`), so `extras` carries\n                // no content and `text` defaults to `''`. The kit:text painter\n                // matches on `data.text != null` and applies style defaults at\n                // render time, so a bare `{ text }` is a complete, editable node.\n                const e = extras as Partial<{ text: string }>;\n                data = { text: e.text ?? '' };\n                break;\n              }\n              case 'image': {\n                // The bitmap is loaded + cached by `imageCache` keyed on `src`;\n                // only the (serializable) `src` lives on the node.\n                const e = extras as Partial<{ src: string; opacity: number }>;\n                data = {\n                  image: {\n                    src: e.src ?? '',\n                    ...(e.opacity !== undefined ? { opacity: e.opacity } : {}),\n                  },\n                };\n                break;\n              }\n              default:\n                console.warn(`weasel insertDep: no factory for kind=\"${kind}\". Skipping insert.`);\n                return null;\n            }\n            break;\n        }\n\n        return {\n          id,\n          ops: [createInsertOp({ node: { id, kind: 'leaf', layer, pose, data } as unknown as { id: string }, label: `Insert ${kind}` })],\n        };\n    };\n    return {\n      layer: () => layer,\n      build,\n      commit(bounds, extras): NodeId | null {\n        const built = build(bounds, extras);\n        if (built === null) return null;\n        ad.applyOps(built.ops, `Insert ${extras.kind}`);\n        return built.id;\n      },\n    };\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"insert.js","names":["e","paintKeys","fill","stroke","withFillRule","path","data","rule","paletteInsertPaint","color","cycleFill","seq","kind","strokeOf","solid","boxKindData","rectPath","bounds","painted","ellipsePath","extras","insertSite","parent","into","sc","p","composition","composesFrames","frame","composeWorldPose","id","definesFrame","useInsertDepSource","sceneRef","useLatest","scene","adapterRef","adapter","factoriesRef","factories","paintRef","paint","registry","useDepRegistry","insertSeqRef","useRef","liveRef","useDepSource","ad","site","build","asked","as","extent","insertPreviewExtent","pose","factory","built","createInsertOp","local","geom","linePath","regularPolygonPath","starPath","samples","schneiderFit","polygonFromPoints"],"sources":["../../../src/canvas/deps/insert.ts"],"sourcesContent":["/**\n * `useInsertDepSource` — wires the `insert` dep consumed by `insertAction`.\n *\n * `line`, `polygon`, `star`, and `pencil` receive the drag AABB from the insertAction invoker,\n * but `extras` may carry richer geometry (endpoints, center+radius+rotation, point trail).\n * `insertPreviewExtent` resolves the two into the node's real extent — the same resolution the\n * live preview and the reported gesture bounds use.\n */\nimport { useRef } from 'react';\nimport { useDepRegistry, useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { InsertDep, InsertExtras, InsertLive } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport {\n  rectPath,\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  linePath,\n  polygonFromPoints,\n  schneiderFit,\n  type PathFillRule,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport { insertPreviewExtent } from '../insertPreviewExtent';\nimport type { ShapeGenerator } from 'features/paths/shapeGenerator';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\nimport { composesFrames, composeWorldPose } from 'core/scene/composeFrame';\nimport { definesFrame } from 'core/scene/effectivePose';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * Consumer-supplied node factory for one insert `kind`. Given the drag AABB\n * and the tool's `extras`, returns the node's `data` (in the consumer's own\n * data shape) plus an optional `pose` override — the dep supplies id, layer,\n * and the undoable insert op. Return `null` to reject the insert.\n *\n * A factory registered for a kit kind (`rect`, `line`, …) fully replaces the\n * kit's default `{ path, fill }` factory for that kind; a factory for a novel\n * kind adds support the kit doesn't ship (e.g. `text`). To change only the\n * paint of a kit shape, pass an {@link InsertPaint}. See\n * `SceneCanvas`'s `insertNodeFactories` prop.\n */\nexport type InsertNodeFactory = (\n  bounds: { x: number; y: number; width: number; height: number },\n  extras: InsertExtras,\n) => { data: unknown; pose?: unknown } | null;\n\n/**\n * The paint a kit-built shape is inserted with. `kind` is the shape being\n * built and `seq` counts this canvas's inserts from 1. A key left out stays\n * off the node, so its painter's default applies; `null` is \"none\". A pencil\n * trail too short to fit is built as a rect and asks as one. A line and an\n * open pen path are inserted unfilled: a fill given to either is dropped.\n * `fillRule` is the rule a path that carries one is built with, where the\n * kit's own is nonzero; a rect or an ellipse has none to set.\n *\n * It paints only the shapes the kit builds: an `InsertNodeFactory` owns its\n * node's whole `data`. See `SceneCanvas`'s `insertPaint` prop.\n */\nexport type InsertPaint = (kind: string, seq: number) => {\n  fill?: Fill | null;\n  stroke?: Stroke | null;\n  fillRule?: PathFillRule;\n};\n\nfunction paintKeys({ fill, stroke }: ReturnType<InsertPaint>): { fill?: Fill | null; stroke?: Stroke | null } {\n  return { ...(fill !== undefined ? { fill } : {}), ...(stroke !== undefined ? { stroke } : {}) };\n}\n\nfunction withFillRule(data: unknown, rule: PathFillRule | undefined): unknown {\n  const path = (data as { path?: object } | undefined)?.path;\n  if (rule === undefined || path === undefined || !('fillRule' in path)) return data;\n  return { ...(data as object), path: { ...path, fillRule: rule } };\n}\n\n/** The default {@link InsertPaint}: the next color of the kit palette, as a\n *  fill on a closed shape, a fill and a stroke on a pen path, and a stroke\n *  alone on a line or a pencil trail. */\nexport const paletteInsertPaint: InsertPaint = (kind, seq) => {\n  const color = cycleFill(seq);\n  if (kind === 'line' || kind === 'pencil') return { stroke: strokeOf(color, 2) };\n  if (kind === 'path') return { fill: { paint: solid(color) }, stroke: strokeOf(color, 2) };\n  return { fill: { paint: solid(color) } };\n};\n\n/** The kit's default data for a kind drawn as a box, or `null` for a kind it has none for. */\nfunction boxKindData(\n  kind: string,\n  bounds: { x: number; y: number; width: number; height: number },\n  extras: InsertExtras,\n  painted: (as?: string) => ReturnType<typeof paintKeys>,\n): unknown {\n  switch (kind) {\n    case 'rect':\n      // The rect path lives at the origin and the pose carries position:\n      // `pathInPoseFrame` rebases a rect path onto the pose box, so don't\n      // double-count the position.\n      return { path: rectPath(0, 0, bounds.width, bounds.height), ...painted() };\n    case 'ellipse':\n      return { path: ellipsePath(bounds), ...painted() };\n    case 'path': {\n      const e = extras as { path: PolygonPath; closed: boolean };\n      return { path: e.path, ...painted(), ...(e.closed ? {} : { fill: null }) };\n    }\n    case 'text': {\n      // The built-in text tool drags an empty text box you then type into, so\n      // `extras` carries no content. The kit:text painter matches on\n      // `data.text != null` and applies style defaults at render time, so a bare\n      // `{ text }` is a complete, editable node.\n      const e = extras as Partial<{ text: string }>;\n      return { text: e.text ?? '' };\n    }\n    case 'image': {\n      // The bitmap is loaded + cached by `imageCache` keyed on `src`;\n      // only the (serializable) `src` lives on the node.\n      const e = extras as Partial<{ src: string; opacity: number }>;\n      return { image: { src: e.src ?? '', ...(e.opacity !== undefined ? { opacity: e.opacity } : {}) } };\n    }\n    default:\n      return null;\n  }\n}\n\n/**\n * Where an insert lands: the container the `insertInto` dep names, on that container's\n * layer, with the pose made local to it when the scene composes frames —\n * or the top of the tree, on the first layer, when it names no container.\n */\nfunction insertSite(\n  sc: Scene<unknown, string, unknown>,\n  into: string | null | undefined,\n): { parent: NodeId | null; layer: string; local: (world: unknown) => unknown } {\n  const parent = into == null ? undefined : sc.get(into as NodeId);\n  if (parent === undefined || parent.kind !== 'container') {\n    return { parent: null, layer: (sc.layers[0]?.id ?? 'default') as string, local: (p) => p };\n  }\n  const composition = sc.composition;\n  if (composition === undefined || !composesFrames(composition)) {\n    return { parent: parent.id, layer: parent.layer, local: (p) => p };\n  }\n  const frame = composeWorldPose({\n    getPose: (id) => sc.get(id as NodeId)!.pose,\n    getParent: (id) => sc.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => definesFrame(sc.get(id as NodeId) ?? {}),\n  }, parent.id, composition.compose);\n  return { parent: parent.id, layer: parent.layer, local: (p) => composition.decompose(frame, p) };\n}\n\nexport function useInsertDepSource(\n  scene: Scene<unknown, string, unknown>,\n  adapter: OpsApplier,\n  factories?: Record<string, InsertNodeFactory>,\n  paint: InsertPaint = paletteInsertPaint,\n): void {\n  const sceneRef = useLatest(scene);\n  const adapterRef = useLatest(adapter);\n  const factoriesRef = useLatest(factories);\n  const paintRef = useLatest(paint);\n  const registry = useDepRegistry();\n  const insertSeqRef = useRef(0);\n  const liveRef = useRef<InsertLive>({ gesture: null });\n  useDepSource('insertLive', () => liveRef.current);\n\n  useDepSource('insert', (): InsertDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n\n    const site = () => insertSite(sc, registry.get('insertInto')?.get());\n    const build = (\n      bounds: { x: number; y: number; width: number; height: number },\n      extras: InsertExtras,\n    ): { id: NodeId; ops: Op[] } | null => {\n        const kind = extras.kind;\n        const { parent, layer, local } = site();\n        const seq = ++insertSeqRef.current;\n        const id = sc.mintId();\n        let asked: ReturnType<InsertPaint> | undefined;\n        const painted = (as: string = kind) => paintKeys(asked = paintRef.current(as, seq));\n\n        // The nascent node's extent — drag AABB reconciled with whatever\n        // richer geometry `extras` carries.\n        const extent = insertPreviewExtent({ shape: kind, bounds, extras });\n        const pose: unknown = extent.bounds;\n\n        // Consumer factory wins over the kit default for this kind. It owns the node's\n        // data + optional pose; the dep still supplies id/layer/op.\n        const factory = factoriesRef.current?.[kind];\n        if (factory) {\n          const built = factory(bounds, extras);\n          if (built === null) return null;\n          return {\n            id,\n            ops: [createInsertOp({ node: { id, kind: 'leaf', layer, parent, pose: local(built.pose ?? pose), data: built.data } as unknown as { id: string }, label: `Insert ${kind}` })],\n          };\n        }\n\n        const geom = extent.geometry;\n        let data: unknown;\n\n        switch (geom.kind) {\n          case 'line':\n            data = { path: linePath(geom.a, geom.b), ...painted(), fill: null };\n            break;\n          case 'polygon':\n            data = {\n              path: regularPolygonPath(geom.center, geom.radius, geom.sides, geom.rotation),\n              generator: { kind: 'polygon', sides: geom.sides, rotation: geom.rotation } satisfies ShapeGenerator,\n              ...painted(),\n            };\n            break;\n          case 'star':\n            data = {\n              path: starPath(geom.center, geom.outerRadius, geom.points, geom.innerRadius, geom.rotation),\n              generator: {\n                kind: 'star',\n                points: geom.points,\n                innerRadiusRatio: geom.outerRadius === 0 ? 0.5 : geom.innerRadius / geom.outerRadius,\n                rotation: geom.rotation,\n              } satisfies ShapeGenerator,\n              ...painted(),\n            };\n            break;\n          case 'pencil': {\n            const samples = geom.samples as { x: number; y: number }[];\n            if (samples.length >= 4) {\n              data = { path: schneiderFit(samples, 2.0), ...painted() };\n            } else if (samples.length >= 2) {\n              data = { path: polygonFromPoints(samples), ...painted() };\n            } else {\n              data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), ...painted('rect') };\n            }\n            break;\n          }\n          case 'box':\n            data = boxKindData(kind, extent.bounds, extras, painted);\n            if (data === null) {\n              console.warn(`weasel insertDep: no factory for kind=\"${kind}\". Skipping insert.`);\n              return null;\n            }\n            break;\n        }\n\n        data = withFillRule(data, asked?.fillRule);\n        return {\n          id,\n          ops: [createInsertOp({ node: { id, kind: 'leaf', layer, parent, pose: local(pose), data } as unknown as { id: string }, label: `Insert ${kind}` })],\n        };\n    };\n    return {\n      layer: () => site().layer,\n      build,\n      commit(bounds, extras): NodeId | null {\n        const built = build(bounds, extras);\n        if (built === null) return null;\n        ad.applyOps(built.ops, `Insert ${extras.kind}`);\n        return built.id;\n      },\n    };\n  });\n}\n"],"mappings":"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"}

package/dist/canvas/deps/lassoSelect.js

@@ -2,13 +2,13 @@ import { hitTestArea as e, hitTestLassoPolygon as t, regionPickOptions as n } fr
 import { useLatest as r } from "@weasel-js/react";
 import { useDepSource as i } from "@weasel-js/routing/react";
 //#region src/canvas/deps/lassoSelect.ts
-function a(a, o, s, c, l) {
-	let u = r(a), d = r(o), f = r(s), p = r(l);
+function a(a, o, s, c) {
+	let l = r(a), u = r(o), d = r(s), f = r(c);
 	i("lassoSelect", () => {
-		let r = u.current, i = d.current, a = f.current, o = p.current;
+		let r = l.current, i = u.current, a = d.current, o = f.current;
 		return {
-			hitTestLasso: (e, i, s) => t(r, e, i, n(s, o, c), a),
-			hitTestArea: (t, i) => e(r, t, n(i, o, c), a),
+			hitTestLasso: (e, i, s) => t(r, e, i, n(s, o), a),
+			hitTestArea: (t, i) => e(r, t, n(i, o), a),
 			getSelection: () => i.current,
 			setSelection: (e) => i.set(e)
 		};

package/dist/canvas/deps/lassoSelect.js.map

@@ -1 +1 @@
-{"version":3,"file":"lassoSelect.js","names":["hitTestAreaShared","useLassoSelectDepSource","sceneRef","useLatest","scene","selectionRef","selection","descriptorRef","descriptor","alphaOfRef","alphaOf","sc","s","d","a","hitTestLassoPolygon","polygon","mode","regionPickOptions","view","poseComposition","hitTestArea","bounds","ids"],"sources":["../../../src/canvas/deps/lassoSelect.ts"],"sourcesContent":["/**\n * `useLassoSelectDepSource` — wires the `lassoSelect` dep consumed by\n * `lassoSelectAction`: `hitTestLasso` tests the lasso polygon itself, and\n * `hitTestArea` is the same silhouette-aware rect test `areaSelect` uses.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { LassoSelectDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { hitTestArea as hitTestAreaShared, hitTestLassoPolygon, regionPickOptions } from './hitTestArea';\nimport type { PoseComposition } from 'features/groups/composePose';\n\nexport function useLassoSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<unknown>,\n  poseComposition?: PoseComposition<unknown>,\n  /** The painted alpha the surface's layers apply, which every view shares. */\n  alphaOf?: (id: string) => number,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const descriptorRef = useLatest(descriptor);\n  const alphaOfRef = useLatest(alphaOf);\n\n  useDepSource('lassoSelect', (): LassoSelectDep => {\n    const sc = sceneRef.current;\n    const s = selectionRef.current;\n    const d = descriptorRef.current;\n    const a = alphaOfRef.current;\n    return {\n      hitTestLasso: (polygon, mode, view) =>\n        hitTestLassoPolygon(sc, polygon, mode, regionPickOptions(view, a, poseComposition), d),\n      hitTestArea: (bounds, view) =>\n        hitTestAreaShared(sc, bounds, regionPickOptions(view, a, poseComposition), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids as NodeId[]),\n    };\n  });\n}\n"],"mappings":";;;;AAcA,SAAgBC,EACd,GACA,GACA,GACA,GAEA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAgBJ,EAAUK,CAAU,GACpCC,IAAaN,EAAUO,CAAO;CAEpC,EAAa,qBAAqC;EAChD,IAAMC,IAAKT,EAAS,SACdU,IAAIP,EAAa,SACjBQ,IAAIN,EAAc,SAClBO,IAAIL,EAAW;EACrB,OAAO;GACL,eAAe,GAAS,GAAM,MAC5BM,EAAoBJ,GAAIK,GAASC,GAAMC,EAAkBC,GAAML,GAAGM,CAAe,GAAGP,CAAC;GACvF,cAAc,GAAQ,MACpBb,EAAkBW,GAAIW,GAAQJ,EAAkBC,GAAML,GAAGM,CAAe,GAAGP,CAAC;GAC9E,oBAAoBD,EAAE;GACtB,eAAe,MAAQA,EAAE,IAAIW,CAAe;EAC9C;CACF,CAAC;AACH"}
+{"version":3,"file":"lassoSelect.js","names":["hitTestAreaShared","useLassoSelectDepSource","sceneRef","useLatest","scene","selectionRef","selection","descriptorRef","descriptor","alphaOfRef","alphaOf","sc","s","d","a","hitTestLassoPolygon","polygon","mode","regionPickOptions","view","hitTestArea","bounds","ids"],"sources":["../../../src/canvas/deps/lassoSelect.ts"],"sourcesContent":["/**\n * `useLassoSelectDepSource` — wires the `lassoSelect` dep consumed by\n * `lassoSelectAction`: `hitTestLasso` tests the lasso polygon itself, and\n * `hitTestArea` is the same silhouette-aware rect test `areaSelect` uses.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { LassoSelectDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { hitTestArea as hitTestAreaShared, hitTestLassoPolygon, regionPickOptions } from './hitTestArea';\n\nexport function useLassoSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<unknown>,\n  /** The painted alpha the surface's layers apply, which every view shares. */\n  alphaOf?: (id: string) => number,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const descriptorRef = useLatest(descriptor);\n  const alphaOfRef = useLatest(alphaOf);\n\n  useDepSource('lassoSelect', (): LassoSelectDep => {\n    const sc = sceneRef.current;\n    const s = selectionRef.current;\n    const d = descriptorRef.current;\n    const a = alphaOfRef.current;\n    return {\n      hitTestLasso: (polygon, mode, view) =>\n        hitTestLassoPolygon(sc, polygon, mode, regionPickOptions(view, a), d),\n      hitTestArea: (bounds, view) =>\n        hitTestAreaShared(sc, bounds, regionPickOptions(view, a), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids as NodeId[]),\n    };\n  });\n}\n"],"mappings":";;;;AAaA,SAAgBC,EACd,GACA,GACA,GAEA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAgBJ,EAAUK,CAAU,GACpCC,IAAaN,EAAUO,CAAO;CAEpC,EAAa,qBAAqC;EAChD,IAAMC,IAAKT,EAAS,SACdU,IAAIP,EAAa,SACjBQ,IAAIN,EAAc,SAClBO,IAAIL,EAAW;EACrB,OAAO;GACL,eAAe,GAAS,GAAM,MAC5BM,EAAoBJ,GAAIK,GAASC,GAAMC,EAAkBC,GAAML,CAAC,GAAGD,CAAC;GACtE,cAAc,GAAQ,MACpBb,EAAkBW,GAAIU,GAAQH,EAAkBC,GAAML,CAAC,GAAGD,CAAC;GAC7D,oBAAoBD,EAAE;GACtB,eAAe,MAAQA,EAAE,IAAIU,CAAe;EAC9C;CACF,CAAC;AACH"}