@weasel-js/core 1.9.4 → 1.10.0

package/dist/core/scene/recorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.js","names":["unwind","i","outer","createRecorder","env","collecting","captured","withArrivalsSettled","result","fn","owns","p","arrivals","batch","outermost","mode","ownsArrivals","notifier","log","err","finished","engine","kind","payload","label","touchesLayout","versionBefore","into","mark","op","ops","before","adapter","bindOpToAdapter","enclosing","step"],"sources":["../../../src/core/scene/recorder.ts"],"sourcesContent":["/**\n * How a scene mutation becomes an undo entry: recorded on its own, collected\n * into the batch it runs in, or left to the engine or the untracked run that\n * is driving it.\n */\nimport type { History } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport type { AppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { bindOpToAdapter } from './boundOps';\nimport type { EditMode } from './editMode';\nimport type { Notifier } from './notifier';\nimport type { NodeId } from './types';\n\n/** What the recorder needs from the scene it records for. */\nexport interface RecorderEnv {\n  notifier: Notifier;\n  mode: EditMode;\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Apply a registered op's forward half. */\n  runOp(kind: string, payload: unknown): void;\n  /** A registered op as the engine holds it. */\n  makeOp(kind: string, payload: unknown): Op;\n  log: AppliedLog;\n  arrivals: Pick<ArrivalWindow<unknown>, 'bareLayoutEdit' | 'open' | 'settle' | 'emitReflow' | 'abandon'>;\n  selection(): readonly NodeId[];\n  /** Write one pose an arrival settle decided. */\n  writePose(id: string, pose: unknown): void;\n}\n\nexport interface Recorder {\n  /** Apply a registered op as part of whatever edit is running. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run the recording half of a mutation. One that touches a laid-out\n   *  container, called bare, runs as a batch of its own: that is what puts\n   *  the arrangement it triggers in the same undo step. */\n  edit<T>(label: string, touchesLayout: boolean, fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  untracked<T>(fn: () => T): T;\n  /** Whether an edit made now would join an open `batch`'s entry. */\n  joins(): boolean;\n  /** Apply ops built outside the scene as part of the open `batch`, all or\n   *  none. Its entry holds the kit ops they cause, and beside them, bound to\n   *  `adapter`, any op that wrote no scene state. */\n  join(ops: Op[], adapter: unknown): void;\n  /** Run `step`, and answer with the kit ops applied during it. */\n  capturing<T>(step: () => T): { result: T; ops: Op[] };\n  /** Run `fn` as a history engine's step: the ops it applies may re-enter\n   *  scene mutation methods, which apply but do not record. The caller\n   *  notifies once after. */\n  engineDriven<T>(fn: () => T): T;\n}\n\n/** Take back ops that wrote outside the scene, newest first. The scene's own\n *  writes are reverted by the applied log. */\nfunction unwind(outer: readonly Op[]): void {\n  for (let i = outer.length - 1; i >= 0; i--) {\n    try {\n      outer[i].invert().apply(undefined);\n    } catch {\n      // The throw being unwound is the one the caller sees.\n    }\n  }\n}\n\nexport function createRecorder(env: RecorderEnv): Recorder {\n  const { notifier, mode, engine, log, arrivals } = env;\n  /** The outermost open batch, while it is recording. */\n  let collecting: { label: string; ops: Op[]; outer: Op[]; selectionBefore: readonly NodeId[] } | null = null;\n  /** The kit ops applied since the innermost `capturing` opened. */\n  let captured: Op[] | null = null;\n\n  /** `fn`, then the poses its arrivals settle to when this edit owns them. */\n  function withArrivalsSettled<T>(fn: () => T, owns: boolean): T {\n    const result = fn();\n    if (owns) for (const p of arrivals.settle()) env.writePose(p.id, p.to);\n    return result;\n  }\n\n  function batch<T>(label: string, fn: () => T): T {\n    const outermost = !mode.open();\n    // Captured at open, not at recordEntry: by the time the batch closes\n    // the selection has already moved to wherever the batch put it.\n    if (outermost) collecting = { label, ops: [], outer: [], selectionBefore: env.selection() };\n    const ownsArrivals = outermost && arrivals.open(true);\n    return notifier.deferred(() => mode.during('batch', () => {\n      if (!outermost) return fn();\n      try {\n        const result = log.atomically(\n          () => withArrivalsSettled(fn, ownsArrivals),\n          () => (collecting?.ops.length ?? 0) > 0,\n        );\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      } catch (err) {\n        // Reverted already; the half-built entry must not reach history.\n        unwind(collecting?.outer ?? []);\n        collecting = null;\n        throw err;\n      }\n    }), () => {\n      if (ownsArrivals) arrivals.abandon();\n      if (!outermost || !collecting) return;\n      const finished = collecting;\n      collecting = null;\n      // The ops were applied as they were issued, so the entry is pushed\n      // without re-applying.\n      if (finished.ops.length > 0) {\n        engine.recordEntry(finished.ops, finished.label, { selectionBefore: finished.selectionBefore });\n      }\n    });\n  }\n\n  return {\n    record(kind, payload, label) {\n      if (mode.records() && !collecting) {\n        // The engine applies the op itself, which is what lets it coalesce.\n        mode.during('own', () => engine.applyOps([env.makeOp(kind, payload)], label));\n      } else {\n        env.runOp(kind, payload);\n        log.logApplied(kind, payload);\n        if (mode.records()) collecting!.ops.push(env.makeOp(kind, payload));\n        else if (!mode.untracked()) captured?.push(env.makeOp(kind, payload));\n      }\n      notifier.notify();\n    },\n    edit: (label, touchesLayout, fn) => (touchesLayout && arrivals.bareLayoutEdit() ? batch(label, fn) : fn()),\n    batch,\n    untracked(fn) {\n      const versionBefore = notifier.version();\n      const ownsArrivals = arrivals.open(true);\n      return notifier.deferred(() => mode.during('untracked', () => {\n        const result = log.atomically(() => withArrivalsSettled(fn, ownsArrivals), () => false);\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      }), () => {\n        if (ownsArrivals) arrivals.abandon();\n        if (notifier.version() !== versionBefore) engine.seal();\n      });\n    },\n    joins: () => mode.records() && collecting !== null,\n    join(ops, adapter) {\n      const into = collecting!;\n      const mark = into.ops.length;\n      const outer: Op[] = [];\n      try {\n        log.atomically(() => {\n          for (const op of ops) {\n            const before = into.ops.length;\n            const result = op.apply(adapter);\n            if (into.ops.length > before || result === false || result === 'noop') continue;\n            outer.push(bindOpToAdapter(op, adapter));\n            into.ops.push(outer[outer.length - 1]);\n          }\n        }, () => false);\n      } catch (err) {\n        unwind(outer);\n        into.ops.length = mark;\n        throw err;\n      }\n      into.outer.push(...outer);\n    },\n    capturing(step) {\n      const enclosing = captured;\n      const ops: Op[] = [];\n      captured = ops;\n      try {\n        return { result: step(), ops };\n      } finally {\n        captured = enclosing;\n      }\n    },\n    engineDriven: (fn) => mode.during('engine', () => notifier.muted(fn)),\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/renderOrder.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderOrder.js","names":["createRenderOrder","walkIds","state","renderOrderFlat","renderOrderBucketed","walkNodes","renderOrderNodesFlat","renderOrderNodesBucketed","structureGeneration","orderCache","invalidate","EMPTY_NODES","currentOrderCache","only","out","stack","id","node","i","buckets","bucket","c","byLayer","layer"],"sources":["../../../src/core/scene/renderOrder.ts"],"sourcesContent":["/**\n * A scene's render order: its nodes layer-major, each layer in tree preorder,\n * cached until the structure changes.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the walks read of a scene's state. */\nexport interface RenderOrderState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: { id: TLayer }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface RenderOrder<TData, TLayer extends string, TPose> {\n  ids(): NodeId[];\n  nodes(): Node<TData, TLayer, TPose>[];\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n  /** Call on every structural edit; see the cache note below. */\n  invalidate(): void;\n}\n\nexport function createRenderOrder<TData, TLayer extends string, TPose>(\n  state: RenderOrderState<TData, TLayer, TPose>,\n): RenderOrder<TData, TLayer, TPose> {\n  /**\n   * Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks\n   * for two sequences, which wants explaining, because collapsing them is the\n   * obvious cleanup and each collapse was measured to cost something:\n   *\n   * - ids vs nodes: projecting one from the other is a whole extra pass, worth\n   *   20% of `renderOrder()` on a multi-layer scene.\n   * - flat vs bucketed: a single layer needs no buckets and can compare the\n   *   layer id instead of indexing it, which is 1.4x. Behind a branch in one\n   *   function it also slows the bucketed path by 20% — the two shapes share\n   *   one optimized body, and whichever ran first wins it.\n   *\n   * All four emit the same order and `renderOrder.test.ts` holds them to it.\n   */\n  function walkIds(): NodeId[] {\n    return state.layers.length === 1 ? renderOrderFlat() : renderOrderBucketed();\n  }\n\n  function walkNodes(): Node<TData, TLayer, TPose>[] {\n    return state.layers.length === 1 ? renderOrderNodesFlat() : renderOrderNodesBucketed();\n  }\n\n  /**\n   * Render order survives everything except a structural edit, so both walks\n   * are cached against a counter the structural writers bump: `attach` and\n   * `detach` (add / remove / reparent / reorder), `kit:setLayer` (which bucket\n   * a node lands in), `rebuildLayerIndex` (the layer list itself), and\n   * `loadState`. Pose and data edits leave order alone and must NOT invalidate\n   * — they fire per frame during a drag, which is exactly when the cache pays.\n   *\n   * A missed bump is a silent wrong answer: nodes painted in the wrong z-order,\n   * or unpickable. `renderOrder.test.ts` walks each structural op and asserts\n   * the order moved.\n   */\n  let structureGeneration = 0;\n  let orderCache: {\n    gen: number;\n    ids?: NodeId[];\n    nodes?: Node<TData, TLayer, TPose>[];\n    byLayer?: Map<TLayer, Node<TData, TLayer, TPose>[]>;\n  } = { gen: 0 };\n\n  function invalidate(): void {\n    structureGeneration++;\n  }\n\n  const EMPTY_NODES: readonly Node<TData, TLayer, TPose>[] = [];\n\n  function currentOrderCache(): typeof orderCache {\n    if (orderCache.gen !== structureGeneration) {\n      orderCache = { gen: structureGeneration };\n    }\n    return orderCache;\n  }\n\n  function renderOrderFlat(): NodeId[] {\n    const only = state.layers[0].id;\n    const out: NodeId[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  function renderOrderNodesFlat(): Node<TData, TLayer, TPose>[] {\n    const only = state.layers[0].id;\n    const out: Node<TData, TLayer, TPose>[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  /** One DFS of the tree, bucketed by layer: appending in preorder keeps each\n   *  bucket in preorder, so concatenating them is the layer-major sequence. */\n  function renderOrderBucketed(): NodeId[] {\n    const buckets: NodeId[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: NodeId[] = [];\n    for (const bucket of buckets) {\n      for (const id of bucket) out.push(id);\n    }\n    return out;\n  }\n\n  function renderOrderNodesBucketed(): Node<TData, TLayer, TPose>[] {\n    const buckets: Node<TData, TLayer, TPose>[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: Node<TData, TLayer, TPose>[] = [];\n    for (const bucket of buckets) {\n      for (const node of bucket) out.push(node);\n    }\n    return out;\n  }\n\n  return {\n    ids() {\n      const c = currentOrderCache();\n      return (c.ids ??= walkIds());\n    },\n    nodes() {\n      const c = currentOrderCache();\n      return (c.nodes ??= walkNodes());\n    },\n    nodesOnLayer(layer) {\n      const c = currentOrderCache();\n      let byLayer = c.byLayer;\n      if (!byLayer) {\n        byLayer = new Map();\n        for (const node of (c.nodes ??= walkNodes())) {\n          let bucket = byLayer.get(node.layer);\n          if (!bucket) byLayer.set(node.layer, (bucket = []));\n          bucket.push(node);\n        }\n        c.byLayer = byLayer;\n      }\n      return byLayer.get(layer) ?? EMPTY_NODES;\n    },\n    invalidate,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"renderOrder.js","names":["createRenderOrder","walkIds","state","renderOrderFlat","renderOrderBucketed","walkNodes","renderOrderNodesFlat","renderOrderNodesBucketed","structureGeneration","orderCache","invalidate","EMPTY_NODES","currentOrderCache","only","out","stack","id","node","i","buckets","bucket","c","byLayer","layer"],"sources":["../../../src/core/scene/renderOrder.ts"],"sourcesContent":["/**\n * A scene's render order: its nodes layer-major, each layer in tree preorder,\n * cached until the structure changes.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the walks read of a scene's state. */\nexport interface RenderOrderState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: { id: TLayer }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface RenderOrder<TData, TLayer extends string, TPose> {\n  ids(): NodeId[];\n  nodes(): Node<TData, TLayer, TPose>[];\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n  /** Call on every structural edit; see the cache note below. */\n  invalidate(): void;\n}\n\nexport function createRenderOrder<TData, TLayer extends string, TPose>(\n  state: RenderOrderState<TData, TLayer, TPose>,\n): RenderOrder<TData, TLayer, TPose> {\n  /**\n   * Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks\n   * for two sequences, which wants explaining, because collapsing them is the\n   * obvious cleanup and each collapse was measured to cost something:\n   *\n   * - ids vs nodes: projecting one from the other is a whole extra pass, worth\n   *   20% of `renderOrder()` on a multi-layer scene.\n   * - flat vs bucketed: a single layer needs no buckets and can compare the\n   *   layer id instead of indexing it, which is 1.4x. Behind a branch in one\n   *   function it also slows the bucketed path by 20% — the two shapes share\n   *   one optimized body, and whichever ran first wins it.\n   *\n   * All four emit the same order and `renderOrder.test.ts` holds them to it.\n   */\n  function walkIds(): NodeId[] {\n    return state.layers.length === 1 ? renderOrderFlat() : renderOrderBucketed();\n  }\n\n  function walkNodes(): Node<TData, TLayer, TPose>[] {\n    return state.layers.length === 1 ? renderOrderNodesFlat() : renderOrderNodesBucketed();\n  }\n\n  /**\n   * Render order survives everything except a structural edit, so both walks\n   * are cached against a counter the structural writers bump. Pose and data\n   * edits leave order alone and must NOT invalidate — they fire per frame\n   * during a drag, which is exactly when the cache pays.\n   *\n   * A missed bump is a silent wrong answer: nodes painted in the wrong z-order,\n   * or unpickable. `renderOrder.test.ts` walks each structural op and asserts\n   * the order moved.\n   */\n  let structureGeneration = 0;\n  let orderCache: {\n    gen: number;\n    ids?: NodeId[];\n    nodes?: Node<TData, TLayer, TPose>[];\n    byLayer?: Map<TLayer, Node<TData, TLayer, TPose>[]>;\n  } = { gen: 0 };\n\n  function invalidate(): void {\n    structureGeneration++;\n  }\n\n  const EMPTY_NODES: readonly Node<TData, TLayer, TPose>[] = [];\n\n  function currentOrderCache(): typeof orderCache {\n    if (orderCache.gen !== structureGeneration) {\n      orderCache = { gen: structureGeneration };\n    }\n    return orderCache;\n  }\n\n  function renderOrderFlat(): NodeId[] {\n    const only = state.layers[0].id;\n    const out: NodeId[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  function renderOrderNodesFlat(): Node<TData, TLayer, TPose>[] {\n    const only = state.layers[0].id;\n    const out: Node<TData, TLayer, TPose>[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  /** One DFS of the tree, bucketed by layer: appending in preorder keeps each\n   *  bucket in preorder, so concatenating them is the layer-major sequence. */\n  function renderOrderBucketed(): NodeId[] {\n    const buckets: NodeId[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: NodeId[] = [];\n    for (const bucket of buckets) {\n      for (const id of bucket) out.push(id);\n    }\n    return out;\n  }\n\n  function renderOrderNodesBucketed(): Node<TData, TLayer, TPose>[] {\n    const buckets: Node<TData, TLayer, TPose>[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: Node<TData, TLayer, TPose>[] = [];\n    for (const bucket of buckets) {\n      for (const node of bucket) out.push(node);\n    }\n    return out;\n  }\n\n  return {\n    ids() {\n      const c = currentOrderCache();\n      return (c.ids ??= walkIds());\n    },\n    nodes() {\n      const c = currentOrderCache();\n      return (c.nodes ??= walkNodes());\n    },\n    nodesOnLayer(layer) {\n      const c = currentOrderCache();\n      let byLayer = c.byLayer;\n      if (!byLayer) {\n        byLayer = new Map();\n        for (const node of (c.nodes ??= walkNodes())) {\n          let bucket = byLayer.get(node.layer);\n          if (!bucket) byLayer.set(node.layer, (bucket = []));\n          bucket.push(node);\n        }\n        c.byLayer = byLayer;\n      }\n      return byLayer.get(layer) ?? EMPTY_NODES;\n    },\n    invalidate,\n  };\n}\n"],"mappings":"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"}