@pixerate/editor 0.140.4 → 0.142.1

package/dist/chunk-54GVEVXS.js

@@ -0,0 +1,408 @@
+import {
+  PRESENCE_COLORS,
+  realPresenceClock
+} from "./chunk-PEEP2YR7.js";
+
+// src/tools/playback.ts
+var ARG_KINDS = {
+  nodeId: "node",
+  edgeId: "edge",
+  layerId: "layer",
+  clipId: "clip",
+  trackId: "track",
+  seriesId: "series",
+  parameterId: "parameter",
+  keyframeId: "keyframe",
+  shapeId: "shape"
+};
+function pushRef(out, kind, id) {
+  if (typeof id !== "string" || !id) return;
+  if (!out.some((r) => r.kind === kind && r.id === id)) out.push({ kind, id });
+}
+function playbackRefsFromArgs(args, defaultKind = "item") {
+  const out = [];
+  const visit = (value, depth) => {
+    if (!value || typeof value !== "object" || Array.isArray(value) || depth > 1) return;
+    const record = value;
+    pushRef(out, defaultKind, record.id);
+    if (Array.isArray(record.ids)) for (const id of record.ids) pushRef(out, defaultKind, id);
+    for (const [key, kind] of Object.entries(ARG_KINDS)) {
+      pushRef(out, kind, record[key]);
+      const many = record[`${key}s`];
+      if (Array.isArray(many)) for (const id of many) pushRef(out, kind, id);
+    }
+    pushRef(out, "cell", record.range);
+    pushRef(out, "cell", record.cell);
+    visit(record.params, depth + 1);
+  };
+  visit(args, 0);
+  return out;
+}
+function playbackRefsFromResult(value, defaultKind = "item") {
+  const out = [];
+  const visit = (v, depth) => {
+    if (!v || typeof v !== "object" || depth > 2) return;
+    if (Array.isArray(v)) {
+      for (const item of v) if (item && typeof item === "object") pushRef(out, defaultKind, item.id);
+      return;
+    }
+    const record = v;
+    if (Array.isArray(record.content) && record.structuredContent) return visit(record.structuredContent, depth);
+    pushRef(out, defaultKind, record.id);
+    if (Array.isArray(record.ids)) for (const id of record.ids) pushRef(out, defaultKind, id);
+    if (record.node && typeof record.node === "object") pushRef(out, "node", record.node.id);
+    pushRef(out, "layer", record.layerId);
+    if (record.layer && typeof record.layer === "object") pushRef(out, "layer", record.layer.id);
+    const created = record.created;
+    if (Array.isArray(created)) visit(created, depth + 1);
+    else if (created && typeof created === "object") {
+      const c = created;
+      for (const n of c.nodes ?? []) pushRef(out, "node", n?.id);
+      for (const e of c.edges ?? []) pushRef(out, "edge", e?.id);
+    }
+    if (record.result && typeof record.result === "object") visit(record.result, depth + 1);
+  };
+  visit(value, 0);
+  return out;
+}
+function derivePlaybackSteps(args, defaultKind) {
+  const refs = playbackRefsFromArgs(args, defaultKind).slice(0, 8);
+  if (!refs.length) return [{ type: "commit" }];
+  return [...refs.map((ref) => ({ type: "target", ref })), { type: "press" }, { type: "release" }, { type: "commit" }];
+}
+function readingTime(text) {
+  return Math.min(2200, Math.max(600, text.length * 65));
+}
+function unionRects(rects) {
+  const list = rects.filter((r) => !!r);
+  if (!list.length) return null;
+  const x = Math.min(...list.map((r) => r.x));
+  const y = Math.min(...list.map((r) => r.y));
+  return { x, y, width: Math.max(...list.map((r) => r.x + r.width)) - x, height: Math.max(...list.map((r) => r.y + r.height)) - y };
+}
+function normalizePlan(plan) {
+  if (!plan) return null;
+  if (Array.isArray(plan)) return plan.length ? { steps: plan } : null;
+  return plan.steps?.length || plan.surface || plan.readOnly !== void 0 ? plan : null;
+}
+var isErrorResult = (value) => !!value && typeof value === "object" && value.isError === true;
+var center = (r) => ({ x: r.x + r.width / 2, y: r.y + r.height / 2 });
+var finiteRect = (r) => r && [r.x, r.y, r.width, r.height].every(Number.isFinite) ? r : null;
+var GLANCE_STEPS = /* @__PURE__ */ new Set(["move", "target", "focus", "say", "wait", "commit"]);
+var AgentPlayback = class {
+  /** 1 = natural pace; `Infinity` plays nothing (calls run instantly). Takes effect on the next step. */
+  speed;
+  reads;
+  clock;
+  linger;
+  defaultActor;
+  surfaces = /* @__PURE__ */ new Map();
+  actors = /* @__PURE__ */ new Map();
+  recordings = /* @__PURE__ */ new Set();
+  installed = /* @__PURE__ */ new WeakSet();
+  listeners = /* @__PURE__ */ new Set();
+  generation = 0;
+  running = 0;
+  calls = 0;
+  constructor(options = {}) {
+    this.clock = options.clock ?? realPresenceClock;
+    this.speed = options.speed ?? 1;
+    this.reads = options.reads ?? "glance";
+    this.linger = options.linger ?? 1500;
+    this.defaultActor = options.actor ?? { id: "agent", name: "Agent" };
+  }
+  /** The registry middleware that plays each call. */
+  middleware = (call, next) => this.perform(call, next);
+  /** Adds the middleware to `registry` once (later calls with the same registry do nothing). */
+  install(registry) {
+    if (this.installed.has(registry)) return;
+    this.installed.add(registry);
+    registry.use(this.middleware);
+  }
+  /** Whether a performance is playing now (e.g. to make the editor read-only meanwhile). */
+  get active() {
+    return this.running > 0;
+  }
+  /** Called when `active` changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Attaches a surface under a provider id (or the id providers name as `playbackSurface`). */
+  attach(id, surface) {
+    this.surfaces.set(id, surface);
+    return () => {
+      if (this.surfaces.get(id) !== surface) return;
+      this.surfaces.delete(id);
+      for (const actor of this.actors.values()) if (actor.surface === id) actor.surface = void 0;
+    };
+  }
+  /** The surface attached under `id`. */
+  surface(id) {
+    return this.surfaces.get(id);
+  }
+  /** Shows `text` in the actor's bubble on the surface it last worked on (until its next step). */
+  say(text, options = {}) {
+    const actor = this.actorState(options.actor);
+    const surface = actor.surface ? this.surfaces.get(actor.surface) : void 0;
+    if (surface?.presence.get(actor.info.id)) surface.presence.set({ id: actor.info.id, message: text });
+  }
+  /** Finishes every running performance at once (the calls still run and keep their results). */
+  stop() {
+    this.generation++;
+  }
+  /** Collects every step played from now on (for tests). */
+  record() {
+    const list = [];
+    this.recordings.add(list);
+    return list;
+  }
+  actorState(info) {
+    const base = info ?? this.defaultActor;
+    let actor = this.actors.get(base.id);
+    if (!actor) {
+      actor = { info: { ...base, color: base.color ?? PRESENCE_COLORS[this.actors.size % PRESENCE_COLORS.length] }, queue: Promise.resolve(), version: 0 };
+      this.actors.set(base.id, actor);
+    } else if (info?.name && info.name !== actor.info.name) actor.info = { ...actor.info, name: info.name };
+    return actor;
+  }
+  enqueue(actor, run) {
+    const result = actor.queue.then(run);
+    actor.queue = result.catch(() => void 0);
+    return result;
+  }
+  surfaceFor(provider, hint) {
+    for (const id of [hint, provider.playbackSurface, provider.id, provider.namespace]) {
+      const surface = id ? this.surfaces.get(id) : void 0;
+      if (id && surface) return [id, surface];
+    }
+    return null;
+  }
+  async perform(call, next) {
+    const tool = call.tool;
+    if (tool.playback === false || !Number.isFinite(this.speed)) return next();
+    const actor = this.actorState(call.context.actor);
+    if (tool.playback === "self") return this.enqueue(actor, next);
+    const fallback = this.surfaceFor(call.provider);
+    let planned = null;
+    if (tool.plan) {
+      try {
+        const state = {
+          surfaceId: fallback?.[0] ?? null,
+          locate: (ref) => fallback?.[1].locate?.(ref) ?? null
+        };
+        planned = normalizePlan(tool.plan(call.args, state));
+      } catch {
+        planned = null;
+      }
+    }
+    const readOnly = planned?.readOnly ?? tool.annotations?.readOnlyHint === true;
+    if (readOnly && this.reads === "skip") return next();
+    const found = this.surfaceFor(call.provider, planned?.surface);
+    if (!found) return next();
+    const [surfaceId, surface] = found;
+    const steps = planned?.steps?.length ? planned.steps : derivePlaybackSteps(call.args, surface.defaultKind);
+    const glance = readOnly && this.reads === "glance";
+    const played = glance ? steps.filter((s) => GLANCE_STEPS.has(s.type)) : steps;
+    if (!played.some((s) => s.type !== "commit")) return next();
+    return this.enqueue(actor, async () => {
+      if (surface.visible && !surface.visible()) {
+        await surface.reveal?.();
+        if (surface.visible && !surface.visible()) return next();
+      }
+      return this.play({ call, next, actor, surfaceId, surface, steps: played, readOnly, glance });
+    });
+  }
+  async play(run) {
+    const { call, next, actor, surfaceId, surface, readOnly } = run;
+    const id = actor.info.id;
+    const gen = this.generation;
+    const instant = () => gen !== this.generation || !Number.isFinite(this.speed);
+    const pace = () => Math.max(0.1, this.speed) * (run.glance ? 1.6 : 1);
+    const wait = (ms) => instant() || ms <= 0 ? Promise.resolve() : this.clock.wait(ms / pace());
+    const presence = surface.presence;
+    const locate = (ref) => finiteRect(surface.locate?.(ref.kind === "item" ? { kind: surface.defaultKind ?? "item", id: ref.id } : ref) ?? null);
+    const record = (step) => {
+      for (const list of this.recordings) list.push({ actor: id, surface: surfaceId, tool: call.name, step });
+    };
+    this.running++;
+    if (this.running === 1) this.listeners.forEach((l) => l());
+    try {
+      if (actor.surface && actor.surface !== surfaceId) this.surfaces.get(actor.surface)?.presence.remove(id);
+      if (!presence.get(id)) {
+        const bounds = surface.bounds?.() ?? null;
+        let at = actor.viewport && surface.fromViewport ? surface.fromViewport(actor.viewport) : null;
+        if (at && bounds) at = { x: Math.min(bounds.x + bounds.width, Math.max(bounds.x, at.x)), y: Math.min(bounds.y + bounds.height, Math.max(bounds.y, at.y)) };
+        at ??= bounds ? { x: bounds.x + bounds.width - 48, y: bounds.y + 32 } : null;
+        if (!at) {
+          const first = run.steps.find((s) => s.type === "move" || s.type === "target" || s.type === "drag");
+          const rect = first?.type === "target" ? locate(first.ref) : null;
+          at = first && first.type !== "target" ? first.to : rect ? center(rect) : { x: 0, y: 0 };
+        }
+        presence.set({ id, name: actor.info.name ?? id, color: actor.info.color, x: at.x, y: at.y, pressed: false });
+      } else presence.set({ id, name: actor.info.name ?? id, color: actor.info.color });
+      actor.surface = surfaceId;
+      actor.version++;
+      const argRefs = playbackRefsFromArgs(call.args, surface.defaultKind);
+      if (!readOnly) surface.beginGesture?.(`agent:${id}:${++this.calls}`);
+      let result;
+      let committed = false;
+      try {
+        for (const step of run.steps) {
+          record(step);
+          if (step.type === "commit") {
+            if (committed) continue;
+            committed = true;
+            result = await next();
+            continue;
+          }
+          if (step.type === "open") {
+            if (!surface.open) continue;
+            const rect = locate(step.ref);
+            if (rect) {
+              await this.glide(presence, id, { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 }, step.ms, instant);
+              presence.set({ id, pressed: true });
+              await wait(90);
+            }
+            await surface.open(step.ref);
+            presence.set({ id, pressed: false });
+            await wait(220);
+            continue;
+          }
+          await this.step(presence, locate, id, step, wait, instant);
+        }
+        if (!committed) {
+          record({ type: "commit" });
+          result = await next();
+        }
+      } catch (error) {
+        presence.set({ id, pressed: false, message: `\u2717 ${error instanceof Error ? error.message : String(error)}`.slice(0, 140) });
+        await wait(900);
+        throw error;
+      } finally {
+        if (!readOnly) surface.endGesture?.();
+        presence.set({ id, pressed: false });
+      }
+      if (isErrorResult(result)) {
+        const text = result.content?.find((c) => c.type === "text")?.text ?? "The tool failed.";
+        presence.set({ id, message: `\u2717 ${text}`.slice(0, 140) });
+        await wait(900);
+      } else if (!readOnly) {
+        const known = new Set(argRefs.map((r) => `${r.kind}:${r.id}`));
+        const fresh = playbackRefsFromResult(result, surface.defaultKind).filter((r) => !known.has(`${r.kind}:${r.id}`));
+        const rect = unionRects(fresh.slice(0, 16).map(locate));
+        if (rect) {
+          const step = { type: "focus", rect };
+          record(step);
+          presence.set({ id, focus: rect });
+          await wait(450);
+        }
+      }
+      presence.set({ id, message: void 0, focus: void 0 });
+      const here = presence.get(id);
+      if (here && surface.toViewport) actor.viewport = surface.toViewport({ x: here.x, y: here.y });
+      this.scheduleLinger(actor, surface);
+      return result;
+    } finally {
+      this.running--;
+      if (this.running === 0) this.listeners.forEach((l) => l());
+    }
+  }
+  scheduleLinger(actor, surface) {
+    if (this.linger <= 0) return;
+    const version = actor.version;
+    void this.clock.wait(this.linger).then(() => {
+      if (actor.version !== version) return;
+      surface.presence.remove(actor.info.id);
+      for (const [sid, s] of this.surfaces) if (s === surface && actor.surface === sid) actor.surface = void 0;
+    });
+  }
+  async step(presence, locate, id, step, wait, instant) {
+    switch (step.type) {
+      case "move":
+        return this.glide(presence, id, step.to, step.ms, instant);
+      case "drag":
+        presence.set({ id, pressed: true });
+        return this.glide(presence, id, step.to, step.ms, instant);
+      case "target": {
+        const rect = locate(step.ref);
+        if (!rect) return;
+        await this.glide(presence, id, center(rect), step.ms, instant);
+        presence.set({ id, focus: rect });
+        return;
+      }
+      case "focus":
+        presence.set({ id, focus: step.rect ?? void 0 });
+        return;
+      case "say":
+        presence.set({ id, message: step.text });
+        return wait(step.ms ?? readingTime(step.text));
+      case "press":
+        presence.set({ id, pressed: true });
+        return wait(90);
+      case "release":
+        presence.set({ id, pressed: false });
+        return wait(60);
+      case "type": {
+        const total = step.ms ?? Math.min(900, 40 * step.text.length + 150);
+        if (instant() || !(total > 0) || !Number.isFinite(total)) {
+          presence.set({ id, message: step.text });
+          return;
+        }
+        const start = this.clock.now();
+        for (; ; ) {
+          const t = Math.min(1, (this.clock.now() - start) / (total / Math.max(0.1, this.speed)));
+          presence.set({ id, message: step.text.slice(0, Math.max(1, Math.round(step.text.length * t))) });
+          if (t >= 1 || instant()) break;
+          await this.clock.wait(16);
+        }
+        presence.set({ id, message: step.text });
+        return;
+      }
+      case "wait":
+        return wait(step.ms);
+    }
+  }
+  /** Glides along a slight arc with ease-out, by elapsed time (fewer frames in a throttled tab, never longer). */
+  async glide(presence, id, to, ms, instant) {
+    if (!Number.isFinite(to.x) || !Number.isFinite(to.y)) return;
+    const a = presence.get(id);
+    const from = a && Number.isFinite(a.x) && Number.isFinite(a.y) ? { x: a.x, y: a.y } : to;
+    const dist = Math.hypot(to.x - from.x, to.y - from.y);
+    const duration = (ms ?? Math.min(900, 260 + dist * 0.5)) / Math.max(0.1, this.speed);
+    if (instant() || dist < 1 || !(duration > 0) || !Number.isFinite(duration)) {
+      presence.set({ id, x: to.x, y: to.y });
+      return;
+    }
+    const bend = Math.min(60, dist * 0.12);
+    const ctrl = { x: (from.x + to.x) / 2 - (to.y - from.y) / dist * bend, y: (from.y + to.y) / 2 + (to.x - from.x) / dist * bend };
+    const start = this.clock.now();
+    for (; ; ) {
+      const t = Math.min(1, (this.clock.now() - start) / duration);
+      const e = 1 - Math.pow(1 - t, 3);
+      const u = 1 - e;
+      presence.set({ id, x: u * u * from.x + 2 * u * e * ctrl.x + e * e * to.x, y: u * u * from.y + 2 * u * e * ctrl.y + e * e * to.y });
+      if (t >= 1) break;
+      if (instant()) {
+        presence.set({ id, x: to.x, y: to.y });
+        break;
+      }
+      await this.clock.wait(16);
+    }
+  }
+};
+function createAgentPlayback(options = {}) {
+  return new AgentPlayback(options);
+}
+
+export {
+  playbackRefsFromArgs,
+  playbackRefsFromResult,
+  derivePlaybackSteps,
+  readingTime,
+  unionRects,
+  AgentPlayback,
+  createAgentPlayback
+};

package/dist/{chunk-E747F3D5.js → chunk-CC6WKVIH.js}

@@ -8,6 +8,7 @@ import {
   formatIsoDate,
   formatIsoDateTime,
   formatTextFunction,
+  indexToColName,
   isBlank,
   isFormulaError,
   isoDateHasTime,
@@ -2947,16 +2948,16 @@ var FormulaEvaluator = class {
     const value = this.evaluateNode(argument);
     if (!Array.isArray(value)) return value;
     if (value.length <= 1) return firstValue(value);
-    const cell = this.context.getFormulaCell?.();
-    if (argument.type === "Range" && cell) {
+    const cell2 = this.context.getFormulaCell?.();
+    if (argument.type === "Range" && cell2) {
       const range = toFormulaRange(value);
       const top = Math.min(argument.startRow, argument.endRow);
       const left = Math.min(colNameToIndex(argument.startCol), colNameToIndex(argument.endCol));
       if (range.cols === 1) {
-        const r = cell.row - top;
+        const r = cell2.row - top;
         if (r >= 0 && r < range.rows) return range.values[r];
       } else if (range.rows === 1) {
-        const c = colNameToIndex(cell.col) - left;
+        const c = colNameToIndex(cell2.col) - left;
         if (c >= 0 && c < range.cols) return range.values[c];
       }
       return this.fail("#VALUE!", `The @ operator found no cell of ${argument.raw} in the formula's row or column.`);
@@ -3757,6 +3758,84 @@ function getFillDirection(source, target) {
   return null;
 }
 
+// src/spreadsheet/playback.ts
+var CELL = /^\s*\$?([A-Za-z]{1,3})\$?(\d+)\s*$/;
+var COL = /^\s*([A-Za-z]{1,3})\s*$/;
+var ROW = /^\s*(\d+)\s*$/;
+function parseSpreadsheetPlaybackRef(ref) {
+  const [a, b = a] = ref.id.split(":");
+  if (!a) return null;
+  if (ref.kind === "cell") {
+    const s = CELL.exec(a);
+    const e = CELL.exec(b);
+    if (!s || !e) return null;
+    const r = [Number(s[2]) - 1, Number(e[2]) - 1];
+    const c = [colNameToIndex(s[1].toUpperCase()), colNameToIndex(e[1].toUpperCase())];
+    return { startRow: Math.min(r[0], r[1]), endRow: Math.max(r[0], r[1]), startCol: Math.min(c[0], c[1]), endCol: Math.max(c[0], c[1]) };
+  }
+  if (ref.kind === "row") {
+    const s = ROW.exec(a);
+    const e = ROW.exec(b);
+    if (!s || !e) return null;
+    return { startRow: Math.min(+s[1], +e[1]) - 1, endRow: Math.max(+s[1], +e[1]) - 1, startCol: null, endCol: null };
+  }
+  if (ref.kind === "column") {
+    const s = COL.exec(a);
+    const e = COL.exec(b);
+    if (!s || !e) return null;
+    const c = [colNameToIndex(s[1].toUpperCase()), colNameToIndex(e[1].toUpperCase())];
+    return { startRow: null, endRow: null, startCol: Math.min(c[0], c[1]), endCol: Math.max(c[0], c[1]) };
+  }
+  return null;
+}
+var cell = (id) => ({ kind: "cell", id });
+var shown = (v) => {
+  if (v === null || v === void 0 || v === "") return null;
+  const text = String(v);
+  return text.length > 40 ? `${text.slice(0, 39)}\u2026` : text;
+};
+function planSpreadsheetToolPlayback(tool, args) {
+  const count = Number.isInteger(args.count) && args.count > 0 ? args.count : 1;
+  switch (tool) {
+    case "set_cell": {
+      if (typeof args.cell !== "string") return null;
+      const value = shown(args.value);
+      return [{ type: "target", ref: cell(args.cell) }, { type: "press" }, { type: "release" }, ...value ? [{ type: "type", text: value }] : []];
+    }
+    case "set_range": {
+      const start = typeof args.start === "string" ? CELL.exec(args.start) : null;
+      const rows = Array.isArray(args.values) ? args.values : [];
+      if (!start || !rows.length) return null;
+      const width = Math.max(1, ...rows.map((r) => Array.isArray(r) ? r.length : 1));
+      const col = colNameToIndex(start[1].toUpperCase());
+      const end = `${indexToColName(col + width - 1)}${Number(start[2]) + rows.length - 1}`;
+      const first = shown(rows.flat().find((v) => v !== null && v !== void 0 && v !== ""));
+      return [
+        { type: "target", ref: cell(args.start) },
+        { type: "press" },
+        { type: "target", ref: cell(`${args.start}:${end}`) },
+        { type: "release" },
+        ...first ? [{ type: "type", text: first }] : []
+      ];
+    }
+    case "insert_rows":
+    case "delete_rows": {
+      const from = Number(tool === "insert_rows" ? args.before : args.start);
+      if (!Number.isInteger(from) || from < 1) return null;
+      return [{ type: "target", ref: { kind: "row", id: `${from}:${from + count - 1}` } }, { type: "press" }, { type: "release" }];
+    }
+    case "insert_columns":
+    case "delete_columns": {
+      const from = String(tool === "insert_columns" ? args.before : args.start ?? "");
+      if (!COL.test(from)) return null;
+      const index = colNameToIndex(from.trim().toUpperCase());
+      return [{ type: "target", ref: { kind: "column", id: `${indexToColName(index)}:${indexToColName(index + count - 1)}` } }, { type: "press" }, { type: "release" }];
+    }
+    default:
+      return null;
+  }
+}
+
 export {
   tokenizeFormula,
   WHOLE_COLUMN_END_ROW,
@@ -3794,5 +3873,7 @@ export {
   roundFloat,
   fillSeries,
   computeFillTarget,
-  getFillDirection
+  getFillDirection,
+  parseSpreadsheetPlaybackRef,
+  planSpreadsheetToolPlayback
 };