1681-engine 0.0.0-stage → 0.5.8

package/dist/core/Stage.js

@@ -0,0 +1,86 @@
+import { Container as r } from "pixi.js";
+import { Camera as h } from "./Camera.js";
+import { Clock as a } from "./Clock.js";
+import { ObjectFactory as o } from "./ObjectFactory.js";
+import { Pointer as c } from "./Pointer.js";
+import { Tweener as d } from "./Tweener.js";
+class n {
+  constructor(e, t) {
+    this.app = e, this.textures = t, e.stage.addChild(this.world, this.screen), this.cameras = { main: new h(this.world, this.screen) }, this.input = { activePointer: new c(e.canvas) }, this.syncSize();
+  }
+  app;
+  textures;
+  /** Told of every fault a guarded step caught (error telemetry, if the game sets one). */
+  static onCaught = null;
+  world = new r({ sortableChildren: !0 });
+  screen = new r();
+  add = new o(this);
+  tweens = new d();
+  time = new a();
+  cameras;
+  input;
+  resizeListeners = [];
+  lastWidth = 0;
+  lastHeight = 0;
+  get width() {
+    return this.app.screen.width;
+  }
+  get height() {
+    return this.app.screen.height;
+  }
+  get fps() {
+    return this.app.ticker.FPS;
+  }
+  /** Calls `fn` whenever the window changes size; the returned function stops it (a per-map listener must). */
+  onResize(e) {
+    return this.resizeListeners.push(e), () => {
+      const t = this.resizeListeners.indexOf(e);
+      t >= 0 && this.resizeListeners.splice(t, 1);
+    };
+  }
+  /**
+   * One frame: game logic, then tweens and timers, then the camera. Pixi renders after. Each step is guarded: a
+   * ticker listener that throws never asks for the next animation frame, so one bad frame used to stop the world for
+   * good — the canvas frozen and no input reaching the server (seen on Android).
+   */
+  frame(e) {
+    const t = performance.now();
+    this.guard("resize", () => this.syncSize()), this.guard("update", () => this.update(t, e)), this.guard("tweens", () => this.tweens.update(e)), this.guard("timers", () => this.time.update(t)), this.guard("camera", () => this.cameras.main.apply(t));
+  }
+  reported = /* @__PURE__ */ new Set();
+  /**
+   * Runs one step of a frame and swallows what it throws, so the steps after it still run. Subclasses guard the parts
+   * of their own `update` too: a fault before the camera follows the player used to leave the view standing on one
+   * spot while the world went on.
+   */
+  guard(e, t) {
+    this.guarded(e, t, void 0);
+  }
+  /** `guard` for a step that answers something: `fallback` when it threw. */
+  guarded(e, t, i) {
+    try {
+      return t();
+    } catch (s) {
+      return this.caught(e, s), i;
+    }
+  }
+  /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */
+  caught(e, t) {
+    const i = `${e}|${t instanceof Error ? t.message : String(t)}`;
+    this.reported.has(i) || (this.reported.add(i), console.error(`[frame] ${e} failed`, t), n.onCaught?.(`[frame] ${e}`, t));
+  }
+  destroy() {
+    this.tweens.clear(), this.time.clear(), this.input.activePointer.destroy(), this.world.destroy({ children: !0, context: !0 }), this.screen.destroy({ children: !0, context: !0 });
+  }
+  syncSize() {
+    const { width: e, height: t } = this.app.screen, i = this.cameras.main;
+    if (i.width = e, i.height = t, !(e === this.lastWidth && t === this.lastHeight)) {
+      this.lastWidth = e, this.lastHeight = t;
+      for (const s of [...this.resizeListeners]) s();
+    }
+  }
+}
+export {
+  n as Stage
+};
+//# sourceMappingURL=Stage.js.map

package/dist/core/Stage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stage.js","sources":["../../src/core/Stage.ts"],"sourcesContent":["import { Container, type Application } from 'pixi.js';\nimport { Camera } from './Camera';\nimport { Clock } from './Clock';\nimport { ObjectFactory } from './ObjectFactory';\nimport { Pointer } from './Pointer';\nimport type { TextureRegistry } from './TextureRegistry';\nimport { Tweener } from './Tweener';\n\n/**\n * What a world object is created in: a world layer the camera moves (children sorted by depth), a screen layer\n * above it, and the per-frame services (tweens, timers, camera, pointer). Subclasses implement `update`.\n */\nexport abstract class Stage {\n  /** Told of every fault a guarded step caught (error telemetry, if the game sets one). */\n  static onCaught: ((where: string, err: unknown) => void) | null = null;\n\n  readonly world = new Container({ sortableChildren: true });\n  readonly screen = new Container();\n  readonly add = new ObjectFactory(this);\n  readonly tweens = new Tweener();\n  readonly time = new Clock();\n  readonly cameras: { main: Camera };\n  readonly input: { activePointer: Pointer };\n  private readonly resizeListeners: (() => void)[] = [];\n  private lastWidth = 0;\n  private lastHeight = 0;\n\n  constructor(\n    readonly app: Application,\n    readonly textures: TextureRegistry,\n  ) {\n    app.stage.addChild(this.world, this.screen);\n    this.cameras = { main: new Camera(this.world, this.screen) };\n    this.input = { activePointer: new Pointer(app.canvas) };\n    this.syncSize();\n  }\n\n  get width(): number {\n    return this.app.screen.width;\n  }\n\n  get height(): number {\n    return this.app.screen.height;\n  }\n\n  get fps(): number {\n    return this.app.ticker.FPS;\n  }\n\n  /** Calls `fn` whenever the window changes size; the returned function stops it (a per-map listener must). */\n  onResize(fn: () => void): () => void {\n    this.resizeListeners.push(fn);\n    return () => {\n      const i = this.resizeListeners.indexOf(fn);\n      if (i >= 0) this.resizeListeners.splice(i, 1);\n    };\n  }\n\n  abstract update(now: number, delta: number): void;\n\n  /**\n   * One frame: game logic, then tweens and timers, then the camera. Pixi renders after. Each step is guarded: a\n   * ticker listener that throws never asks for the next animation frame, so one bad frame used to stop the world for\n   * good — the canvas frozen and no input reaching the server (seen on Android).\n   */\n  frame(delta: number): void {\n    const now = performance.now();\n    this.guard('resize', () => this.syncSize());\n    this.guard('update', () => this.update(now, delta));\n    this.guard('tweens', () => this.tweens.update(delta));\n    this.guard('timers', () => this.time.update(now));\n    this.guard('camera', () => this.cameras.main.apply(now));\n  }\n\n  private readonly reported = new Set<string>();\n\n  /**\n   * Runs one step of a frame and swallows what it throws, so the steps after it still run. Subclasses guard the parts\n   * of their own `update` too: a fault before the camera follows the player used to leave the view standing on one\n   * spot while the world went on.\n   */\n  protected guard(step: string, fn: () => void): void {\n    this.guarded(step, fn, undefined);\n  }\n\n  /** `guard` for a step that answers something: `fallback` when it threw. */\n  protected guarded<T>(step: string, fn: () => T, fallback: T): T {\n    try {\n      return fn();\n    } catch (err) {\n      this.caught(step, err);\n      return fallback;\n    }\n  }\n\n  /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */\n  protected caught(step: string, err: unknown): void {\n    const key = `${step}|${err instanceof Error ? err.message : String(err)}`;\n    if (this.reported.has(key)) return;\n    this.reported.add(key);\n    console.error(`[frame] ${step} failed`, err);\n    // caught here, so the window's error listener never hears of it: tell the telemetry ourselves\n    Stage.onCaught?.(`[frame] ${step}`, err);\n  }\n\n  destroy(): void {\n    this.tweens.clear();\n    this.time.clear();\n    this.input.activePointer.destroy();\n    this.world.destroy({ children: true, context: true });\n    this.screen.destroy({ children: true, context: true });\n  }\n\n  private syncSize(): void {\n    const { width, height } = this.app.screen;\n    const cam = this.cameras.main;\n    cam.width = width;\n    cam.height = height;\n    if (width === this.lastWidth && height === this.lastHeight) return;\n    this.lastWidth = width;\n    this.lastHeight = height;\n    // a copy: a listener may unsubscribe itself (or another) while they run\n    for (const fn of [...this.resizeListeners]) fn();\n  }\n}\n"],"names":["Stage","app","textures","Camera","Pointer","Container","ObjectFactory","Tweener","Clock","fn","i","delta","now","step","fallback","err","key","width","height","cam"],"mappings":"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"}

package/dist/core/Text.js

@@ -0,0 +1,22 @@
+import { Text as e } from "pixi.js";
+import { GameObject as f } from "./gameObject.js";
+class d extends f(e) {
+  constructor(o, t, n, i) {
+    const r = {
+      fontFamily: i.fontFamily ?? "monospace",
+      fontSize: typeof i.fontSize == "string" ? parseFloat(i.fontSize) : i.fontSize,
+      fill: i.color ?? "#ffffff"
+    };
+    i.stroke && (r.stroke = { color: i.stroke, width: i.strokeThickness ?? 1, join: "round" }), i.align && (r.align = i.align), i.lineSpacing !== void 0 && (r.leading = i.lineSpacing), i.wordWrapWidth !== void 0 && (r.wordWrap = !0, r.wordWrapWidth = i.wordWrapWidth), super({ text: n, resolution: i.resolution ?? 1, style: r }), this.position.set(o, t);
+  }
+  setOrigin(o = 0.5, t = o) {
+    return this.anchor.set(o, t), this;
+  }
+  setText(o) {
+    return this.text = o, this;
+  }
+}
+export {
+  d as Text
+};
+//# sourceMappingURL=Text.js.map

package/dist/core/Text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.js","sources":["../../src/core/Text.ts"],"sourcesContent":["import { Text as PixiText, type TextStyleOptions } from 'pixi.js';\nimport { GameObject } from './gameObject';\n\nexport interface TextStyle {\n  fontFamily?: string;\n  fontSize: string | number;\n  color?: string;\n  stroke?: string;\n  strokeThickness?: number;\n  /** Texture pixels per world pixel: world text is zoomed by the camera, so it is rasterised finer. */\n  resolution?: number;\n  align?: 'left' | 'center' | 'right';\n  lineSpacing?: number;\n  wordWrapWidth?: number;\n}\n\n/** Canvas text in world or screen space. */\nexport class Text extends GameObject(PixiText) {\n  constructor(x: number, y: number, text: string, style: TextStyle) {\n    // only keys that are set: an explicit undefined overrides Pixi's default (leading: undefined = NaN height)\n    const pixiStyle: TextStyleOptions = {\n      fontFamily: style.fontFamily ?? 'monospace',\n      fontSize: typeof style.fontSize === 'string' ? parseFloat(style.fontSize) : style.fontSize,\n      fill: style.color ?? '#ffffff',\n    };\n    if (style.stroke) pixiStyle.stroke = { color: style.stroke, width: style.strokeThickness ?? 1, join: 'round' };\n    if (style.align) pixiStyle.align = style.align;\n    if (style.lineSpacing !== undefined) pixiStyle.leading = style.lineSpacing;\n    if (style.wordWrapWidth !== undefined) {\n      pixiStyle.wordWrap = true;\n      pixiStyle.wordWrapWidth = style.wordWrapWidth;\n    }\n    super({ text, resolution: style.resolution ?? 1, style: pixiStyle });\n    this.position.set(x, y);\n  }\n\n  setOrigin(x = 0.5, y = x): this {\n    this.anchor.set(x, y);\n    return this;\n  }\n\n  setText(text: string): this {\n    this.text = text;\n    return this;\n  }\n}\n"],"names":["Text","GameObject","PixiText","x","y","text","style","pixiStyle"],"mappings":";;AAiBO,MAAMA,UAAaC,EAAWC,CAAQ,EAAE;AAAA,EAC7C,YAAYC,GAAWC,GAAWC,GAAcC,GAAkB;AAEhE,UAAMC,IAA8B;AAAA,MAClC,YAAYD,EAAM,cAAc;AAAA,MAChC,UAAU,OAAOA,EAAM,YAAa,WAAW,WAAWA,EAAM,QAAQ,IAAIA,EAAM;AAAA,MAClF,MAAMA,EAAM,SAAS;AAAA,IAAA;AAEvB,IAAIA,EAAM,WAAQC,EAAU,SAAS,EAAE,OAAOD,EAAM,QAAQ,OAAOA,EAAM,mBAAmB,GAAG,MAAM,QAAA,IACjGA,EAAM,UAAOC,EAAU,QAAQD,EAAM,QACrCA,EAAM,gBAAgB,WAAWC,EAAU,UAAUD,EAAM,cAC3DA,EAAM,kBAAkB,WAC1BC,EAAU,WAAW,IACrBA,EAAU,gBAAgBD,EAAM,gBAElC,MAAM,EAAE,MAAAD,GAAM,YAAYC,EAAM,cAAc,GAAG,OAAOC,GAAW,GACnE,KAAK,SAAS,IAAIJ,GAAGC,CAAC;AAAA,EACxB;AAAA,EAEA,UAAUD,IAAI,KAAKC,IAAID,GAAS;AAC9B,gBAAK,OAAO,IAAIA,GAAGC,CAAC,GACb;AAAA,EACT;AAAA,EAEA,QAAQC,GAAoB;AAC1B,gBAAK,OAAOA,GACL;AAAA,EACT;AACF;"}

package/dist/core/TextureRegistry.js

@@ -0,0 +1,111 @@
+import { CanvasSource as m, Texture as d, Rectangle as l } from "pixi.js";
+class v {
+  constructor(t, s) {
+    this.key = t, this.canvas = s, this.source = new m({ resource: s, scaleMode: "nearest" }), this.whole = new d({ source: this.source });
+  }
+  key;
+  canvas;
+  frames = /* @__PURE__ */ new Map();
+  source;
+  whole;
+  get width() {
+    return this.canvas.width;
+  }
+  get height() {
+    return this.canvas.height;
+  }
+  get context() {
+    return this.canvas.getContext("2d");
+  }
+  /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */
+  add(t, s, e, a, o, h) {
+    this.frames.get(t)?.destroy(), this.frames.set(t, new d({ source: this.source, frame: new l(e, a, o, h) }));
+  }
+  /**
+   * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is
+   * found by this texture's key. A texture of its own over the other page's source: each side frees its own.
+   */
+  adopt(t, s) {
+    const e = s.frames.get(t);
+    e && (this.frames.get(t)?.destroy(), this.frames.set(t, new d({ source: s.source, frame: e.frame.clone() })));
+  }
+  refresh() {
+    this.source.update();
+  }
+  destroy() {
+    for (const t of this.frames.values()) t.destroy();
+    this.frames.clear(), this.whole.destroy(), this.source.destroy();
+  }
+}
+class x {
+  textures = /* @__PURE__ */ new Map();
+  /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */
+  live = /* @__PURE__ */ new Set();
+  missing = /* @__PURE__ */ new Set();
+  snapshots = 0;
+  markLive(t) {
+    this.live.add(t);
+  }
+  isLive(t) {
+    return this.live.has(t);
+  }
+  /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */
+  snapshot(t, s) {
+    const e = this.get(t, s), { x: a, y: o, width: h, height: r } = e.frame, i = document.createElement("canvas");
+    i.width = h, i.height = r;
+    const n = this.textures.get(t)?.canvas;
+    n && i.getContext("2d").drawImage(n, a, o, h, r, 0, 0, h, r);
+    const c = `${t}#still${++this.snapshots}`;
+    return this.addCanvas(c, i).add("0", 0, 0, 0, h, r), c;
+  }
+  /**
+   * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only
+   * made anew when the frame's size changes. Frame '0' is the copy.
+   */
+  snapshotInto(t, s, e) {
+    const a = this.get(t, s), { x: o, y: h, width: r, height: i } = a.frame;
+    let n = this.textures.get(e);
+    if (!n || n.width !== r || n.height !== i) {
+      const u = document.createElement("canvas");
+      u.width = r, u.height = i, n = this.addCanvas(e, u), n.add("0", 0, 0, 0, r, i);
+    }
+    const c = n.context;
+    c.clearRect(0, 0, r, i);
+    const g = this.textures.get(t)?.canvas;
+    g && c.drawImage(g, o, h, r, i, 0, 0, r, i), n.refresh();
+  }
+  exists(t) {
+    return this.textures.has(t);
+  }
+  addCanvas(t, s) {
+    this.remove(t);
+    const e = new v(t, s);
+    return this.textures.set(t, e), e;
+  }
+  /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */
+  addSpriteSheet(t, s, e) {
+    const a = this.addCanvas(t, s), o = Math.floor(s.width / e.frameWidth), h = Math.floor(s.height / e.frameHeight);
+    for (let r = 0; r < o * h; r++)
+      a.add(String(r), 0, r % o * e.frameWidth, Math.floor(r / o) * e.frameHeight, e.frameWidth, e.frameHeight);
+    return a;
+  }
+  createCanvas(t, s, e) {
+    const a = document.createElement("canvas");
+    return a.width = s, a.height = e, this.addCanvas(t, a);
+  }
+  remove(t) {
+    this.textures.get(t)?.destroy(), this.textures.delete(t), this.live.delete(t);
+  }
+  get(t, s) {
+    const e = this.textures.get(t);
+    return e ? s === void 0 || s === "" ? e.whole : e.frames.get(String(s)) ?? this.warn(`${t}/${s}`) : this.warn(t);
+  }
+  warn(t) {
+    return this.missing.has(t) || (this.missing.add(t), console.warn(`[textures] missing ${t}`)), d.EMPTY;
+  }
+}
+export {
+  v as CanvasTexture,
+  x as TextureRegistry
+};
+//# sourceMappingURL=TextureRegistry.js.map

package/dist/core/TextureRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureRegistry.js","sources":["../../src/core/TextureRegistry.ts"],"sourcesContent":["import { CanvasSource, Rectangle, Texture } from 'pixi.js';\n\n/** A canvas-backed texture with named frames; repaint the canvas, then `refresh()` to upload it. */\nexport class CanvasTexture {\n  readonly frames = new Map<string, Texture>();\n  readonly source: CanvasSource;\n  readonly whole: Texture;\n\n  constructor(\n    readonly key: string,\n    readonly canvas: HTMLCanvasElement,\n  ) {\n    this.source = new CanvasSource({ resource: canvas, scaleMode: 'nearest' });\n    this.whole = new Texture({ source: this.source });\n  }\n\n  get width(): number {\n    return this.canvas.width;\n  }\n\n  get height(): number {\n    return this.canvas.height;\n  }\n\n  get context(): CanvasRenderingContext2D {\n    return this.canvas.getContext('2d')!;\n  }\n\n  /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */\n  add(name: string, _source: number, x: number, y: number, w: number, h: number): void {\n    this.frames.get(name)?.destroy();\n    this.frames.set(name, new Texture({ source: this.source, frame: new Rectangle(x, y, w, h) }));\n  }\n\n  /**\n   * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is\n   * found by this texture's key. A texture of its own over the other page's source: each side frees its own.\n   */\n  adopt(name: string, from: CanvasTexture): void {\n    const src = from.frames.get(name);\n    if (!src) return;\n    this.frames.get(name)?.destroy();\n    this.frames.set(name, new Texture({ source: from.source, frame: src.frame.clone() }));\n  }\n\n  refresh(): void {\n    this.source.update();\n  }\n\n  destroy(): void {\n    for (const t of this.frames.values()) t.destroy();\n    this.frames.clear();\n    this.whole.destroy();\n    this.source.destroy();\n  }\n}\n\n/** Every texture of the world by key: the sprite atlas and per-player repainted sheets. */\nexport class TextureRegistry {\n  private readonly textures = new Map<string, CanvasTexture>();\n  /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */\n  private readonly live = new Set<string>();\n  private missing = new Set<string>();\n  private snapshots = 0;\n\n  markLive(key: string): void {\n    this.live.add(key);\n  }\n\n  isLive(key: string): boolean {\n    return this.live.has(key);\n  }\n\n  /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */\n  snapshot(key: string, frame?: string | number): string {\n    const src = this.get(key, frame);\n    const { x, y, width, height } = src.frame;\n    const canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n    const from = this.textures.get(key)?.canvas;\n    if (from) canvas.getContext('2d')!.drawImage(from, x, y, width, height, 0, 0, width, height);\n    const copy = `${key}#still${++this.snapshots}`;\n    this.addCanvas(copy, canvas).add('0', 0, 0, 0, width, height);\n    return copy;\n  }\n\n  /**\n   * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only\n   * made anew when the frame's size changes. Frame '0' is the copy.\n   */\n  snapshotInto(key: string, frame: string | number | undefined, into: string): void {\n    const src = this.get(key, frame);\n    const { x, y, width, height } = src.frame;\n    let tex = this.textures.get(into);\n    if (!tex || tex.width !== width || tex.height !== height) {\n      const canvas = document.createElement('canvas');\n      canvas.width = width;\n      canvas.height = height;\n      tex = this.addCanvas(into, canvas);\n      tex.add('0', 0, 0, 0, width, height);\n    }\n    const ctx = tex.context;\n    ctx.clearRect(0, 0, width, height);\n    const from = this.textures.get(key)?.canvas;\n    if (from) ctx.drawImage(from, x, y, width, height, 0, 0, width, height);\n    tex.refresh();\n  }\n\n  exists(key: string): boolean {\n    return this.textures.has(key);\n  }\n\n  addCanvas(key: string, canvas: HTMLCanvasElement): CanvasTexture {\n    this.remove(key);\n    const tex = new CanvasTexture(key, canvas);\n    this.textures.set(key, tex);\n    return tex;\n  }\n\n  /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */\n  addSpriteSheet(key: string, canvas: HTMLCanvasElement, size: { frameWidth: number; frameHeight: number }): CanvasTexture {\n    const tex = this.addCanvas(key, canvas);\n    const cols = Math.floor(canvas.width / size.frameWidth);\n    const rows = Math.floor(canvas.height / size.frameHeight);\n    for (let i = 0; i < cols * rows; i++) {\n      tex.add(String(i), 0, (i % cols) * size.frameWidth, Math.floor(i / cols) * size.frameHeight, size.frameWidth, size.frameHeight);\n    }\n    return tex;\n  }\n\n  createCanvas(key: string, width: number, height: number): CanvasTexture {\n    const canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n    return this.addCanvas(key, canvas);\n  }\n\n  remove(key: string): void {\n    this.textures.get(key)?.destroy();\n    this.textures.delete(key);\n    this.live.delete(key);\n  }\n\n  get(key: string, frame?: string | number): Texture {\n    const tex = this.textures.get(key);\n    if (!tex) return this.warn(key);\n    if (frame === undefined || frame === '') return tex.whole;\n    return tex.frames.get(String(frame)) ?? this.warn(`${key}/${frame}`);\n  }\n\n  private warn(what: string): Texture {\n    if (!this.missing.has(what)) {\n      this.missing.add(what);\n      console.warn(`[textures] missing ${what}`);\n    }\n    return Texture.EMPTY;\n  }\n}\n"],"names":["CanvasTexture","key","canvas","CanvasSource","Texture","name","_source","x","y","w","Rectangle","from","src","TextureRegistry","frame","width","height","copy","into","tex","ctx","size","cols","rows","i","what"],"mappings":"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"}

package/dist/core/Timeline.js

@@ -0,0 +1,211 @@
+import { TimelineBuilder as p } from "./TimelineBuilder.js";
+class c extends p {
+  timeScale;
+  repeat;
+  yoyo;
+  repeatDelay;
+  /** A timeline holds no targets of its own for `Tweener.killTweensOf`: stop it with `kill()`. */
+  targets = [];
+  options;
+  time = 0;
+  paused;
+  reversed = !1;
+  done = !1;
+  killed = !1;
+  /** In its manager's list: set again by anything that brings a finished timeline back to life. */
+  listed = !1;
+  /** The next render starts the run: a call standing at its first point fires. */
+  fresh = !0;
+  nestedIn = null;
+  resolveFinished = () => {
+  };
+  finishedPromise;
+  settled = !1;
+  /** Scratch for `locate`, so moving the playhead allocates nothing. */
+  locCycle = 0;
+  locLocal = 0;
+  constructor(t = {}) {
+    super(), this.options = t, this.repeat = t.repeat ?? 0, this.yoyo = t.yoyo ?? !1, this.repeatDelay = Math.max(0, t.repeatDelay ?? 0), this.timeScale = t.timeScale ?? 1, this.paused = t.paused ?? !1, this.finishedPromise = this.newPromise(), this.relist();
+  }
+  adopt(t) {
+    if (!(t instanceof c) || t === this || t.nestedIn) throw new Error("Timeline.add: a timeline is played by one parent at most, never itself");
+    if (!Number.isFinite(t.totalDuration)) throw new Error("Timeline.add: a timeline that repeats forever cannot be nested");
+    return t.nestedIn = this, t;
+  }
+  // ── playing ───────────────────────────────────────────────────────────────────────────────────────────────────
+  /** Every play and the delays between them, ms; Infinity when it repeats forever. */
+  get totalDuration() {
+    return this.repeat === -1 ? 1 / 0 : this.duration * (this.repeat + 1) + this.repeatDelay * this.repeat;
+  }
+  /** Where the playhead stands, ms from the start of the first play. */
+  get currentTime() {
+    return this.time;
+  }
+  /** 0–1 over the whole run (over the current play when it repeats forever). */
+  get progress() {
+    const t = this.totalDuration;
+    if (Number.isFinite(t)) return t > 0 ? this.time / t : 1;
+    const e = this.duration;
+    return e <= 0 ? 1 : (this.locate(this.time, t), this.locLocal / e);
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get isReversed() {
+    return this.reversed;
+  }
+  /** Still has somewhere to go: not completed, not killed. */
+  get isActive() {
+    return !this.done && !this.killed;
+  }
+  /** Resolves when the timeline completes (or is killed, so nothing awaits it forever). A restart makes a new one. */
+  get finished() {
+    return this.finishedPromise;
+  }
+  /** Advances by `dt` ms (× `timeScale`): how a timeline with no manager is played. */
+  update(t) {
+    this.tick(t);
+  }
+  /** @internal The manager's step: false once there is nothing left to play. */
+  step(t) {
+    this.listed = !1;
+    const e = this.tick(t);
+    return this.listed = e, e;
+  }
+  pause() {
+    return this.paused = !0, this;
+  }
+  /** Carries on the way it was going. */
+  resume() {
+    return this.paused = !1, this.wake(), this;
+  }
+  /** Plays forward from where it stands. */
+  play() {
+    return this.reversed = !1, this.resume();
+  }
+  /** Turns round and plays toward the start (or forward again, if it was reversed). */
+  reverse() {
+    return this.reversed = !this.reversed, this.resume();
+  }
+  /**
+   * Jumps to `to` (ms or a label) and shows it there. Calls on the way are skipped unless `fireCalls`; the playing
+   * state is kept, so a paused timeline stays paused.
+   */
+  seek(t, e = !1) {
+    const s = this.totalDuration, r = typeof t == "number" ? t : this.labels.get(t);
+    if (r === void 0) throw new Error(`Timeline.seek: no label "${t}"`);
+    const i = Math.min(s, Math.max(0, r));
+    return this.render(this.time, i, e, this.fresh && e), this.time = i, this.fresh = !1, this.wake(), this;
+  }
+  /** Back to the start, playing forward, with a new `finished` if the old one was settled. */
+  restart() {
+    return this.render(this.time, 0, !1, !1), this.time = 0, this.reversed = !1, this.paused = !1, this.fresh = !0, this.settled && (this.finishedPromise = this.newPromise()), this.wake(), this;
+  }
+  /** Stops for good where it stands (nothing is put back) and settles `finished`. */
+  kill() {
+    this.killed = !0, this.settle();
+  }
+  /** @internal The manager's name for `kill` (`Tweener.clear`, a stage destroyed). */
+  remove() {
+    this.kill();
+  }
+  /** @internal Played by a parent: its own time and calls, as one span. */
+  playNested(t, e, s, r) {
+    this.render(t, e, s, r), this.time = e, this.options.onUpdate?.(this), e >= this.totalDuration && t < e && this.options.onComplete?.(this);
+  }
+  // ── inside ────────────────────────────────────────────────────────────────────────────────────────────────────
+  tick(t) {
+    if (this.killed || this.nestedIn || this.done) return !1;
+    if (this.paused) return !0;
+    const e = this.totalDuration, s = this.time, r = t * this.timeScale;
+    let i = this.reversed ? s - r : s + r;
+    return i > e && (i = e), i < 0 && (i = 0), (i !== s || this.fresh) && (this.render(s, i, !0, this.fresh), this.time = i, this.fresh = !1, this.options.onUpdate?.(this)), this.killed ? !1 : (this.reversed ? i <= 0 : i >= e) ? (this.done = !0, this.options.onComplete?.(this), this.settle(), !1) : !0;
+  }
+  /** Moves the playhead from `from` to `to` (total time), play by play. */
+  render(t, e, s, r) {
+    const i = this.duration, a = this.totalDuration, h = i + this.repeatDelay;
+    if (this.repeat === 0 || h <= 0) {
+      this.playCycle(0, Math.min(i, Math.max(0, t)), Math.min(i, Math.max(0, e)), s, r);
+      return;
+    }
+    this.locate(t, a);
+    const o = this.locCycle, d = this.locLocal;
+    this.locate(e, a);
+    const n = this.locCycle, u = this.locLocal;
+    if (o === n) {
+      this.playCycle(o, d, u, s, r);
+      return;
+    }
+    const f = !this.yoyo;
+    if (n > o) {
+      this.playCycle(o, d, i, s, r);
+      for (let l = Math.max(o + 1, n - 1); l <= n; l++) {
+        if (this.nextPlay()) return;
+        this.playCycle(l, 0, l === n ? u : i, s, f);
+      }
+    } else {
+      this.playCycle(o, d, 0, s, r);
+      for (let l = Math.min(o - 1, n + 1); l >= n; l--) {
+        if (this.nextPlay()) return;
+        this.playCycle(l, i, l === n ? u : 0, s, f);
+      }
+    }
+  }
+  /** A play boundary: `onRepeat`, and a forever timeline whose every target is gone ends here. Answers "stop". */
+  nextPlay() {
+    return this.repeat === -1 && this.orphaned() ? (this.kill(), !0) : (this.options.onRepeat?.(this), this.killed);
+  }
+  playCycle(t, e, s, r, i) {
+    if (this.yoyo && t % 2 === 1) {
+      const h = this.duration;
+      e = h - e, s = h - s;
+    }
+    const a = this.children;
+    if (s >= e) for (let h = 0; h < a.length; h++) a[h].play(e, s, r, i);
+    else for (let h = a.length - 1; h >= 0; h--) a[h].play(e, s, r, i);
+  }
+  /** Total time → play and time within it, into `locCycle` / `locLocal`. */
+  locate(t, e) {
+    const s = this.duration;
+    if (t >= e) {
+      this.locCycle = this.repeat, this.locLocal = s;
+      return;
+    }
+    const r = s + this.repeatDelay, i = Math.floor(t / r);
+    this.locCycle = i, this.locLocal = Math.min(s, t - i * r);
+  }
+  /**
+   * Every tween's every target is a destroyed display object. Checked only when a forever timeline turns round, as
+   * `Tween` drops a forever tween whose sprites were freed: otherwise it would hold them for good.
+   */
+  orphaned() {
+    let t = !1;
+    for (const e of this.children)
+      if (e.kind === "tween")
+        for (const s of e.targets) {
+          if (s.destroyed !== !0) return !1;
+          t = !0;
+        }
+    return t;
+  }
+  /** Brought back to life (reversed, sought, restarted, resumed): its manager steps it again. */
+  wake() {
+    this.killed || (this.done = !1, this.relist());
+  }
+  relist() {
+    const t = this.options.tweens;
+    !t || this.listed || this.killed || this.nestedIn || (this.listed = !0, t.run(this));
+  }
+  settle() {
+    this.settled || (this.settled = !0, this.resolveFinished());
+  }
+  newPromise() {
+    return this.settled = !1, new Promise((t) => {
+      this.resolveFinished = t;
+    });
+  }
+}
+export {
+  c as Timeline
+};
+//# sourceMappingURL=Timeline.js.map

package/dist/core/Timeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timeline.js","sources":["../../src/core/Timeline.ts"],"sourcesContent":["import { TimelineBuilder } from './TimelineBuilder';\nimport type { NestedPlay } from './TimelineChild';\nimport type { Steppable, Tweener, TweenTarget } from './Tweener';\n\nexport interface TimelineOptions {\n  /**\n   * The manager that steps it: `stage.tweens` makes it follow the stage's `timeScale` and stop with the stage. Leave\n   * it out to step the timeline yourself with `update(dt)` (a fixed step, a test, a timeline played by another).\n   */\n  tweens?: Tweener;\n  /** Built but not playing until `play()` / `resume()`. */\n  paused?: boolean;\n  /** Extra plays after the first (-1 = forever). */\n  repeat?: number;\n  /** Every second play runs backwards. */\n  yoyo?: boolean;\n  /** Ms of stillness between plays. */\n  repeatDelay?: number;\n  /** Its own speed factor, on top of its manager's. */\n  timeScale?: number;\n  onUpdate?: (timeline: Timeline) => void;\n  onRepeat?: (timeline: Timeline) => void;\n  /** When the playhead reaches the end it is playing toward: the end, or the start when reversed. */\n  onComplete?: (timeline: Timeline) => void;\n}\n\n/**\n * Tweens and calls laid out in time and played as one: in sequence by default, overlapping by position (`'<'`,\n * `'-=100'`, a label), side by side in `parallel` groups, nested (`add`). It can repeat, yoyo, run at its own speed,\n * pause, seek and play backwards, and `finished` resolves when it completes.\n *\n * Built in one go, then it plays: a timeline stepped while empty has nothing left to do and completes, so build it in\n * the frame it is made (or make it `paused` and `play()` it later). Children are kept sorted by start, which is the\n * order they are played in going forward (and the reverse going back), so a later tween on the same property wins.\n */\nexport class Timeline extends TimelineBuilder implements Steppable, NestedPlay {\n  timeScale: number;\n  readonly repeat: number;\n  readonly yoyo: boolean;\n  readonly repeatDelay: number;\n  /** A timeline holds no targets of its own for `Tweener.killTweensOf`: stop it with `kill()`. */\n  readonly targets: readonly object[] = [];\n  private readonly options: TimelineOptions;\n  private time = 0;\n  private paused: boolean;\n  private reversed = false;\n  private done = false;\n  private killed = false;\n  /** In its manager's list: set again by anything that brings a finished timeline back to life. */\n  private listed = false;\n  /** The next render starts the run: a call standing at its first point fires. */\n  private fresh = true;\n  private nestedIn: Timeline | null = null;\n  private resolveFinished: () => void = () => undefined;\n  private finishedPromise: Promise<void>;\n  private settled = false;\n  /** Scratch for `locate`, so moving the playhead allocates nothing. */\n  private locCycle = 0;\n  private locLocal = 0;\n\n  constructor(options: TimelineOptions = {}) {\n    super();\n    this.options = options;\n    this.repeat = options.repeat ?? 0;\n    this.yoyo = options.yoyo ?? false;\n    this.repeatDelay = Math.max(0, options.repeatDelay ?? 0);\n    this.timeScale = options.timeScale ?? 1;\n    this.paused = options.paused ?? false;\n    this.finishedPromise = this.newPromise();\n    this.relist();\n  }\n\n  protected adopt(child: TimelineBuilder): NestedPlay {\n    if (!(child instanceof Timeline) || child === this || child.nestedIn) throw new Error('Timeline.add: a timeline is played by one parent at most, never itself');\n    if (!Number.isFinite(child.totalDuration)) throw new Error('Timeline.add: a timeline that repeats forever cannot be nested');\n    child.nestedIn = this;\n    return child;\n  }\n\n  // ── playing ───────────────────────────────────────────────────────────────────────────────────────────────────\n\n  /** Every play and the delays between them, ms; Infinity when it repeats forever. */\n  get totalDuration(): number {\n    if (this.repeat === -1) return Infinity;\n    return this.duration * (this.repeat + 1) + this.repeatDelay * this.repeat;\n  }\n\n  /** Where the playhead stands, ms from the start of the first play. */\n  get currentTime(): number {\n    return this.time;\n  }\n\n  /** 0–1 over the whole run (over the current play when it repeats forever). */\n  get progress(): number {\n    const total = this.totalDuration;\n    if (Number.isFinite(total)) return total > 0 ? this.time / total : 1;\n    const d = this.duration;\n    if (d <= 0) return 1;\n    this.locate(this.time, total);\n    return this.locLocal / d;\n  }\n\n  get isPaused(): boolean {\n    return this.paused;\n  }\n\n  get isReversed(): boolean {\n    return this.reversed;\n  }\n\n  /** Still has somewhere to go: not completed, not killed. */\n  get isActive(): boolean {\n    return !this.done && !this.killed;\n  }\n\n  /** Resolves when the timeline completes (or is killed, so nothing awaits it forever). A restart makes a new one. */\n  get finished(): Promise<void> {\n    return this.finishedPromise;\n  }\n\n  /** Advances by `dt` ms (× `timeScale`): how a timeline with no manager is played. */\n  update(dt: number): void {\n    this.tick(dt);\n  }\n\n  /** @internal The manager's step: false once there is nothing left to play. */\n  step(dt: number): boolean {\n    // dropped by the manager if anything below throws: only a clean return keeps it listed\n    this.listed = false;\n    const alive = this.tick(dt);\n    this.listed = alive;\n    return alive;\n  }\n\n  pause(): this {\n    this.paused = true;\n    return this;\n  }\n\n  /** Carries on the way it was going. */\n  resume(): this {\n    this.paused = false;\n    this.wake();\n    return this;\n  }\n\n  /** Plays forward from where it stands. */\n  play(): this {\n    this.reversed = false;\n    return this.resume();\n  }\n\n  /** Turns round and plays toward the start (or forward again, if it was reversed). */\n  reverse(): this {\n    this.reversed = !this.reversed;\n    return this.resume();\n  }\n\n  /**\n   * Jumps to `to` (ms or a label) and shows it there. Calls on the way are skipped unless `fireCalls`; the playing\n   * state is kept, so a paused timeline stays paused.\n   */\n  seek(to: number | string, fireCalls = false): this {\n    const total = this.totalDuration;\n    const at = typeof to === 'number' ? to : this.labels.get(to);\n    if (at === undefined) throw new Error(`Timeline.seek: no label \"${to}\"`);\n    const target = Math.min(total, Math.max(0, at));\n    this.render(this.time, target, fireCalls, this.fresh && fireCalls);\n    this.time = target;\n    this.fresh = false;\n    this.wake();\n    return this;\n  }\n\n  /** Back to the start, playing forward, with a new `finished` if the old one was settled. */\n  restart(): this {\n    this.render(this.time, 0, false, false);\n    this.time = 0;\n    this.reversed = false;\n    this.paused = false;\n    this.fresh = true;\n    if (this.settled) this.finishedPromise = this.newPromise();\n    this.wake();\n    return this;\n  }\n\n  /** Stops for good where it stands (nothing is put back) and settles `finished`. */\n  kill(): void {\n    this.killed = true;\n    this.settle();\n  }\n\n  /** @internal The manager's name for `kill` (`Tweener.clear`, a stage destroyed). */\n  remove(): void {\n    this.kill();\n  }\n\n  /** @internal Played by a parent: its own time and calls, as one span. */\n  playNested(from: number, to: number, fire: boolean, includeStart: boolean): void {\n    this.render(from, to, fire, includeStart);\n    this.time = to;\n    this.options.onUpdate?.(this);\n    if (to >= this.totalDuration && from < to) this.options.onComplete?.(this);\n  }\n\n  // ── inside ────────────────────────────────────────────────────────────────────────────────────────────────────\n\n  private tick(dt: number): boolean {\n    if (this.killed || this.nestedIn) return false;\n    if (this.done) return false;\n    if (this.paused) return true;\n    const total = this.totalDuration;\n    const from = this.time;\n    const delta = dt * this.timeScale;\n    let to = this.reversed ? from - delta : from + delta;\n    if (to > total) to = total;\n    if (to < 0) to = 0;\n    if (to !== from || this.fresh) {\n      this.render(from, to, true, this.fresh);\n      this.time = to;\n      this.fresh = false;\n      this.options.onUpdate?.(this);\n    }\n    if (this.killed) return false;\n    if (this.reversed ? to <= 0 : to >= total) {\n      this.done = true;\n      this.options.onComplete?.(this);\n      this.settle();\n      return false;\n    }\n    return true;\n  }\n\n  /** Moves the playhead from `from` to `to` (total time), play by play. */\n  private render(from: number, to: number, fire: boolean, includeStart: boolean): void {\n    const d = this.duration;\n    const total = this.totalDuration;\n    const period = d + this.repeatDelay;\n    if (this.repeat === 0 || period <= 0) {\n      this.playCycle(0, Math.min(d, Math.max(0, from)), Math.min(d, Math.max(0, to)), fire, includeStart);\n      return;\n    }\n    this.locate(from, total);\n    const ca = this.locCycle;\n    const la = this.locLocal;\n    this.locate(to, total);\n    const cb = this.locCycle;\n    const lb = this.locLocal;\n    if (ca === cb) {\n      this.playCycle(ca, la, lb, fire, includeStart);\n      return;\n    }\n    // a yoyo's turn has just played its end point, so the next play leaves it out; a plain repeat starts afresh\n    const restart = !this.yoyo;\n    if (cb > ca) {\n      this.playCycle(ca, la, d, fire, includeStart);\n      // a frame that crosses many plays (a very short timeline) shows only the last two\n      for (let c = Math.max(ca + 1, cb - 1); c <= cb; c++) {\n        if (this.nextPlay()) return;\n        this.playCycle(c, 0, c === cb ? lb : d, fire, restart);\n      }\n    } else {\n      this.playCycle(ca, la, 0, fire, includeStart);\n      for (let c = Math.min(ca - 1, cb + 1); c >= cb; c--) {\n        if (this.nextPlay()) return;\n        this.playCycle(c, d, c === cb ? lb : 0, fire, restart);\n      }\n    }\n  }\n\n  /** A play boundary: `onRepeat`, and a forever timeline whose every target is gone ends here. Answers \"stop\". */\n  private nextPlay(): boolean {\n    if (this.repeat === -1 && this.orphaned()) {\n      this.kill();\n      return true;\n    }\n    this.options.onRepeat?.(this);\n    return this.killed;\n  }\n\n  private playCycle(cycle: number, a: number, b: number, fire: boolean, includeStart: boolean): void {\n    if (this.yoyo && cycle % 2 === 1) {\n      const d = this.duration;\n      a = d - a;\n      b = d - b;\n    }\n    const list = this.children;\n    if (b >= a) for (let i = 0; i < list.length; i++) list[i]!.play(a, b, fire, includeStart);\n    else for (let i = list.length - 1; i >= 0; i--) list[i]!.play(a, b, fire, includeStart);\n  }\n\n  /** Total time → play and time within it, into `locCycle` / `locLocal`. */\n  private locate(t: number, total: number): void {\n    const d = this.duration;\n    if (t >= total) {\n      this.locCycle = this.repeat;\n      this.locLocal = d;\n      return;\n    }\n    const period = d + this.repeatDelay;\n    const c = Math.floor(t / period);\n    this.locCycle = c;\n    this.locLocal = Math.min(d, t - c * period);\n  }\n\n  /**\n   * Every tween's every target is a destroyed display object. Checked only when a forever timeline turns round, as\n   * `Tween` drops a forever tween whose sprites were freed: otherwise it would hold them for good.\n   */\n  private orphaned(): boolean {\n    let any = false;\n    for (const c of this.children) {\n      if (c.kind !== 'tween') continue;\n      for (const t of c.targets) {\n        if ((t as TweenTarget).destroyed !== true) return false;\n        any = true;\n      }\n    }\n    return any;\n  }\n\n  /** Brought back to life (reversed, sought, restarted, resumed): its manager steps it again. */\n  private wake(): void {\n    if (this.killed) return;\n    // the next step finds out whether there is anywhere left to go, and completes it if not\n    this.done = false;\n    this.relist();\n  }\n\n  private relist(): void {\n    const tweens = this.options.tweens;\n    if (!tweens || this.listed || this.killed || this.nestedIn) return;\n    this.listed = true;\n    tweens.run(this);\n  }\n\n  private settle(): void {\n    if (this.settled) return;\n    this.settled = true;\n    this.resolveFinished();\n  }\n\n  private newPromise(): Promise<void> {\n    this.settled = false;\n    return new Promise<void>((resolve) => {\n      this.resolveFinished = resolve;\n    });\n  }\n}\n"],"names":["Timeline","TimelineBuilder","options","child","total","d","dt","alive","to","fireCalls","at","target","from","fire","includeStart","delta","period","ca","la","cb","lb","restart","c","cycle","a","b","list","i","any","t","tweens","resolve"],"mappings":"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"}

package/dist/core/TimelineBuilder.js

@@ -0,0 +1,73 @@
+import { easeByName as d } from "./eases.js";
+import { placeAt as m } from "./timelinePlace.js";
+import { TimelineChild as i } from "./TimelineChild.js";
+class x {
+  /** Sorted by start; equal starts keep the order they were added in. */
+  children = [];
+  labels = /* @__PURE__ */ new Map();
+  /** The longest child's end, kept as children are added rather than summed every frame. */
+  length = 0;
+  lastStart = 0;
+  lastEnd = 0;
+  group = null;
+  /** One play, ms (the longest child's end). */
+  get duration() {
+    return this.length;
+  }
+  /** Tweens the numeric `props` of `targets` (one object or several), after what came before unless `at` says. */
+  to(t, e, s = {}) {
+    const n = Array.isArray(t) ? [...t] : [t], a = [], l = [], h = [];
+    for (const [p, r] of Object.entries(e))
+      a.push(p), typeof r == "number" ? (l.push(r), h.push(void 0)) : (l.push(r.to), h.push(r.from));
+    const o = typeof s.ease == "function" ? s.ease : d(s.ease), u = Math.max(0, s.duration ?? 1e3), c = this.place(s.at);
+    return this.insert(new i("tween", c, u, n, a, l, h, o));
+  }
+  /** Calls `fn` when the playhead passes `at` (default: the end so far), going either way. */
+  call(t, e) {
+    return this.insert(new i("call", this.place(e), 0, [], [], [], [], null, t));
+  }
+  /** `ms` of nothing: the next child starts that much later, and a wait at the end makes the timeline longer. */
+  wait(t) {
+    return this.insert(new i("gap", this.place(void 0), Math.max(0, t)));
+  }
+  /** Names a point (default: the end so far), for positions and `seek`. */
+  label(t, e) {
+    return this.labels.set(t, this.place(e)), this;
+  }
+  /** Where a label stands, if it is set. */
+  labelTime(t) {
+    return this.labels.get(t);
+  }
+  /**
+   * Everything `build` adds starts together, at `at` (default: the end so far); a position inside is measured from
+   * the group's start. What follows the group starts at its longest child's end.
+   */
+  parallel(t, e) {
+    const s = this.group, n = this.place(e), a = { start: n, end: n };
+    this.group = a;
+    try {
+      t(this);
+    } finally {
+      this.group = s, s && (s.end = Math.max(s.end, a.end)), this.lastStart = n, this.lastEnd = a.end;
+    }
+    return this;
+  }
+  /** Plays another timeline (built, not repeating forever) as one child of this one; it is no longer stepped alone. */
+  add(t, e) {
+    const s = this.adopt(t), n = this.place(e);
+    return this.insert(new i("nested", n, s.totalDuration, [], [], [], [], null, null, s));
+  }
+  place(t) {
+    const e = this.length, s = { fallback: this.group ? this.group.start : e, end: e, lastStart: this.lastStart, lastEnd: this.lastEnd, labels: this.labels };
+    return m(t, s);
+  }
+  insert(t) {
+    let e = this.children.length;
+    for (; e > 0 && this.children[e - 1].start > t.start; ) e--;
+    return this.children.splice(e, 0, t), this.length = Math.max(this.length, t.end), this.lastStart = t.start, this.lastEnd = t.end, this.group && (this.group.end = Math.max(this.group.end, t.end)), this;
+  }
+}
+export {
+  x as TimelineBuilder
+};
+//# sourceMappingURL=TimelineBuilder.js.map

package/dist/core/TimelineBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineBuilder.js","sources":["../../src/core/TimelineBuilder.ts"],"sourcesContent":["import { easeByName, type EaseFn } from './eases';\nimport { placeAt, type PlaceContext, type TimelinePosition } from './timelinePlace';\nimport { TimelineChild, type NestedPlay } from './TimelineChild';\nimport type { TweenTarget } from './Tweener';\n\n/** A number to tween to, or `{ from, to }` to start from a given value instead of the target's own. */\nexport type TimelineProps = Record<string, number | { from?: number; to: number }>;\n\nexport interface TimelineTweenOptions {\n  /** Ms (default 1000, as `Tweener`'s). */\n  duration?: number;\n  /** A name `easeByName` knows ('Quad.Out' when left out, as `Tweener`'s) or an ease function. */\n  ease?: string | EaseFn;\n  at?: TimelinePosition;\n}\n\n/**\n * The building half of `Timeline`: where each tween, call, gap and nested timeline goes. Kept apart from the playing\n * half so each stays readable; nothing here runs per frame.\n */\nexport abstract class TimelineBuilder {\n  /** Sorted by start; equal starts keep the order they were added in. */\n  protected readonly children: TimelineChild[] = [];\n  protected readonly labels = new Map<string, number>();\n  /** The longest child's end, kept as children are added rather than summed every frame. */\n  private length = 0;\n  private lastStart = 0;\n  private lastEnd = 0;\n  private group: { start: number; end: number } | null = null;\n\n  /** Checks `child` may be played by this timeline and takes it over (it stops being stepped alone). */\n  protected abstract adopt(child: TimelineBuilder): NestedPlay;\n\n  /** One play, ms (the longest child's end). */\n  get duration(): number {\n    return this.length;\n  }\n\n  /** Tweens the numeric `props` of `targets` (one object or several), after what came before unless `at` says. */\n  to(targets: object | readonly object[], props: TimelineProps, options: TimelineTweenOptions = {}): this {\n    const list = (Array.isArray(targets) ? [...targets] : [targets]) as TweenTarget[];\n    const names: string[] = [];\n    const ends: number[] = [];\n    const froms: (number | undefined)[] = [];\n    for (const [name, v] of Object.entries(props)) {\n      names.push(name);\n      if (typeof v === 'number') {\n        ends.push(v);\n        froms.push(undefined);\n      } else {\n        ends.push(v.to);\n        froms.push(v.from);\n      }\n    }\n    const ease = typeof options.ease === 'function' ? options.ease : easeByName(options.ease);\n    const duration = Math.max(0, options.duration ?? 1000);\n    const start = this.place(options.at);\n    return this.insert(new TimelineChild('tween', start, duration, list, names, ends, froms, ease));\n  }\n\n  /** Calls `fn` when the playhead passes `at` (default: the end so far), going either way. */\n  call(fn: () => void, at?: TimelinePosition): this {\n    return this.insert(new TimelineChild('call', this.place(at), 0, [], [], [], [], null, fn));\n  }\n\n  /** `ms` of nothing: the next child starts that much later, and a wait at the end makes the timeline longer. */\n  wait(ms: number): this {\n    return this.insert(new TimelineChild('gap', this.place(undefined), Math.max(0, ms)));\n  }\n\n  /** Names a point (default: the end so far), for positions and `seek`. */\n  label(name: string, at?: TimelinePosition): this {\n    this.labels.set(name, this.place(at));\n    return this;\n  }\n\n  /** Where a label stands, if it is set. */\n  labelTime(name: string): number | undefined {\n    return this.labels.get(name);\n  }\n\n  /**\n   * Everything `build` adds starts together, at `at` (default: the end so far); a position inside is measured from\n   * the group's start. What follows the group starts at its longest child's end.\n   */\n  parallel(build: (timeline: this) => void, at?: TimelinePosition): this {\n    const outer = this.group;\n    const start = this.place(at);\n    const group = { start, end: start };\n    this.group = group;\n    try {\n      build(this);\n    } finally {\n      this.group = outer;\n      if (outer) outer.end = Math.max(outer.end, group.end);\n      this.lastStart = start;\n      this.lastEnd = group.end;\n    }\n    return this;\n  }\n\n  /** Plays another timeline (built, not repeating forever) as one child of this one; it is no longer stepped alone. */\n  add(child: TimelineBuilder, at?: TimelinePosition): this {\n    const nested = this.adopt(child);\n    const start = this.place(at);\n    return this.insert(new TimelineChild('nested', start, nested.totalDuration, [], [], [], [], null, null, nested));\n  }\n\n  private place(at: TimelinePosition | undefined): number {\n    const end = this.length;\n    const ctx: PlaceContext = { fallback: this.group ? this.group.start : end, end, lastStart: this.lastStart, lastEnd: this.lastEnd, labels: this.labels };\n    return placeAt(at, ctx);\n  }\n\n  private insert(child: TimelineChild): this {\n    let i = this.children.length;\n    while (i > 0 && this.children[i - 1]!.start > child.start) i--;\n    this.children.splice(i, 0, child);\n    this.length = Math.max(this.length, child.end);\n    this.lastStart = child.start;\n    this.lastEnd = child.end;\n    if (this.group) this.group.end = Math.max(this.group.end, child.end);\n    return this;\n  }\n}\n"],"names":["TimelineBuilder","targets","props","options","list","names","ends","froms","name","v","ease","easeByName","duration","start","TimelineChild","fn","at","ms","build","outer","group","child","nested","end","ctx","placeAt","i"],"mappings":"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"}