@weasel-js/core 1.9.4 → 1.10.1

package/dist/affordances/rotationHandle.js.map

@@ -1 +1 @@
-{"version":3,"file":"rotationHandle.js","names":["isAnnulusForm","paint","DEFAULT_PAINT","createRotationAffordance","opts","annulusPaint","target","pickTarget","state","b","halfW","halfH","regionCursor","cursor","angleOf","transformOf","bind","region","bandPx","handle","id","MULTI_RESIZE_TARGET_ID"],"sources":["../../src/affordances/rotationHandle.ts"],"sourcesContent":["import type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport type { CommandFill, CommandStroke } from '@weasel-js/paint';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport { angleOf, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\n\n/** Options for `createRotationAffordance` — how thick the rotate band is\n *  outside the selection, and how (or whether) it is painted. */\nexport interface RotationAffordanceOptions {\n  /** Minimum screen-space thickness of the rotate-zone band outside the\n   *  selection AABB. The outer ellipse semi-axes are clamped to\n   *  `max(w/√2, w/2 + bandPx/scale)` so the zone stays hoverable at any\n   *  zoom and any selection size. Default 24. */\n  bandPx?: number;\n  /** Paint for the ring. `null` / `false` = invisible. Default is a\n   *  semi-transparent fill of the band, contracted by `insetPx` screen\n   *  pixels on the outer edge so the visible band sits inside the\n   *  hoverable zone with a clear margin. Pass a `Stroke` (or\n   *  `{ fill, stroke, insetPx }`) to override. */\n  paint?:\n    | CommandStroke\n    | { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null\n    | false;\n  /** Cursor while hovering the ring. Defaults to the `rotate` glyph turned\n   *  with the target, falling back to `'grab'` if the browser rejects the\n   *  image. */\n  cursor?: CursorSpec;\n  /** A grab region for a rotate badge painted off the top edge — the one\n   *  the selection overlay's `rotationHandle` draws. `distancePx` is how far\n   *  off the edge it sits and `hitRadiusPx` the half-extent of its square,\n   *  both in screen pixels. Placed by the same `standoff` the painted badge\n   *  is, so the two cannot drift apart. Omitted, only the ring rotates. */\n  handle?: { distancePx: number; hitRadiusPx: number };\n}\n\n/** What a rotation-handle hit hands to the rotate action: what is being\n *  rotated, and the world-space pivot it turns around. */\nexport interface RotationScratch extends CommonAffordanceScratch {\n  /** Id of the rotation target — single selection id, or\n   *  `MULTI_RESIZE_TARGET_ID` for multi-selection. */\n  targetId: string;\n  /** Rotation pivot in world coords — the AABB (or union AABB) center. */\n  fixedPoint: { x: number; y: number };\n}\n\ntype AnnulusPaintForm = { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number };\n\nconst isAnnulusForm = (paint: CommandStroke | AnnulusPaintForm): paint is AnnulusPaintForm =>\n  'fill' in paint || 'stroke' in paint || 'insetPx' in paint;\n\nconst DEFAULT_PAINT: AnnulusPaintForm = {\n  fill: { fill: 'solid', color: 'rgba(26, 19, 13, 0.12)' },\n  insetPx: 10,\n};\n\n/**\n * @experimental\n * Rotation affordance for the active selection. Replaces the legacy\n * \"small dot above the AABB\" handle with an elliptical ring that wraps\n * the selection: the smallest ellipse containing the AABB, minus the AABB\n * itself. Hovering the ring sets the cursor (default the `rotate` glyph)\n * and drag-from-ring triggers `rotateAction` via the same\n * binding path the old point-handle used (id stays\n * `'selection.rotation-handle'`).\n *\n * The ring is target-local — under target rotation the ellipse rotates\n * with the AABB so the hoverable band always wraps the rendered shape.\n *\n * Visibility: gated by chrome-caps' `'selection.rotation-handle'` rule.\n * The ring paints as a faint band by default; `paint: null` leaves the\n * cursor change as the only cue.\n */\nexport function createRotationAffordance(\n  opts: RotationAffordanceOptions = {},\n): Affordance {\n  const { bandPx = 24, paint = DEFAULT_PAINT, cursor, handle } = opts;\n\n  // Normalize `paint` into the AnnulusPaint shape understood by\n  // `composeAffordanceLayer`. Three input forms are accepted: a bare\n  // `Stroke` (legacy outline form), the `{ fill, stroke, insetPx }`\n  // object form, or `null`/`false` for invisible. The object form is what\n  // carries these three keys; `Stroke` carries none of them, and cannot be\n  // told apart by its own `paint` since that is optional.\n  const annulusPaint:\n    | { kind: 'annulus'; fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null = (() => {\n      if (!paint) return null;\n      if (!isAnnulusForm(paint)) {\n        return { kind: 'annulus' as const, stroke: paint };\n      }\n      return {\n        kind: 'annulus' as const,\n        ...(paint.fill ? { fill: paint.fill } : {}),\n        ...(paint.stroke ? { stroke: paint.stroke } : {}),\n        ...(paint.insetPx !== undefined ? { insetPx: paint.insetPx } : {}),\n      };\n    })();\n\n  return {\n    id: 'selection.rotation-handle',\n    regions(state: ChromeState): readonly AffordanceRegion[] {\n      const target = pickTarget(state);\n      if (!target) return [];\n      const b = target.bounds;\n\n      // The natural ring: the smallest ellipse containing the AABB. For a\n      // small or thin selection that band is too tight to hover, so\n      // `minBandPx` asks the framework to widen it to at least `bandPx`\n      // screen pixels outside the rect. The floor is declared in screen units\n      // rather than applied here because `ChromeState` carries no view scale\n      // — the framework applies it at paint and hit time, where the view is\n      // known, so the ring holds its apparent thickness at any zoom.\n      const halfW = b.width / 2;\n      const halfH = b.height / 2;\n\n      // Turned with the target, so the arc follows the selection it rotates.\n      // Resolved per region rather than defaulted in the option list because\n      // the angle is only known once a target is picked.\n      const regionCursor: CursorSpec = cursor ?? {\n        glyph: 'rotate',\n        angle: angleOf(transformOf(state, target.id)),\n        fallback: 'grab',\n      };\n      const bind = (): AffordanceBinding => ({\n        initialScratch: {\n          targetId: target.id,\n          // Pivot. `rotateAction` recomputes its own union pivot for\n          // multi-selection, but the single-target case reads this.\n          fixedPoint: { x: b.x + halfW, y: b.y + halfH },\n        } satisfies RotationScratch,\n      });\n\n      const region: AffordanceRegion = {\n        id: 'selection.rotation-handle',\n        targetId: target.id,\n        shape: {\n          kind: 'annulus',\n          cx: b.x + halfW,\n          cy: b.y + halfH,\n          rx: halfW * Math.SQRT2,\n          ry: halfH * Math.SQRT2,\n          innerX: b.x,\n          innerY: b.y,\n          innerWidth: b.width,\n          innerHeight: b.height,\n          minBandPx: bandPx,\n        },\n        ...(annulusPaint ? { paint: annulusPaint } : {}),\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      if (!handle) return [region];\n      const badge: AffordanceRegion = {\n        id: 'rotation-badge',\n        targetId: target.id,\n        shape: {\n          kind: 'point',\n          x: b.x + halfW,\n          y: b.y,\n          hitRadiusPx: handle.hitRadiusPx,\n          standoff: { px: handle.distancePx, normal: { x: 0, y: -1 } },\n        },\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      return [region, badge];\n    },\n  };\n}\n\nfunction pickTarget(state: ChromeState): { id: string; bounds: Bounds } | null {\n  if (state.selection.length === 1) {\n    const id = state.selection[0];\n    // Skip when the selected node's pose-descriptor declares it can't\n    // carry a rotation. Without this the rotation affordance would expose\n    // a rotate cursor over (e.g.) polygon-Path selections whose\n    // `rotateAction` write is silently dropped at paint time.\n    if (state.canRotate && !state.canRotate(id)) return null;\n    const b = state.boundsOf(id);\n    return b ? { id, bounds: b } : null;\n  }\n  // Multi-selection: anchor the ring to the union AABB. `rotateAction`\n  // ignores the synthetic id and pivots at its own union center\n  // (`useUnionPivot: ids.length > 1` branch in `defaults/rotate.ts`).\n  // Require every selected id to support rotation — a partial multi-rotate\n  // (some ids rotate, others silently no-op) would feel broken.\n  if (state.multiActive && state.unionBounds) {\n    if (state.canRotate) {\n      for (const id of state.selection) {\n        if (!state.canRotate(id)) return null;\n      }\n    }\n    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };\n  }\n  return null;\n}\n"],"mappings":";;;AAiDA,IAAMA,KAAiB,MACrB,UAAUC,KAAS,YAAYA,KAAS,aAAaA,GAEjDC,IAAkC;CACtC,MAAM;EAAE,MAAM;EAAS,OAAO;CAAyB;CACvD,SAAS;AACX;AAmBA,SAAgBC,EACd,IAAkC,CAAC,GACvB;CACZ,IAAM,EAAE,YAAS,IAAI,WAAQD,GAAe,WAAQ,cAAWE,GAQzDC,IAGGJ,IACAD,EAAcC,CAAK,IAGjB;EACL,MAAM;EACN,GAAIA,EAAM,OAAO,EAAE,MAAMA,EAAM,KAAK,IAAI,CAAC;EACzC,GAAIA,EAAM,SAAS,EAAE,QAAQA,EAAM,OAAO,IAAI,CAAC;EAC/C,GAAIA,EAAM,YAAY,KAAA,IAAyC,CAAC,IAA9B,EAAE,SAASA,EAAM,QAAQ;CAC7D,IAPS;EAAE,MAAM;EAAoB,QAAQA;CAAM,IAFhC;CAYvB,OAAO;EACL,IAAI;EACJ,QAAQ,GAAiD;GACvD,IAAMK,IAASC,EAAWC,CAAK;GAC/B,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAIH,EAAO,QASXI,IAAQD,EAAE,QAAQ,GAClBE,IAAQF,EAAE,SAAS,GAKnBG,IAA2BC,KAAU;IACzC,OAAO;IACP,OAAOC,EAAQC,EAAYP,GAAOF,EAAO,EAAE,CAAC;IAC5C,UAAU;GACZ,GACMU,WAAiC,EACrC,gBAAgB;IACd,UAAUV,EAAO;IAGjB,YAAY;KAAE,GAAGG,EAAE,IAAIC;KAAO,GAAGD,EAAE,IAAIE;IAAM;GAC/C,EACF,IAEMM,IAA2B;IAC/B,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,IAAIG,EAAE,IAAIC;KACV,IAAID,EAAE,IAAIE;KACV,IAAID,IAAQ,KAAK;KACjB,IAAIC,IAAQ,KAAK;KACjB,QAAQF,EAAE;KACV,QAAQA,EAAE;KACV,YAAYA,EAAE;KACd,aAAaA,EAAE;KACf,WAAWS;IACb;IACA,GAAIb,IAAe,EAAE,OAAOA,EAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQO;IACR;GACF;GAgBA,OAfKO,IAeE,CAACF,GAAQ;IAbd,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAGG,EAAE,IAAIC;KACT,GAAGD,EAAE;KACL,aAAaU,EAAO;KACpB,UAAU;MAAE,IAAIA,EAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQP;IACR;GAEc,CAAK,IAfD,CAACK,CAAM;EAgB7B;CACF;AACF;AAEA,SAASV,EAAW,GAA2D;CAC7E,IAAIC,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMY,IAAKZ,EAAM,UAAU;EAK3B,IAAIA,EAAM,aAAa,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EACpD,IAAMX,IAAID,EAAM,SAASY,CAAE;EAC3B,OAAOX,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CAMA,IAAID,EAAM,eAAeA,EAAM,aAAa;EAC1C,IAAIA,EAAM,WACH;QAAA,IAAMY,KAAMZ,EAAM,WACrB,IAAI,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EAAA;EAGrC,OAAO;GAAE,IAAIC;GAAwB,QAAQb,EAAM;EAAY;CACjE;CACA,OAAO;AACT"}
+{"version":3,"file":"rotationHandle.js","names":["isAnnulusForm","paint","DEFAULT_PAINT","createRotationAffordance","opts","annulusPaint","target","pickTarget","state","b","halfW","halfH","pivot","localToWorld","transformOf","regionCursor","cursor","rotateCursorAt","at","view","bind","region","bandPx","handle","id","MULTI_RESIZE_TARGET_ID"],"sources":["../../src/affordances/rotationHandle.ts"],"sourcesContent":["import type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport type { CommandStroke, CommandFill } from '@weasel-js/paint';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport { localToWorld, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport { rotateCursorAt } from './rotateCursor';\n\n/** Options for `createRotationAffordance` — how thick the rotate band is\n *  outside the selection, and how (or whether) it is painted. */\nexport interface RotationAffordanceOptions {\n  /** Minimum screen-space thickness of the rotate-zone band outside the selection AABB, so\n   *  the zone stays hoverable at any zoom and any selection size. Default 24. */\n  bandPx?: number;\n  /** Paint for the ring. `null` / `false` = invisible. Default is a semi-transparent fill of\n   *  the band, contracted by `insetPx` screen pixels on the outer edge. Pass a `Stroke` (or\n   *  `{ fill, stroke, insetPx }`) to override. */\n  paint?:\n    | CommandStroke\n    | { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null\n    | false;\n  /** Cursor while hovering the ring. Defaults to the `rotate` glyph turned\n   *  square to the line from the pivot to the pointer, falling back to\n   *  `'grab'` if the browser rejects the image. */\n  cursor?: CursorSpec;\n  /** A grab region for a rotate badge painted off the top edge — the one\n   *  the selection overlay's `rotationHandle` draws. `distancePx` is how far\n   *  off the edge it sits and `hitRadiusPx` the half-extent of its square,\n   *  both in screen pixels. Placed by the same `standoff` the painted badge\n   *  is, so the two cannot drift apart. Omitted, only the ring rotates. */\n  handle?: { distancePx: number; hitRadiusPx: number };\n}\n\n/** What a rotation-handle hit hands to the rotate action: what is being\n *  rotated, and the world-space pivot it turns around. */\nexport interface RotationScratch extends CommonAffordanceScratch {\n  /** Id of the rotation target — single selection id, or\n   *  `MULTI_RESIZE_TARGET_ID` for multi-selection. */\n  targetId: string;\n  /** Rotation pivot in world coords — the AABB (or union AABB) center. */\n  fixedPoint: { x: number; y: number };\n}\n\ntype AnnulusPaintForm = { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number };\n\nconst isAnnulusForm = (paint: CommandStroke | AnnulusPaintForm): paint is AnnulusPaintForm =>\n  'fill' in paint || 'stroke' in paint || 'insetPx' in paint;\n\nconst DEFAULT_PAINT: AnnulusPaintForm = {\n  fill: { paint: { kind: 'solid', color: 'rgba(26, 19, 13, 0.12)' } },\n  insetPx: 10,\n};\n\n/**\n * @experimental\n * Rotation affordance for the active selection: an elliptical ring that wraps the selection —\n * the smallest ellipse containing the AABB, minus the AABB itself. Hovering the ring sets the\n * cursor (default the `rotate` glyph) and a drag from it triggers `rotateAction`.\n *\n * The ring is target-local — under target rotation the ellipse rotates with the AABB.\n * Visibility is gated by chrome-caps' `'selection.rotation-handle'` rule. `paint: null` leaves\n * the cursor change as the only cue.\n */\nexport function createRotationAffordance(\n  opts: RotationAffordanceOptions = {},\n): Affordance {\n  const { bandPx = 24, paint = DEFAULT_PAINT, cursor, handle } = opts;\n\n  // A bare `Stroke` carries none of the object form's three keys, and cannot be told apart\n  // by its own `paint` since that is optional.\n  const annulusPaint:\n    | { kind: 'annulus'; fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null = (() => {\n      if (!paint) return null;\n      if (!isAnnulusForm(paint)) {\n        return { kind: 'annulus' as const, stroke: paint };\n      }\n      return {\n        kind: 'annulus' as const,\n        ...(paint.fill ? { fill: paint.fill } : {}),\n        ...(paint.stroke ? { stroke: paint.stroke } : {}),\n        ...(paint.insetPx !== undefined ? { insetPx: paint.insetPx } : {}),\n      };\n    })();\n\n  return {\n    id: 'selection.rotation-handle',\n    regions(state: ChromeState): readonly AffordanceRegion[] {\n      const target = pickTarget(state);\n      if (!target) return [];\n      const b = target.bounds;\n\n      // The natural ring is the smallest ellipse containing the AABB. `minBandPx` asks the\n      // framework to widen it to at least `bandPx` screen pixels outside the rect; the floor is\n      // declared in screen units because `ChromeState` carries no view scale.\n      const halfW = b.width / 2;\n      const halfH = b.height / 2;\n\n      const pivot = localToWorld(transformOf(state, target.id), b.x + halfW, b.y + halfH);\n      const regionCursor: AffordanceRegion['cursor'] = cursor\n        ?? ((at, view) => rotateCursorAt(pivot, at, view.scale));\n      const bind = (): AffordanceBinding => ({\n        initialScratch: {\n          targetId: target.id,\n          // Pivot. `rotateAction` recomputes its own union pivot for\n          // multi-selection, but the single-target case reads this.\n          fixedPoint: { x: b.x + halfW, y: b.y + halfH },\n        } satisfies RotationScratch,\n      });\n\n      const region: AffordanceRegion = {\n        id: 'selection.rotation-handle',\n        targetId: target.id,\n        shape: {\n          kind: 'annulus',\n          cx: b.x + halfW,\n          cy: b.y + halfH,\n          rx: halfW * Math.SQRT2,\n          ry: halfH * Math.SQRT2,\n          innerX: b.x,\n          innerY: b.y,\n          innerWidth: b.width,\n          innerHeight: b.height,\n          minBandPx: bandPx,\n        },\n        ...(annulusPaint ? { paint: annulusPaint } : {}),\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      if (!handle) return [region];\n      const badge: AffordanceRegion = {\n        id: 'rotation-badge',\n        targetId: target.id,\n        shape: {\n          kind: 'point',\n          x: b.x + halfW,\n          y: b.y,\n          hitRadiusPx: handle.hitRadiusPx,\n          standoff: { px: handle.distancePx, normal: { x: 0, y: -1 } },\n        },\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      return [region, badge];\n    },\n  };\n}\n\nfunction pickTarget(state: ChromeState): { id: string; bounds: Bounds } | null {\n  if (state.selection.length === 1) {\n    const id = state.selection[0];\n    // Skip when the selected node's pose-descriptor declares it can't carry a rotation;\n    // otherwise the ring would offer a rotate cursor over a node whose write is dropped.\n    if (state.canRotate && !state.canRotate(id)) return null;\n    const b = state.boundsOf(id);\n    return b ? { id, bounds: b } : null;\n  }\n  // Multi-selection: anchor the ring to the union AABB; `rotateAction` ignores the synthetic\n  // id and pivots at its own union center. Every selected id must support rotation — a\n  // partial multi-rotate would feel broken.\n  if (state.multiActive && state.unionBounds) {\n    if (state.canRotate) {\n      for (const id of state.selection) {\n        if (!state.canRotate(id)) return null;\n      }\n    }\n    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };\n  }\n  return null;\n}\n"],"mappings":";;;;;AA8CA,IAAMA,KAAiB,MACrB,UAAUC,KAAS,YAAYA,KAAS,aAAaA,GAEjDC,IAAkC;CACtC,MAAM,EAAE,OAAO;EAAE,MAAM;EAAS,OAAO;CAAyB,EAAE;CAClE,SAAS;AACX;AAYA,SAAgBC,EACd,IAAkC,CAAC,GACvB;CACZ,IAAM,EAAE,YAAS,IAAI,WAAQD,GAAe,WAAQ,cAAWE,GAIzDC,IAGGJ,IACAD,EAAcC,CAAK,IAGjB;EACL,MAAM;EACN,GAAIA,EAAM,OAAO,EAAE,MAAMA,EAAM,KAAK,IAAI,CAAC;EACzC,GAAIA,EAAM,SAAS,EAAE,QAAQA,EAAM,OAAO,IAAI,CAAC;EAC/C,GAAIA,EAAM,YAAY,KAAA,IAAyC,CAAC,IAA9B,EAAE,SAASA,EAAM,QAAQ;CAC7D,IAPS;EAAE,MAAM;EAAoB,QAAQA;CAAM,IAFhC;CAYvB,OAAO;EACL,IAAI;EACJ,QAAQ,GAAiD;GACvD,IAAMK,IAASC,EAAWC,CAAK;GAC/B,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAIH,EAAO,QAKXI,IAAQD,EAAE,QAAQ,GAClBE,IAAQF,EAAE,SAAS,GAEnBG,IAAQC,EAAaC,EAAYN,GAAOF,EAAO,EAAE,GAAGG,EAAE,IAAIC,GAAOD,EAAE,IAAIE,CAAK,GAC5EI,IAA2CC,OAC1C,GAAI,MAASC,EAAeL,GAAOM,GAAIC,EAAK,KAAK,IAClDC,WAAiC,EACrC,gBAAgB;IACd,UAAUd,EAAO;IAGjB,YAAY;KAAE,GAAGG,EAAE,IAAIC;KAAO,GAAGD,EAAE,IAAIE;IAAM;GAC/C,EACF,IAEMU,IAA2B;IAC/B,IAAI;IACJ,UAAUf,EAAO;IACjB,OAAO;KACL,MAAM;KACN,IAAIG,EAAE,IAAIC;KACV,IAAID,EAAE,IAAIE;KACV,IAAID,IAAQ,KAAK;KACjB,IAAIC,IAAQ,KAAK;KACjB,QAAQF,EAAE;KACV,QAAQA,EAAE;KACV,YAAYA,EAAE;KACd,aAAaA,EAAE;KACf,WAAWa;IACb;IACA,GAAIjB,IAAe,EAAE,OAAOA,EAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQU;IACR;GACF;GAgBA,OAfKQ,IAeE,CAACF,GAAQ;IAbd,IAAI;IACJ,UAAUf,EAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAGG,EAAE,IAAIC;KACT,GAAGD,EAAE;KACL,aAAac,EAAO;KACpB,UAAU;MAAE,IAAIA,EAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQR;IACR;GAEc,CAAK,IAfD,CAACM,CAAM;EAgB7B;CACF;AACF;AAEA,SAASd,EAAW,GAA2D;CAC7E,IAAIC,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMgB,IAAKhB,EAAM,UAAU;EAG3B,IAAIA,EAAM,aAAa,CAACA,EAAM,UAAUgB,CAAE,GAAG,OAAO;EACpD,IAAMf,IAAID,EAAM,SAASgB,CAAE;EAC3B,OAAOf,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CAIA,IAAID,EAAM,eAAeA,EAAM,aAAa;EAC1C,IAAIA,EAAM,WACH;QAAA,IAAMgB,KAAMhB,EAAM,WACrB,IAAI,CAACA,EAAM,UAAUgB,CAAE,GAAG,OAAO;EAAA;EAGrC,OAAO;GAAE,IAAIC;GAAwB,QAAQjB,EAAM;EAAY;CACjE;CACA,OAAO;AACT"}

package/dist/animation/behaviors/coast.js

@@ -0,0 +1,21 @@
+//#region src/animation/behaviors/coast.ts
+var e = 0, t = () => `momentum:${e++}`, n = (e, t) => e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+function r(e, t, n) {
+	if (!e) return {
+		nx: t,
+		ny: n,
+		hitX: !1,
+		hitY: !1
+	};
+	let r = Math.min(Math.max(t, e.x), e.x + e.width), i = Math.min(Math.max(n, e.y), e.y + e.height);
+	return {
+		nx: r,
+		ny: i,
+		hitX: r !== t,
+		hitY: i !== n
+	};
+}
+//#endregion
+export { r as clampCorner, t as coastKey, n as sameBounds };
+
+//# sourceMappingURL=coast.js.map

package/dist/animation/behaviors/coast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coast.js","names":["nextCoast","coastKey","sameBounds","a","b","clampCorner","bounds","x","y","nx","ny"],"sources":["../../../src/animation/behaviors/coast.ts"],"sourcesContent":["import type { GestureContext } from 'interactions/gestures/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { Animator } from '@weasel-js/animator';\n\n/** One flick still traveling: the nodes it carries, and how a new drag of one stops it. */\nexport interface Coast {\n  ids: readonly string[];\n  stop(): void;\n}\n\n/** What a coast is started with. */\nexport interface CoastArgs<TPose> {\n  animator: Animator;\n  ctx: GestureContext<TPose>;\n  /** Release velocity in world units a second. */\n  vx: number;\n  vy: number;\n  friction: number;\n  bounds: { x: number; y: number; width: number; height: number } | undefined;\n  boundary: 'stop' | 'continue';\n  d: PoseDescriptor<TPose>;\n  /** The behavior's running coasts. A coast adds itself and takes itself out as it ends. */\n  coasts: Set<Coast>;\n}\n\nlet nextCoast = 0;\n\n/** A cancel key no other coast holds. */\nexport const coastKey = (): string => `momentum:${nextCoast++}`;\n\n/** Whether two bounds are the same box. */\nexport const sameBounds = (a: Bounds, b: Bounds): boolean =>\n  a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n\n/** A top-left corner held inside `bounds`, and which axes that moved. */\nexport function clampCorner(\n  bounds: CoastArgs<unknown>['bounds'],\n  x: number,\n  y: number,\n): { nx: number; ny: number; hitX: boolean; hitY: boolean } {\n  if (!bounds) return { nx: x, ny: y, hitX: false, hitY: false };\n  const nx = Math.min(Math.max(x, bounds.x), bounds.x + bounds.width);\n  const ny = Math.min(Math.max(y, bounds.y), bounds.y + bounds.height);\n  return { nx, ny, hitX: nx !== x, hitY: ny !== y };\n}\n"],"mappings":";AA0BA,IAAIA,IAAY,GAGHC,UAAyB,YAAY,OAGrCC,KAAc,GAAW,MACpCC,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAMC,EAAE,KAAKD,EAAE,UAAUC,EAAE,SAASD,EAAE,WAAWC,EAAE;AAGtE,SAAgBC,EACd,GACA,GACA,GAC0D;CAC1D,IAAI,CAACC,GAAQ,OAAO;EAAE,IAAIC;EAAG,IAAIC;EAAG,MAAM;EAAO,MAAM;CAAM;CAC7D,IAAMC,IAAK,KAAK,IAAI,KAAK,IAAIF,GAAGD,EAAO,CAAC,GAAGA,EAAO,IAAIA,EAAO,KAAK,GAC5DI,IAAK,KAAK,IAAI,KAAK,IAAIF,GAAGF,EAAO,CAAC,GAAGA,EAAO,IAAIA,EAAO,MAAM;CACnE,OAAO;EAAE;EAAI;EAAI,MAAMG,MAAOF;EAAG,MAAMG,MAAOF;CAAE;AAClD"}

package/dist/animation/behaviors/coastByWrite.js

@@ -0,0 +1,107 @@
+import { translatePoseViaDescriptor as e } from "../../core/geometry/poseDescriptor.js";
+import { createTransformOp as t } from "../../core/ops/transform.js";
+import { clampCorner as n, coastKey as r, sameBounds as i } from "./coast.js";
+//#region src/animation/behaviors/coastByWrite.ts
+function a(a) {
+	let { animator: o, ctx: s, d: c, bounds: l, coasts: u } = a, d = s.adapter, f = new Map(s.current), p = {
+		x: 0,
+		y: 0
+	}, m = (e) => {
+		if (d.previewPoses) d.previewPoses(e);
+		else for (let [t, n] of e) n !== null && d.setPose(t, n);
+	}, h = new Set(s.draggedIds), g = /* @__PURE__ */ new Map();
+	for (let e of h) d.getNode(e) && g.set(e, c.getBounds(d.getPose(e)));
+	let _ = (e) => {
+		let t = g.get(e);
+		return t !== void 0 && d.getNode(e) !== void 0 && i(c.getBounds(d.getPose(e)), t);
+	}, v = /* @__PURE__ */ new Map(), y = r(), b = {
+		ids: s.draggedIds.slice(),
+		stop: () => {
+			if (!o.isActive(y)) {
+				u.delete(b);
+				return;
+			}
+			x.cancel(), S();
+		}
+	};
+	u.add(b), m(new Map([...h].flatMap((e) => {
+		let t = f.get(e);
+		return t === void 0 ? [] : [[e, t]];
+	})));
+	let x = o.decay({
+		from: {
+			x: 0,
+			y: 0
+		},
+		velocity: {
+			x: a.vx,
+			y: a.vy
+		},
+		friction: a.friction,
+		cancelKey: y,
+		add: (e, t) => ({
+			x: e.x + t.x,
+			y: e.y + t.y
+		}),
+		scale: (e, t) => ({
+			x: e.x * t,
+			y: e.y * t
+		}),
+		magnitude: (e) => Math.hypot(e.x, e.y),
+		onTick: (t) => {
+			p = t;
+			let r = l !== void 0, i = /* @__PURE__ */ new Map();
+			for (let a of [...h]) {
+				if (!_(a)) {
+					h.delete(a), i.set(a, null);
+					continue;
+				}
+				let o = f.get(a);
+				if (!o) continue;
+				let s = c.getBounds(o), { nx: u, ny: d, hitX: p, hitY: m } = n(l, s.x + t.x, s.y + t.y);
+				!p && !m && (r = !1), v.set(a, {
+					x: u,
+					y: d
+				}), i.set(a, e(o, u - s.x, d - s.y, c));
+			}
+			m(i);
+			for (let e of h) g.set(e, c.getBounds(d.getPose(e)));
+			if (h.size === 0) {
+				u.delete(b), x.cancel();
+				return;
+			}
+			a.boundary === "stop" && r && b.stop();
+		},
+		onDone: () => {
+			S();
+		}
+	});
+	function S() {
+		if (!u.delete(b)) return;
+		let n = [], r = /* @__PURE__ */ new Map();
+		for (let i of h) {
+			if (r.set(i, null), !_(i)) continue;
+			let a = f.get(i);
+			if (!a) continue;
+			let o = c.getBounds(a), l = v.get(i) ?? {
+				x: o.x + p.x,
+				y: o.y + p.y
+			}, u = e(a, l.x - o.x, l.y - o.y, c), d = s.origin.get(i) ?? a;
+			n.push(t({
+				id: i,
+				from: d,
+				to: u,
+				label: "flick"
+			}));
+		}
+		if (n.length > 0) {
+			if (d.applyOps) d.applyOps(n, "flick");
+			else if (d.previewPoses) for (let e of n) e.apply(d);
+		}
+		d.previewPoses?.(r);
+	}
+}
+//#endregion
+export { a as coastByWrite };
+
+//# sourceMappingURL=coastByWrite.js.map

package/dist/animation/behaviors/coastByWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coastByWrite.js","names":["coastByWrite","adapter","ctx","startPoses","lastValue","show","poses","id","pose","riding","lastSeen","d","stillOurs","seen","sameBounds","finalPositions","cancelKey","coastKey","coast","animator","decayHandle","commitFlick","coasts","start","p","q","v","k","delta","allHit","bounds","frame","o","clampCorner","hitX","hitY","nx","ny","translatePoseViaDescriptor","ops","shown","fp","finalPose","from","createTransformOp","op"],"sources":["../../../src/animation/behaviors/coastByWrite.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { clampCorner, coastKey, sameBounds, type Coast, type CoastArgs } from './coast';\n\ninterface Delta { x: number; y: number }\n\n/**\n * A coast over an adapter with no pose targets: one decay of the flick's travel, written to\n * every node it carries each frame, through `previewPoses` where the adapter has it and\n * `setPose` where it does not. Nothing else animating a node adds to it.\n */\nexport function coastByWrite<TPose>(a: CoastArgs<TPose>): void {\n  const { animator, ctx, d, bounds, coasts } = a;\n  const adapter = ctx.adapter;\n  const startPoses = new Map<string, TPose>(ctx.current);\n  let lastValue: Delta = { x: 0, y: 0 };\n  const show = (poses: Map<string, TPose | null>): void => {\n    if (adapter.previewPoses) adapter.previewPoses(poses);\n    else for (const [id, pose] of poses) if (pose !== null) adapter.setPose(id, pose);\n  };\n  // What the scene held for each node right after the coast last wrote it.\n  // A node that is gone, or reads back as anything else, has another\n  // writer now, an undo or a delete, and leaves the coast unrecorded.\n  const riding = new Set(ctx.draggedIds);\n  const lastSeen = new Map<string, Bounds>();\n  for (const id of riding) {\n    if (adapter.getNode(id)) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n  }\n  const stillOurs = (id: string): boolean => {\n    const seen = lastSeen.get(id);\n    return seen !== undefined && adapter.getNode(id) !== undefined\n      && sameBounds(d.getBounds(adapter.getPose(id)), seen);\n  };\n  // Where each node was last put, which under bounds is not its start plus the decay's travel.\n  const finalPositions = new Map<string, Delta>();\n  const cancelKey = coastKey();\n  const coast: Coast = {\n    ids: ctx.draggedIds.slice(),\n    stop: (): void => {\n      // Canceled from outside (cancelAll, unmount), it stopped long ago and somewhere else.\n      if (!animator.isActive(cancelKey)) {\n        coasts.delete(coast);\n        return;\n      }\n      decayHandle.cancel();\n      commitFlick();\n    },\n  };\n  coasts.add(coast);\n  // Held from the release itself, so no frame paints the pre-drag pose\n  // between the drag's preview going away and the first coast frame.\n  show(new Map([...riding].flatMap((id) => {\n    const start = startPoses.get(id);\n    return start === undefined ? [] : [[id, start] as const];\n  })));\n  const decayHandle = animator.decay<Delta>({\n    from: { x: 0, y: 0 },\n    velocity: { x: a.vx, y: a.vy },\n    friction: a.friction,\n    cancelKey,\n    add: (p, q) => ({ x: p.x + q.x, y: p.y + q.y }),\n    scale: (v, k) => ({ x: v.x * k, y: v.y * k }),\n    magnitude: (v) => Math.hypot(v.x, v.y),\n    onTick: (delta) => {\n      lastValue = delta;\n      let allHit = bounds !== undefined;\n      const frame = new Map<string, TPose | null>();\n      for (const id of [...riding]) {\n        if (!stillOurs(id)) {\n          riding.delete(id);\n          frame.set(id, null);\n          continue;\n        }\n        const start = startPoses.get(id);\n        if (!start) continue;\n        const o = d.getBounds(start);\n        const { nx, ny, hitX, hitY } = clampCorner(bounds, o.x + delta.x, o.y + delta.y);\n        if (!hitX && !hitY) allHit = false;\n        finalPositions.set(id, { x: nx, y: ny });\n        frame.set(id, translatePoseViaDescriptor(start, nx - o.x, ny - o.y, d));\n      }\n      show(frame);\n      for (const id of riding) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n      if (riding.size === 0) {\n        coasts.delete(coast);\n        decayHandle.cancel();\n        return;\n      }\n      // Under 'stop', once every node is at the boundary the coast ends\n      // there instead of drifting along the edge as friction wears off.\n      if (a.boundary === 'stop' && allHit) coast.stop();\n    },\n    onDone: () => {\n      commitFlick();\n    },\n  });\n\n  function commitFlick(): void {\n    if (!coasts.delete(coast)) return;\n    const ops: Op[] = [];\n    const shown = new Map<string, TPose | null>();\n    for (const id of riding) {\n      shown.set(id, null);\n      if (!stillOurs(id)) continue;\n      const start = startPoses.get(id);\n      if (!start) continue;\n      const o = d.getBounds(start);\n      const fp = finalPositions.get(id) ?? { x: o.x + lastValue.x, y: o.y + lastValue.y };\n      const finalPose = translatePoseViaDescriptor(start, fp.x - o.x, fp.y - o.y, d);\n      const from = ctx.origin.get(id) ?? start;\n      ops.push(createTransformOp<TPose>({ id, from, to: finalPose, label: 'flick' }));\n    }\n    // The document first, so the preview never gives way to the pre-drag pose.\n    if (ops.length > 0) {\n      if (adapter.applyOps) adapter.applyOps(ops, 'flick');\n      else if (adapter.previewPoses) for (const op of ops) op.apply(adapter);\n    }\n    adapter.previewPoses?.(shown);\n  }\n}\n"],"mappings":"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"}

package/dist/animation/behaviors/coastOnTargets.js

@@ -0,0 +1,94 @@
+import { translatePoseViaDescriptor as e } from "../../core/geometry/poseDescriptor.js";
+import { createTransformOp as t } from "../../core/ops/transform.js";
+import { poseKey as n } from "../poseHelpers.js";
+import { clampCorner as r, coastKey as i, sameBounds as a } from "./coast.js";
+//#region src/animation/behaviors/coastOnTargets.ts
+function o(t, n, r, i, a) {
+	let o = t.to(r), s = t.to(e(r, 1, 0, n)), c = t.to(e(r, 0, 1, n));
+	return t.from(o.map((e, t) => i * (s[t] - e) + a * (c[t] - e)));
+}
+function s(s, c) {
+	let { animator: l, ctx: u, d, bounds: f, coasts: p } = s, m = u.adapter, h = -Math.log(s.friction), g = i(), _ = /* @__PURE__ */ new Map(), v = (e) => m.getNode(e.id) !== void 0 && a(d.getBounds(e.target.committed()), d.getBounds(e.seen)), y = (e, t, n, r) => {
+		let i = t ?? e.target.committed(), a = o(e.target.axes, d, i, n, r), c = d.getBounds(i);
+		e.startX = c.x, e.startY = c.y, e.vx = n, e.vy = r, e.handle = l.decay({
+			target: e.target,
+			from: t,
+			velocity: a,
+			friction: s.friction,
+			cancelKey: g,
+			interrupt: !1,
+			onTick: (t) => S(e, t),
+			onDone: () => b(e)
+		});
+	}, b = (e) => {
+		e.handle = null, e.seen = e.target.committed();
+		for (let e of _.values()) if (e.handle) return;
+		w();
+	}, x = (e, t) => {
+		let r = e.target.committed();
+		if (_.delete(e.id), e.handle?.cancel(), e.target.commit(r), e.target.active && m.getNode(e.id) !== void 0) {
+			let i = d.getBounds(r), a = d.getBounds(e.seen), s = d.getBounds(t), c = e.vx - h * (s.x - (i.x - a.x) - e.startX), u = e.vy - h * (s.y - (i.y - a.y) - e.startY);
+			l.spring({
+				target: e.target,
+				from: t,
+				to: r,
+				velocity: o(e.target.axes, d, t, c, u),
+				cancelKey: n(e.id),
+				interrupt: !1
+			});
+		}
+		b(e);
+	};
+	function S(t, n) {
+		if (!v(t)) {
+			x(t, n);
+			return;
+		}
+		let i = d.getBounds(n), { nx: a, ny: o, hitX: c, hitY: l } = r(f, i.x, i.y);
+		if (!c && !l) return;
+		let u = c ? 0 : t.vx - h * (i.x - t.startX), p = l ? 0 : t.vy - h * (i.y - t.startY);
+		t.handle?.cancel(), t.target.commit(e(t.target.committed(), a - i.x, o - i.y, d)), t.seen = t.target.committed(), s.boundary === "continue" && Math.hypot(u, p) > 0 ? y(t, void 0, u, p) : b(t);
+	}
+	let C = {
+		ids: u.draggedIds.slice(),
+		stop: () => {
+			if (!l.isActive(g)) {
+				p.delete(C);
+				return;
+			}
+			for (let e of _.values()) e.handle?.cancel(), e.handle = null, e.seen = e.target.committed();
+			w();
+		}
+	};
+	p.add(C);
+	function w() {
+		if (!p.delete(C) || !m.applyOps) return;
+		let e = [];
+		for (let n of _.values()) {
+			if (!v(n)) continue;
+			let r = u.origin.get(n.id) ?? n.seen, i = n.target.committed();
+			n.target.commit(r), e.push(t({
+				id: n.id,
+				from: r,
+				to: i,
+				label: "flick"
+			}));
+		}
+		e.length > 0 && m.applyOps(e, "flick");
+	}
+	for (let [e, t] of c) _.set(e, {
+		id: e,
+		target: t,
+		seen: t.committed(),
+		handle: null,
+		startX: 0,
+		startY: 0,
+		vx: 0,
+		vy: 0
+	});
+	for (let e of [..._.values()]) y(e, u.current.get(e.id), s.vx, s.vy);
+}
+//#endregion
+export { s as coastOnTargets };
+
+//# sourceMappingURL=coastOnTargets.js.map

package/dist/animation/behaviors/coastOnTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coastOnTargets.js","names":["poseVelocity","base","ax","at","alongX","translatePoseViaDescriptor","d","alongY","vx","i","b","vy","coastOnTargets","a","adapter","ctx","drag","cancelKey","coastKey","riders","ours","r","sameBounds","launch","from","velocity","corner","animator","tick","own","halted","other","drop","left","moved","was","poseKey","clampCorner","bounds","hitX","hitY","nx","ny","coast","commitFlick","coasts","ops","to","createTransformOp","id","target","targets"],"sources":["../../../src/animation/behaviors/coastOnTargets.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Target, TargetAxes } from '@weasel-js/animator';\nimport type { AnimationHandle } from '@weasel-js/animator';\nimport { poseKey } from '../poseHelpers';\nimport { clampCorner, coastKey, sameBounds, type Coast, type CoastArgs } from './coast';\n\ninterface Rider<TPose> {\n  id: string;\n  target: Target<TPose>;\n  /** The committed pose as the coast last left it. Anything else there is another writer's. */\n  seen: TPose;\n  /** Null once this node has stopped. */\n  handle: AnimationHandle | null;\n  /** The corner and velocity its running decay started with. */\n  startX: number;\n  startY: number;\n  vx: number;\n  vy: number;\n}\n\n/** A world velocity as the rate of change of a pose at `at`. */\nfunction poseVelocity<TPose>(\n  ax: TargetAxes<TPose>,\n  d: PoseDescriptor<TPose>,\n  at: TPose,\n  vx: number,\n  vy: number,\n): TPose {\n  const base = ax.to(at);\n  const alongX = ax.to(translatePoseViaDescriptor(at, 1, 0, d));\n  const alongY = ax.to(translatePoseViaDescriptor(at, 0, 1, d));\n  return ax.from(base.map((b, i) => vx * (alongX[i]! - b) + vy * (alongY[i]! - b)));\n}\n\n/**\n * A coast on each node's own pose target: a decay per node, so anything else animating the\n * node adds to it. The document keeps the pre-drag pose while the node travels, takes the\n * pose it stops at, and the flick is recorded as one transform once every node has stopped.\n */\nexport function coastOnTargets<TPose>(a: CoastArgs<TPose>, targets: ReadonlyMap<string, Target<TPose>>): void {\n  const { animator, ctx, d, bounds, coasts } = a;\n  const adapter = ctx.adapter;\n  // Speed lost per unit traveled: an exponential coast's velocity is its first less this times\n  // how far it has gone, which is how a node stopped at an edge knows what speed it has left.\n  const drag = -Math.log(a.friction);\n  const cancelKey = coastKey();\n  const riders = new Map<string, Rider<TPose>>();\n\n  const ours = (r: Rider<TPose>): boolean =>\n    adapter.getNode(r.id) !== undefined && sameBounds(d.getBounds(r.target.committed()), d.getBounds(r.seen));\n\n  const launch = (r: Rider<TPose>, from: TPose | undefined, vx: number, vy: number): void => {\n    const at = from ?? r.target.committed();\n    const velocity = poseVelocity(r.target.axes, d, at, vx, vy);\n    const corner = d.getBounds(at);\n    r.startX = corner.x;\n    r.startY = corner.y;\n    r.vx = vx;\n    r.vy = vy;\n    r.handle = animator.decay<TPose>({\n      target: r.target,\n      from,\n      velocity,\n      friction: a.friction,\n      cancelKey,\n      interrupt: false,\n      onTick: (own) => tick(r, own),\n      onDone: () => halted(r),\n    });\n  };\n\n  const halted = (r: Rider<TPose>): void => {\n    r.handle = null;\n    r.seen = r.target.committed();\n    for (const other of riders.values()) if (other.handle) return;\n    commitFlick();\n  };\n\n  /**\n   * Takes `r` out of the coast where another writer left its node. Where that writer is another\n   * animation on the node, the node is still short of `left` by what the coast had traveled, at\n   * `own`: a spring carries that to nothing from the coast's speed, joining the node's moves.\n   */\n  const drop = (r: Rider<TPose>, own: TPose): void => {\n    const left = r.target.committed();\n    riders.delete(r.id);\n    r.handle?.cancel();\n    r.target.commit(left);\n    if (r.target.active && adapter.getNode(r.id) !== undefined) {\n      const moved = d.getBounds(left);\n      const was = d.getBounds(r.seen);\n      const corner = d.getBounds(own);\n      const vx = r.vx - drag * (corner.x - (moved.x - was.x) - r.startX);\n      const vy = r.vy - drag * (corner.y - (moved.y - was.y) - r.startY);\n      animator.spring<TPose>({\n        target: r.target,\n        from: own,\n        to: left,\n        velocity: poseVelocity(r.target.axes, d, own, vx, vy),\n        cancelKey: poseKey(r.id),\n        interrupt: false,\n      });\n    }\n    halted(r);\n  };\n\n  function tick(r: Rider<TPose>, own: TPose): void {\n    if (!ours(r)) { drop(r, own); return; }\n    const corner = d.getBounds(own);\n    const { nx, ny, hitX, hitY } = clampCorner(bounds, corner.x, corner.y);\n    if (!hitX && !hitY) return;\n    const vx = hitX ? 0 : r.vx - drag * (corner.x - r.startX);\n    const vy = hitY ? 0 : r.vy - drag * (corner.y - r.startY);\n    // Canceled, it commits the pose it reached; the edge is where it belongs.\n    r.handle?.cancel();\n    r.target.commit(translatePoseViaDescriptor(r.target.committed(), nx - corner.x, ny - corner.y, d));\n    r.seen = r.target.committed();\n    if (a.boundary === 'continue' && Math.hypot(vx, vy) > 0) launch(r, undefined, vx, vy);\n    else halted(r);\n  }\n\n  const coast: Coast = {\n    ids: ctx.draggedIds.slice(),\n    stop: (): void => {\n      // Canceled from outside (cancelAll, unmount), it stopped long ago and somewhere else.\n      if (!animator.isActive(cancelKey)) {\n        coasts.delete(coast);\n        return;\n      }\n      for (const r of riders.values()) {\n        r.handle?.cancel();\n        r.handle = null;\n        r.seen = r.target.committed();\n      }\n      commitFlick();\n    },\n  };\n  coasts.add(coast);\n\n  function commitFlick(): void {\n    if (!coasts.delete(coast) || !adapter.applyOps) return;\n    const ops: Op[] = [];\n    for (const r of riders.values()) {\n      if (!ours(r)) continue;\n      const from = ctx.origin.get(r.id) ?? r.seen;\n      const to = r.target.committed();\n      // A scene records the write it sees, not an op's `from`, so the document goes back first.\n      r.target.commit(from);\n      ops.push(createTransformOp<TPose>({ id: r.id, from, to, label: 'flick' }));\n    }\n    if (ops.length > 0) adapter.applyOps(ops, 'flick');\n  }\n\n  for (const [id, target] of targets) {\n    riders.set(id, { id, target, seen: target.committed(), handle: null, startX: 0, startY: 0, vx: 0, vy: 0 });\n  }\n  // Each starts from its release pose, which the document does not hold: the drag was a preview.\n  for (const r of [...riders.values()]) launch(r, ctx.current.get(r.id), a.vx, a.vy);\n}\n"],"mappings":"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"}

package/dist/animation/behaviors/momentum.js

@@ -1,156 +1,68 @@
-import { createTransformOp as e } from "../../core/ops/transform.js";
-import { translatePoseViaDescriptor as t } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as e } from "../../core/geometry/autoPoseDescriptor.js";
+import { coastByWrite as t } from "./coastByWrite.js";
+import { coastOnTargets as n } from "./coastOnTargets.js";
 import { getScratch as r, scratchKey as i, setScratch as a } from "@weasel-js/routing";
 //#region src/animation/behaviors/momentum.ts
-var o = (e, t) => e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height, s = 0, c = i("momentum.samples");
-function l(i) {
-	let l = i.friction ?? .92, u = i.threshold ?? 200, d = i.velocitySampleMs ?? 80, f = i.now ?? (() => Date.now()), p = i.bounds, m = i.boundary ?? "stop", h = i.poseDescriptor ?? n, g = (e, t, n, r) => {
-		let i = e + n, a = t + r;
-		if (!p) return {
-			nx: i,
-			ny: a,
-			hit: !1
-		};
-		let o = !1;
-		return i < p.x ? (i = p.x, o = !0) : i > p.x + p.width && (i = p.x + p.width, o = !0), a < p.y ? (a = p.y, o = !0) : a > p.y + p.height && (a = p.y + p.height, o = !0), {
-			nx: i,
-			ny: a,
-			hit: o
-		};
-	}, _ = (e) => {
-		let t = r(e.scratch, c);
-		t || (t = [], a(e.scratch, c, t)), t.push({
-			t: f(),
+var o = i("momentum.samples");
+function s(i) {
+	let s = i.friction ?? .92, c = i.threshold ?? 200, l = i.velocitySampleMs ?? 80, u = i.now ?? (() => Date.now()), d = i.poseDescriptor ?? e, f = (e) => {
+		let t = r(e.scratch, o);
+		t || (t = [], a(e.scratch, o, t)), t.push({
+			t: u(),
 			x: e.pointer.worldX,
 			y: e.pointer.worldY
 		});
-		let n = f() - d * 4;
+		let n = u() - l * 4;
 		for (; t.length > 1 && t[0].t < n;) t.shift();
-	}, v = /* @__PURE__ */ new Set();
+	}, p = /* @__PURE__ */ new Set(), m = (e) => {
+		let { adapter: t } = e;
+		if (!t.poseTarget) return null;
+		let n = /* @__PURE__ */ new Map();
+		for (let r of e.draggedIds) {
+			if (!e.current.has(r)) continue;
+			let a = t.getNode(r) && t.poseTarget(r, i.poseDescriptor);
+			if (!a) return null;
+			n.set(r, a);
+		}
+		return n;
+	};
 	return {
 		onStart(e) {
-			for (let t of [...v]) t.ids.some((t) => e.draggedIds.includes(t)) && t.stop();
-			a(e.scratch, c, []), _(e);
+			for (let t of [...p]) t.ids.some((t) => e.draggedIds.includes(t)) && t.stop();
+			a(e.scratch, o, []), f(e);
 		},
 		onMove(e) {
-			_(e);
+			f(e);
 		},
-		onEnd(n, a) {
+		onEnd(e, a) {
 			if (a.answered) return;
-			let f = r(n.scratch, c) ?? [];
-			if (f.length < 2) return;
-			let _ = f[f.length - 1], y = _.t - d, b = f[0];
-			for (let e of f) if (e.t >= y) {
-				b = e;
+			let u = r(e.scratch, o) ?? [];
+			if (u.length < 2) return;
+			let f = u[u.length - 1], h = f.t - l, g = u[0];
+			for (let e of u) if (e.t >= h) {
+				g = e;
 				break;
 			}
-			let x = (_.t - b.t) / 1e3;
-			if (x <= 0) return;
-			let S = (_.x - b.x) / x, C = (_.y - b.y) / x;
-			if (Math.hypot(S, C) < u) return;
-			let w = new Map(n.current), T = {
-				x: 0,
-				y: 0
-			}, E = n.adapter, D = (e) => {
-				if (E.previewPoses) E.previewPoses(e);
-				else for (let [t, n] of e) n !== null && E.setPose(t, n);
-			}, O = new Set(n.draggedIds), k = /* @__PURE__ */ new Map();
-			for (let e of O) E.getNode(e) && k.set(e, h.getBounds(E.getPose(e)));
-			let A = (e) => {
-				let t = k.get(e);
-				return t !== void 0 && E.getNode(e) !== void 0 && o(h.getBounds(E.getPose(e)), t);
-			}, j = /* @__PURE__ */ new Map(), M = `momentum:${s++}`, N = {
-				ids: n.draggedIds.slice(),
-				stop: () => {
-					if (!i.animator.isActive(M)) {
-						v.delete(N);
-						return;
-					}
-					P.cancel(), F();
-				}
-			};
-			v.add(N), D(new Map([...O].flatMap((e) => {
-				let t = w.get(e);
-				return t === void 0 ? [] : [[e, t]];
-			})));
-			let P = i.animator.decay({
-				from: {
-					x: 0,
-					y: 0
-				},
-				velocity: {
-					x: S,
-					y: C
-				},
-				friction: l,
-				cancelKey: M,
-				add: (e, t) => ({
-					x: e.x + t.x,
-					y: e.y + t.y
-				}),
-				scale: (e, t) => ({
-					x: e.x * t,
-					y: e.y * t
-				}),
-				magnitude: (e) => Math.hypot(e.x, e.y),
-				onTick: (e) => {
-					T = e;
-					let n = p !== void 0, r = /* @__PURE__ */ new Map();
-					for (let i of [...O]) {
-						if (!A(i)) {
-							O.delete(i), r.set(i, null);
-							continue;
-						}
-						let a = w.get(i);
-						if (!a) continue;
-						let o = h.getBounds(a), { nx: s, ny: c, hit: l } = g(o.x, o.y, e.x, e.y);
-						l || (n = !1), j.set(i, {
-							x: s,
-							y: c
-						}), r.set(i, t(a, s - o.x, c - o.y, h));
-					}
-					D(r);
-					for (let e of O) k.set(e, h.getBounds(E.getPose(e)));
-					if (O.size === 0) {
-						v.delete(N), P.cancel();
-						return;
-					}
-					m === "stop" && n && N.stop();
-				},
-				onDone: () => {
-					F();
-				}
-			});
-			function F() {
-				if (!v.delete(N)) return;
-				let r = [], i = /* @__PURE__ */ new Map();
-				for (let a of O) {
-					if (i.set(a, null), !A(a)) continue;
-					let o = w.get(a);
-					if (!o) continue;
-					let s = h.getBounds(o), c = j.get(a) ?? {
-						x: s.x + T.x,
-						y: s.y + T.y
-					}, l = t(o, c.x - s.x, c.y - s.y, h), u = n.origin.get(a) ?? o;
-					r.push(e({
-						id: a,
-						from: u,
-						to: l,
-						label: "flick"
-					}));
-				}
-				if (r.length > 0) {
-					if (E.applyOps) E.applyOps(r, "flick");
-					else if (E.previewPoses) for (let e of r) e.apply(E);
-				}
-				E.previewPoses?.(i);
-			}
-			return null;
+			let _ = (f.t - g.t) / 1e3;
+			if (_ <= 0) return;
+			let v = (f.x - g.x) / _, y = (f.y - g.y) / _;
+			if (Math.hypot(v, y) < c) return;
+			let b = {
+				animator: i.animator,
+				ctx: e,
+				vx: v,
+				vy: y,
+				friction: s,
+				d,
+				coasts: p,
+				bounds: i.bounds,
+				boundary: i.boundary ?? "stop"
+			}, x = m(e);
+			return x ? n(b, x) : t(b), null;
 		}
 	};
 }
 //#endregion
-export { l as momentum };
+export { s as momentum };
 
 //# sourceMappingURL=momentum.js.map

package/dist/animation/behaviors/momentum.js.map

@@ -1 +1 @@
-{"version":3,"file":"momentum.js","names":["sameBounds","a","b","nextCoast","SAMPLES","scratchKey","momentum","friction","opts","threshold","sampleMs","now","bounds","boundaryPolicy","d","AUTO_POSE_DESCRIPTOR","clampToBounds","nx","sx","dx","ny","sy","dy","hit","recordSample","samples","getScratch","ctx","setScratch","cutoff","coasts","coast","id","end","last","first","s","dt","vx","vy","startPoses","lastValue","adapter","show","poses","pose","riding","lastSeen","stillOurs","seen","finalPositions","cancelKey","decayHandle","commitFlick","start","v","k","delta","allHit","frame","translatePoseViaDescriptor","ops","shown","o","fp","finalPose","from","createTransformOp","op"],"sources":["../../../src/animation/behaviors/momentum.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { MoveBehavior, GestureContext } from 'interactions/gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { Animator } from '../types';\n\n/** Options for the `momentum` move behavior. */\nexport interface MomentumOptions {\n  /** Required: the per-Canvas animator that will own the decay. */\n  animator: Animator;\n  friction?: number;     // default 0.92 (per second)\n  threshold?: number;    // default 200 world units/sec; the slowest release that coasts\n  /** Sample window in ms for velocity computation. Default 80ms. */\n  velocitySampleMs?: number;\n  /** Optional clock override for tests. Defaults to `Date.now`. */\n  now?: () => number;\n  /**\n   * Optional bounds for the object's top-left corner (in world units). When\n   * supplied, momentum-driven translation is clamped: each tick's new\n   * position is constrained so the object's `(x, y)` stays inside the rect.\n   * Without bounds, a hard flick carries the object indefinitely until\n   * friction dampens velocity below `threshold`.\n   *\n   * Note: ignores object size for now — the bound is on the top-left, not\n   * the visible edges. A consumer wanting \"object stays fully inside\" should\n   * pass `bounds = { x: canvas.x, y: canvas.y, width: canvas.w - obj.w,\n   * height: canvas.h - obj.h }` (and accept that it doesn't adapt to\n   * variable-sized objects mid-flight).\n   */\n  bounds?: { x: number; y: number; width: number; height: number };\n  /**\n   * Boundary policy when the clamped position hits an edge. 'stop' cancels\n   * the decay (instant settle at the edge). 'continue' keeps decaying but\n   * subsequent ticks stay clamped (object drifts along the edge as friction\n   * decays the velocity). Default 'stop'.\n   */\n  boundary?: 'stop' | 'continue';\n  /** How to translate poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n}\n\ninterface PointerSample {\n  t: number;       // ms timestamp\n  x: number;\n  y: number;\n}\n\ninterface RectLike { x: number; y: number }\n\nconst sameBounds = (a: Bounds, b: Bounds): boolean =>\n  a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n\nlet nextCoast = 0;\n\nconst SAMPLES = scratchKey<PointerSample[]>('momentum.samples');\n\n/**\n * Move behavior that keeps a dragged node coasting after the pointer is\n * released, at the velocity it was traveling, until friction brings it to\n * rest. A release slower than `threshold` does not coast at all.\n *\n * Plugs into the move action rather than replacing it, so the drag itself is\n * unchanged — this only decides what happens after the release. The whole\n * flick, coast included, records as one undoable transform: under an adapter\n * with `previewPoses` the coast is shown without touching the document, and\n * the transform is written once it comes to rest. Dragging a node\n * again while it coasts stops the coast and records it where it stands. A node\n * something else moves or deletes mid-coast, an undo included, drops out of\n * the coast where that left it, and nothing is recorded for it.\n */\nexport function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose> {\n  const friction = opts.friction ?? 0.92;\n  const threshold = opts.threshold ?? 200;\n  const sampleMs = opts.velocitySampleMs ?? 80;\n  const now = opts.now ?? (() => Date.now());\n  const bounds = opts.bounds;\n  const boundaryPolicy = opts.boundary ?? 'stop';\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  /** Apply bounds clamp to (sx + dx, sy + dy). Returns clamped (nx, ny) and\n   *  whether either axis was clamped (signalling boundary hit). */\n  const clampToBounds = (sx: number, sy: number, dx: number, dy: number): { nx: number; ny: number; hit: boolean } => {\n    let nx = sx + dx;\n    let ny = sy + dy;\n    if (!bounds) return { nx, ny, hit: false };\n    let hit = false;\n    if (nx < bounds.x) { nx = bounds.x; hit = true; }\n    else if (nx > bounds.x + bounds.width) { nx = bounds.x + bounds.width; hit = true; }\n    if (ny < bounds.y) { ny = bounds.y; hit = true; }\n    else if (ny > bounds.y + bounds.height) { ny = bounds.y + bounds.height; hit = true; }\n    return { nx, ny, hit };\n  };\n\n  const recordSample = (ctx: GestureContext<TPose>): void => {\n    let samples = getScratch(ctx.scratch, SAMPLES);\n    if (!samples) {\n      samples = [];\n      setScratch(ctx.scratch, SAMPLES, samples);\n    }\n    samples.push({\n      t: now(),\n      x: ctx.pointer.worldX,\n      y: ctx.pointer.worldY,\n    });\n    // Trim anything older than 4× the sample window — bounded memory.\n    const cutoff = now() - sampleMs * 4;\n    while (samples.length > 1 && samples[0].t < cutoff) samples.shift();\n  };\n\n  const coasts = new Set<{ ids: readonly string[]; stop(): void }>();\n\n  return {\n    onStart(ctx) {\n      for (const coast of [...coasts]) {\n        if (coast.ids.some((id) => ctx.draggedIds.includes(id))) coast.stop();\n      }\n      setScratch(ctx.scratch, SAMPLES, []);\n      recordSample(ctx);\n    },\n    onMove(ctx) {\n      recordSample(ctx);\n    },\n    onEnd(ctx, end): Op[] | null | void {\n      if (end.answered) return undefined;\n      const samples = getScratch(ctx.scratch, SAMPLES) ?? [];\n      if (samples.length < 2) return undefined;\n      const last = samples[samples.length - 1];\n      // Find the oldest sample within `sampleMs` of `last`.\n      const cutoff = last.t - sampleMs;\n      let first = samples[0];\n      for (const s of samples) {\n        if (s.t >= cutoff) { first = s; break; }\n      }\n      const dt = (last.t - first.t) / 1000;\n      if (dt <= 0) return undefined;\n      const vx = (last.x - first.x) / dt;\n      const vy = (last.y - first.y) / dt;\n      const speed = Math.hypot(vx, vy);\n      if (speed < threshold) return undefined;\n\n      // Suppress default commit and fire decay. We translate each dragged id\n      // by the per-frame delta and commit one transform op per id when done.\n      const startPoses = new Map<string, TPose>(ctx.current);\n      let lastValue = { x: 0, y: 0 };\n      const adapter = ctx.adapter;\n      const show = (poses: Map<string, TPose | null>): void => {\n        if (adapter.previewPoses) adapter.previewPoses(poses);\n        else for (const [id, pose] of poses) if (pose !== null) adapter.setPose(id, pose);\n      };\n      // What the scene held for each node right after the coast last wrote it.\n      // A node that is gone, or reads back as anything else, has another\n      // writer now, an undo or a delete, and leaves the coast unrecorded.\n      const riding = new Set(ctx.draggedIds);\n      const lastSeen = new Map<string, Bounds>();\n      for (const id of riding) {\n        if (adapter.getNode(id)) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n      }\n      const stillOurs = (id: string): boolean => {\n        const seen = lastSeen.get(id);\n        return seen !== undefined && adapter.getNode(id) !== undefined\n          && sameBounds(d.getBounds(adapter.getPose(id)), seen);\n      };\n      // Track per-id final positions when bounds clamping is active — used\n      // by onDone to compute the correct final transform op (not just\n      // start + decay's last delta, which may overshoot the boundary).\n      const finalPositions = new Map<string, { x: number; y: number }>();\n      const cancelKey = `momentum:${nextCoast++}`;\n      const coast = {\n        ids: ctx.draggedIds.slice(),\n        stop: (): void => {\n          // Canceled from outside (cancelAll, unmount), it stopped long ago and somewhere else.\n          if (!opts.animator.isActive(cancelKey)) {\n            coasts.delete(coast);\n            return;\n          }\n          decayHandle.cancel();\n          commitFlick();\n        },\n      };\n      coasts.add(coast);\n      // Held from the release itself, so no frame paints the pre-drag pose\n      // between the drag's preview going away and the first coast frame.\n      show(new Map([...riding].flatMap((id) => {\n        const start = startPoses.get(id);\n        return start === undefined ? [] : [[id, start] as const];\n      })));\n      const decayHandle = opts.animator.decay<RectLike>({\n        from: { x: 0, y: 0 },\n        velocity: { x: vx, y: vy },\n        friction,\n        cancelKey,\n        add: (a, b) => ({ x: a.x + b.x, y: a.y + b.y }),\n        scale: (v, k) => ({ x: v.x * k, y: v.y * k }),\n        magnitude: (v) => Math.hypot(v.x, v.y),\n        onTick: (delta) => {\n          lastValue = delta;\n          let allHit = bounds !== undefined;\n          const frame = new Map<string, TPose | null>();\n          for (const id of [...riding]) {\n            if (!stillOurs(id)) {\n              riding.delete(id);\n              frame.set(id, null);\n              continue;\n            }\n            const start = startPoses.get(id);\n            if (!start) continue;\n            const o = d.getBounds(start);\n            const { nx, ny, hit } = clampToBounds(o.x, o.y, delta.x, delta.y);\n            if (!hit) allHit = false;\n            finalPositions.set(id, { x: nx, y: ny });\n            frame.set(id, translatePoseViaDescriptor(start, nx - o.x, ny - o.y, d));\n          }\n          show(frame);\n          for (const id of riding) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n          if (riding.size === 0) {\n            coasts.delete(coast);\n            decayHandle.cancel();\n            return;\n          }\n          // If 'stop' policy and every dragged id's clamped position hit\n          // the boundary, cancel the decay so the animation settles instantly\n          // instead of drifting along the edge as friction wears off.\n          if (boundaryPolicy === 'stop' && allHit) coast.stop();\n        },\n        onDone: () => {\n          commitFlick();\n        },\n      });\n\n      function commitFlick(): void {\n        if (!coasts.delete(coast)) return;\n        const ops: Op[] = [];\n        const shown = new Map<string, TPose | null>();\n        for (const id of riding) {\n          shown.set(id, null);\n          if (!stillOurs(id)) continue;\n          const start = startPoses.get(id);\n          if (!start) continue;\n          const o = d.getBounds(start);\n          const fp = finalPositions.get(id) ?? { x: o.x + lastValue.x, y: o.y + lastValue.y };\n          const finalPose = translatePoseViaDescriptor(start, fp.x - o.x, fp.y - o.y, d);\n          const from = ctx.origin.get(id) ?? start;\n          ops.push(createTransformOp<TPose>({ id, from, to: finalPose, label: 'flick' }));\n        }\n        // The document first, so the preview never gives way to the pre-drag pose.\n        if (ops.length > 0) {\n          if (adapter.applyOps) adapter.applyOps(ops, 'flick');\n          else if (adapter.previewPoses) for (const op of ops) op.apply(adapter);\n        }\n        adapter.previewPoses?.(shown);\n      }\n\n      return null;\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"momentum.js","names":["SAMPLES","scratchKey","momentum","friction","opts","threshold","sampleMs","now","AUTO_POSE_DESCRIPTOR","recordSample","samples","getScratch","ctx","setScratch","cutoff","coasts","targetsOf","adapter","targets","id","target","coast","end","last","first","s","dt","vx","vy","args","coastOnTargets","coastByWrite"],"sources":["../../../src/animation/behaviors/momentum.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport type { MoveBehavior, GestureContext } from 'interactions/gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { Target } from '@weasel-js/animator';\nimport type { Animator } from '@weasel-js/animator';\nimport type { Coast, CoastArgs } from './coast';\nimport { coastByWrite } from './coastByWrite';\nimport { coastOnTargets } from './coastOnTargets';\n\n/** Options for the `momentum` move behavior. */\nexport interface MomentumOptions {\n  /** Required: the per-Canvas animator that will own the decay. */\n  animator: Animator;\n  friction?: number;     // default 0.92 (per second)\n  threshold?: number;    // default 200 world units/sec; the slowest release that coasts\n  /** Sample window in ms for velocity computation. Default 80ms. */\n  velocitySampleMs?: number;\n  /** Optional clock override for tests. Defaults to `Date.now`. */\n  now?: () => number;\n  /**\n   * Optional bounds for the object's top-left corner (in world units): each\n   * tick's new position is clamped so the object's `(x, y)` stays inside the\n   * rect. Object size is ignored, so to keep an object fully inside, shrink\n   * the rect by the object's width and height.\n   */\n  bounds?: { x: number; y: number; width: number; height: number };\n  /**\n   * Boundary policy when the clamped position hits an edge. 'stop' settles at\n   * the edge at once. 'continue' keeps decaying, so the object drifts along\n   * the edge. Default 'stop'.\n   */\n  boundary?: 'stop' | 'continue';\n  /** How to translate poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n}\n\ninterface PointerSample {\n  t: number;       // ms timestamp\n  x: number;\n  y: number;\n}\n\nconst SAMPLES = scratchKey<PointerSample[]>('momentum.samples');\n\n/**\n * Move behavior that keeps a dragged node coasting after the pointer is\n * released, at the velocity it was traveling, until friction brings it to\n * rest. A release slower than `threshold` does not coast at all.\n *\n * The whole flick, coast included, records as one undoable transform, written\n * once it comes to rest. Over an adapter with `poseTarget`, which a\n * scene-backed one has, each node coasts on its own pose target, so anything\n * else animating it adds; over one without, the coast is shown through\n * `previewPoses`, or written through `setPose` each frame. Dragging a node\n * again while it coasts stops the coast and records it where it stands. A\n * `tweenPose` or `springPose` of a coasting node ends its coast. A node\n * something else moves or deletes mid-coast, an undo included, drops out of\n * the coast where that left it, and nothing is recorded for it.\n */\nexport function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose> {\n  const friction = opts.friction ?? 0.92;\n  const threshold = opts.threshold ?? 200;\n  const sampleMs = opts.velocitySampleMs ?? 80;\n  const now = opts.now ?? (() => Date.now());\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const recordSample = (ctx: GestureContext<TPose>): void => {\n    let samples = getScratch(ctx.scratch, SAMPLES);\n    if (!samples) {\n      samples = [];\n      setScratch(ctx.scratch, SAMPLES, samples);\n    }\n    samples.push({\n      t: now(),\n      x: ctx.pointer.worldX,\n      y: ctx.pointer.worldY,\n    });\n    // Trim anything older than 4× the sample window — bounded memory.\n    const cutoff = now() - sampleMs * 4;\n    while (samples.length > 1 && samples[0].t < cutoff) samples.shift();\n  };\n\n  const coasts = new Set<Coast>();\n\n  /** Every dragged node's pose target, or null where the adapter has none for one of them. */\n  const targetsOf = (ctx: GestureContext<TPose>): Map<string, Target<TPose>> | null => {\n    const { adapter } = ctx;\n    if (!adapter.poseTarget) return null;\n    const targets = new Map<string, Target<TPose>>();\n    for (const id of ctx.draggedIds) {\n      if (!ctx.current.has(id)) continue;\n      const target = adapter.getNode(id) && adapter.poseTarget(id, opts.poseDescriptor as PoseDescriptor<TPose> | undefined);\n      if (!target) return null;\n      targets.set(id, target);\n    }\n    return targets;\n  };\n\n  return {\n    onStart(ctx) {\n      for (const coast of [...coasts]) {\n        if (coast.ids.some((id) => ctx.draggedIds.includes(id))) coast.stop();\n      }\n      setScratch(ctx.scratch, SAMPLES, []);\n      recordSample(ctx);\n    },\n    onMove(ctx) {\n      recordSample(ctx);\n    },\n    onEnd(ctx, end): Op[] | null | void {\n      if (end.answered) return undefined;\n      const samples = getScratch(ctx.scratch, SAMPLES) ?? [];\n      if (samples.length < 2) return undefined;\n      const last = samples[samples.length - 1];\n      // Find the oldest sample within `sampleMs` of `last`.\n      const cutoff = last.t - sampleMs;\n      let first = samples[0];\n      for (const s of samples) {\n        if (s.t >= cutoff) { first = s; break; }\n      }\n      const dt = (last.t - first.t) / 1000;\n      if (dt <= 0) return undefined;\n      const vx = (last.x - first.x) / dt;\n      const vy = (last.y - first.y) / dt;\n      if (Math.hypot(vx, vy) < threshold) return undefined;\n\n      const args: CoastArgs<TPose> = {\n        animator: opts.animator, ctx, vx, vy, friction, d, coasts,\n        bounds: opts.bounds, boundary: opts.boundary ?? 'stop',\n      };\n      const targets = targetsOf(ctx);\n      if (targets) coastOnTargets(args, targets);\n      else coastByWrite(args);\n      // The coast commits the flick itself, so the move action's own commit is suppressed.\n      return null;\n    },\n  };\n}\n"],"mappings":";;;;;AA4CA,IAAMA,IAAUC,EAA4B,kBAAkB;AAiB9D,SAAgBC,EAAgB,GAA4C;CAC1E,IAAMC,IAAWC,EAAK,YAAY,KAC5BC,IAAYD,EAAK,aAAa,KAC9BE,IAAWF,EAAK,oBAAoB,IACpCG,IAAMH,EAAK,cAAc,KAAK,IAAI,IAClC,IAAKA,EAAK,kBAAkBI,GAE5BC,KAAgB,MAAqC;EACzD,IAAIC,IAAUC,EAAWC,EAAI,SAASZ,CAAO;EAK7C,AAJKU,MACH,IAAU,CAAC,GACXG,EAAWD,EAAI,SAASZ,GAASU,CAAO,IAE1CA,EAAQ,KAAK;GACX,GAAGH,EAAI;GACP,GAAGK,EAAI,QAAQ;GACf,GAAGA,EAAI,QAAQ;EACjB,CAAC;EAED,IAAME,IAASP,EAAI,IAAID,IAAW;EAClC,OAAOI,EAAQ,SAAS,KAAKA,EAAQ,EAAE,CAAC,IAAII,IAAQ,EAAQ,MAAM;CACpE,GAEMC,oBAAS,IAAI,IAAW,GAGxBC,KAAa,MAAkE;EACnF,IAAM,EAAE,eAAYJ;EACpB,IAAI,CAACK,EAAQ,YAAY,OAAO;EAChC,IAAMC,oBAAU,IAAI,IAA2B;EAC/C,KAAK,IAAMC,KAAMP,EAAI,YAAY;GAC/B,IAAI,CAACA,EAAI,QAAQ,IAAIO,CAAE,GAAG;GAC1B,IAAMC,IAASH,EAAQ,QAAQE,CAAE,KAAKF,EAAQ,WAAWE,GAAIf,EAAK,cAAmD;GACrH,IAAI,CAACgB,GAAQ,OAAO;GACpB,EAAQ,IAAID,GAAIC,CAAM;EACxB;EACA,OAAOF;CACT;CAEA,OAAO;EACL,QAAQ,GAAK;GACX,KAAK,IAAMG,KAAS,CAAC,GAAGN,CAAM,GAC5B,AAAIM,EAAM,IAAI,MAAM,MAAOT,EAAI,WAAW,SAASO,CAAE,CAAC,KAAGE,EAAM,KAAK;GAGtE,AADAR,EAAWD,EAAI,SAASZ,GAAS,CAAC,CAAC,GACnCS,EAAaG,CAAG;EAClB;EACA,OAAO,GAAK;GACV,EAAaA,CAAG;EAClB;EACA,MAAM,GAAK,GAAyB;GAClC,IAAIU,EAAI,UAAU;GAClB,IAAMZ,IAAUC,EAAWC,EAAI,SAASZ,CAAO,KAAK,CAAC;GACrD,IAAIU,EAAQ,SAAS,GAAG;GACxB,IAAMa,IAAOb,EAAQA,EAAQ,SAAS,IAEhCI,IAASS,EAAK,IAAIjB,GACpBkB,IAAQd,EAAQ;GACpB,KAAK,IAAMe,KAAKf,GACd,IAAIe,EAAE,KAAKX,GAAQ;IAAE,IAAQW;IAAG;GAAO;GAEzC,IAAMC,KAAMH,EAAK,IAAIC,EAAM,KAAK;GAChC,IAAIE,KAAM,GAAG;GACb,IAAMC,KAAMJ,EAAK,IAAIC,EAAM,KAAKE,GAC1BE,KAAML,EAAK,IAAIC,EAAM,KAAKE;GAChC,IAAI,KAAK,MAAMC,GAAIC,CAAE,IAAIvB,GAAW;GAEpC,IAAMwB,IAAyB;IAC7B,UAAUzB,EAAK;IAAU;IAAK;IAAI;IAAI;IAAU;IAAG;IACnD,QAAQA,EAAK;IAAQ,UAAUA,EAAK,YAAY;GAClD,GACMc,IAAUF,EAAUJ,CAAG;GAI7B,OAHIM,IAASY,EAAeD,GAAMX,CAAO,IACpCa,EAAaF,CAAI,GAEf;EACT;CACF;AACF"}

package/dist/animation/clipTargets.js

@@ -0,0 +1,12 @@
+import { scenePoseTarget as e } from "./poseTarget.js";
+//#region src/animation/clipTargets.ts
+function t(t, n = {}) {
+	return (r) => {
+		if (r.startsWith("pose:")) return e(t, r.slice(5), n.descriptor, n.cascade);
+		if (r.startsWith("rig:")) return n.rigs?.[r.slice(4)]?.target;
+	};
+}
+//#endregion
+export { t as sceneClipTargets };
+
+//# sourceMappingURL=clipTargets.js.map

package/dist/animation/clipTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipTargets.js","names":["sceneClipTargets","name","scenePoseTarget","scene","options"],"sources":["../../src/animation/clipTargets.ts"],"sourcesContent":["import type { ClipBinder, Pose, Target } from '@weasel-js/animator';\nimport type { PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport { scenePoseTarget, type PoseCascade, type PoseTargetScene } from './poseTarget';\n\n/** Options for `sceneClipTargets`. */\nexport interface SceneClipTargetsOptions<TPose> {\n  /** Rigs by the name a clip calls them: a track naming `rig:<name>` moves that rig's pose. */\n  rigs?: Readonly<Record<string, { readonly target: Target<Pose> }>>;\n  /** As `scenePoseTarget` takes them. */\n  descriptor?: PoseDescriptor<TPose>;\n  cascade?: PoseCascade<TPose>;\n}\n\n/**\n * A `ClipBinder.target` over a scene. `pose:<node id>` is that node's pose target, the one\n * `scenePoseTarget` answers, and `rig:<name>` is the target of the rig given under that\n * name. Any other name is `undefined`, for a caller to resolve itself first or after. A track\n * over part of a rig names joints as its `axes`, which the rig's target resolves.\n */\nexport function sceneClipTargets<TPose>(\n  scene: PoseTargetScene<TPose>,\n  options: SceneClipTargetsOptions<TPose> = {},\n): NonNullable<ClipBinder['target']> {\n  return (name) => {\n    if (name.startsWith('pose:')) return scenePoseTarget(scene, name.slice(5), options.descriptor, options.cascade);\n    if (name.startsWith('rig:')) return options.rigs?.[name.slice(4)]?.target;\n    return undefined;\n  };\n}\n"],"mappings":";;AAmBA,SAAgBA,EACd,GACA,IAA0C,CAAC,GACR;CACnC,QAAQ,MAAS;EACf,IAAIC,EAAK,WAAW,OAAO,GAAG,OAAOC,EAAgBC,GAAOF,EAAK,MAAM,CAAC,GAAGG,EAAQ,YAAYA,EAAQ,OAAO;EAC9G,IAAIH,EAAK,WAAW,MAAM,GAAG,OAAOG,EAAQ,OAAOH,EAAK,MAAM,CAAC,EAAE,EAAE;CAErE;AACF"}