@weasel-js/animator 1.15.2 → 1.16.0

package/dist/{chunk-7TTE4JM6.js → chunk-TXKTFZIW.js}

@@ -722,12 +722,11 @@ function createTargetTable(opts) {
   tables.set(table, rows);
   return table;
 }
-
-// src/colorRegistry.ts
 var ColorOverrideRegistry = class {
   map = /* @__PURE__ */ new Map();
   slots = /* @__PURE__ */ new Map();
   tables = /* @__PURE__ */ new Map();
+  listeners = createEmitter();
   _version = 0;
   set(id, channel, override) {
     let entry = this.map.get(id);
@@ -736,7 +735,7 @@ var ColorOverrideRegistry = class {
       this.map.set(id, entry);
     }
     entry[channel] = override;
-    this._version++;
+    this.changed();
   }
   /** Drops `id`'s override on `channel`, and the colors a finished or canceled animation on its
    *  {@link target} left painted. An animation still running goes on. */
@@ -747,7 +746,7 @@ var ColorOverrideRegistry = class {
     if (!(channel in entry)) return;
     delete entry[channel];
     if (!entry.fill && !entry.stroke) this.map.delete(id);
-    this._version++;
+    this.changed();
   }
   clearAll() {
     for (const [id, node] of this.slots) {
@@ -755,7 +754,7 @@ var ColorOverrideRegistry = class {
     }
     if (this.map.size === 0) return;
     this.map.clear();
-    this._version++;
+    this.changed();
   }
   /** What `set` stored for `id`'s `channel`; failing that, the colors its {@link target} paints. */
   get(id, channel) {
@@ -764,9 +763,12 @@ var ColorOverrideRegistry = class {
     const slot = this.slots.get(id)?.[channel];
     return slot?.painted ? shownOf(slot) : void 0;
   }
-  /** Whether anything overrides `id`, on either channel. */
+  /** Whether anything paints over `id`, on either channel: an override from `set`, or a target
+   *  an animation has committed. A target asked for and never moved does not count. */
   has(id) {
-    return this.map.has(id) || this.slots.has(id);
+    if (this.map.has(id)) return true;
+    const node = this.slots.get(id);
+    return node !== void 0 && (node.fill?.painted === true || node.stroke?.painted === true);
   }
   /**
    * The {@link Target} for `id`'s colors on `channel`: `length` numbers, flat RGBA per anchor.
@@ -811,7 +813,8 @@ var ColorOverrideRegistry = class {
       set: (row) => {
         const slot = rows[row];
         if (slot) slot.painted = true;
-        this._version++;
+        if (table.target(row).active) this._version++;
+        else this.changed();
       },
       show: () => {
         this._version++;
@@ -836,7 +839,7 @@ var ColorOverrideRegistry = class {
     delete node[channel];
     if (!node.fill && !node.stroke) this.slots.delete(id);
     this.drop(slot);
-    if (slot.painted) this._version++;
+    if (slot.painted) this.changed();
   }
   /**
    * The colors to paint on `id`'s `channel`, given the colors the painter would
@@ -859,9 +862,18 @@ var ColorOverrideRegistry = class {
     const result = override(base, tMs);
     return result.length === base.length ? result : base;
   }
+  /** Calls `listener` after a `set`, `clear`, or release changes what paints; an animation's
+   *  frames reach a painter through `animator.onTick` instead. Returns an unsubscribe. */
+  subscribe(listener) {
+    return this.listeners.subscribe(listener);
+  }
   version() {
     return this._version;
   }
+  changed() {
+    this._version++;
+    this.listeners.emit();
+  }
 };
 function shownOf(slot) {
   const { shown } = slot.table;
@@ -870,6 +882,119 @@ function shownOf(slot) {
   for (let i = 0; i < out.length; i++) out[i] = shown[at + i];
   return out;
 }
+var EDGES = ["start", "end"];
+var TrimOverrideRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  slots = /* @__PURE__ */ new Map();
+  listeners = createEmitter();
+  _version = 0;
+  set(id, override) {
+    this.map.set(id, { ...override });
+    this.changed();
+  }
+  /** Drops `id`'s override, and the edges a finished or canceled animation on its
+   *  {@link target}s left painted. An animation still running goes on. */
+  clear(id) {
+    for (const edge of EDGES) this.release(id, edge);
+    if (this.map.delete(id)) this.changed();
+  }
+  clearAll() {
+    for (const [id, node] of [...this.slots]) {
+      for (const edge of Object.keys(node)) this.release(id, edge);
+    }
+    if (this.map.size === 0) return;
+    this.map.clear();
+    this.changed();
+  }
+  /** What paints on `id`'s edges now: see {@link resolve}. */
+  get(id) {
+    return this.resolve(id);
+  }
+  /** Whether anything paints over `id`'s trim: an override from `set`, or a target an
+   *  animation has committed. A target asked for and never moved does not count. */
+  has(id) {
+    if (this.map.has(id)) return true;
+    const node = this.slots.get(id);
+    return node !== void 0 && (node.start?.painted === true || node.end?.painted === true);
+  }
+  /**
+   * The {@link Target} for `id`'s `edge`, committed at the whole stroke's (`start` 0, `end` 1)
+   * until something moves it. Every caller for one node and edge gets the same one, so their
+   * animations add. The registry holds its committed value and nothing writes the scene.
+   *
+   * What it paints, on its own edge only: with no override from `set` on that edge, its value in
+   * place of the stroke's own; over one, only what its animations have left to travel, added on
+   * top. Ask again for each animation rather than keeping it: {@link release} and {@link clear}
+   * drop a resting one, and the target it had throws from then on.
+   */
+  target(id, edge) {
+    let node = this.slots.get(id);
+    const held = node?.[edge];
+    if (held) return held.target;
+    const state = { value: edge === "start" ? 0 : 1, painted: false, released: false };
+    const target = createTarget({
+      get: () => state.value,
+      set: (value) => {
+        if (state.released) throw new Error(`trim overrides: ${id}'s ${edge} target was released`);
+        state.value = value;
+        state.painted = true;
+        if (target.active) this._version++;
+        else this.changed();
+      },
+      show: () => {
+        this._version++;
+      }
+    });
+    if (!node) {
+      node = {};
+      this.slots.set(id, node);
+    }
+    node[edge] = Object.assign(state, { target });
+    return target;
+  }
+  /** Drops the value `id`'s {@link target} on `edge` left painted, unless an animation is still
+   *  moving it. An override from `set` stays. */
+  release(id, edge) {
+    const node = this.slots.get(id);
+    const slot = node?.[edge];
+    if (!node || !slot || slot.target.active) return;
+    delete node[edge];
+    if (!node.start && !node.end) this.slots.delete(id);
+    slot.released = true;
+    if (slot.painted) this.changed();
+  }
+  /**
+   * The edges to paint on `id`'s stroke, each on its own: the override from `set` for that
+   * edge plus what its {@link target} has left to travel; failing a `set` value, the target's
+   * value once an animation has committed it. An edge with neither is left out, so the stroke's
+   * own stands. `undefined` when neither edge is overridden.
+   */
+  resolve(id) {
+    const override = this.map.get(id);
+    const node = this.slots.get(id);
+    const start = edgeOf(override?.start, node?.start);
+    const end = edgeOf(override?.end, node?.end);
+    if (start === void 0 && end === void 0) return void 0;
+    return { ...start !== void 0 ? { start } : {}, ...end !== void 0 ? { end } : {} };
+  }
+  /** Calls `listener` after a `set`, `clear`, or release changes what paints; an animation's
+   *  frames reach a painter through `animator.onTick` instead. Returns an unsubscribe. */
+  subscribe(listener) {
+    return this.listeners.subscribe(listener);
+  }
+  version() {
+    return this._version;
+  }
+  changed() {
+    this._version++;
+    this.listeners.emit();
+  }
+};
+function edgeOf(set, slot) {
+  const painted = slot?.painted === true;
+  if (set === void 0) return painted ? slot.target.read() : void 0;
+  return painted && slot.target.active ? set + slot.target.read() - slot.value : set;
+}
 function axesFor(axes, value, what) {
   const a = axes.to(value);
   if (a.length !== axes.count || !a.every((x) => typeof x === "number" && !Number.isNaN(x))) {
@@ -1609,6 +1734,6 @@ function createTimeline(register, id, opts, report, hold) {
   };
 }
 
-export { ColorOverrideRegistry, absorb, axesFor, axesOf, axisIndexes, bump, bumpOn, comeOut, commitOffset, committedInto, createHoldStore, createTarget, createTargetBook, createTargetTable, createTimeline, goBehind, isTarget, minus, norm, plus, rowTableOf, runsOn, sampleTrack, seat, setBeside, shareBehind, stateOf, takeUp, times, travel };
-//# sourceMappingURL=chunk-7TTE4JM6.js.map
-//# sourceMappingURL=chunk-7TTE4JM6.js.map
+export { ColorOverrideRegistry, TrimOverrideRegistry, absorb, axesFor, axesOf, axisIndexes, bump, bumpOn, comeOut, commitOffset, committedInto, createHoldStore, createTarget, createTargetBook, createTargetTable, createTimeline, goBehind, isTarget, minus, norm, plus, rowTableOf, runsOn, sampleTrack, seat, setBeside, shareBehind, stateOf, takeUp, times, travel };
+//# sourceMappingURL=chunk-TXKTFZIW.js.map
+//# sourceMappingURL=chunk-TXKTFZIW.js.map