@energy8platform/golem 0.1.0

package/dist/lib/editor/timeline-layout.d.ts

@@ -0,0 +1,64 @@
+import type { Animation, RigDocument } from "../rig-format";
+import type { TrackRef } from "./store";
+export interface Row {
+    kind: "all" | "group" | "track";
+    label: string;
+    /** only on `track` rows — the track this row edits */
+    track?: TrackRef;
+    /** key times, ascending; on `all` / `group` rows the union of the tracks below it */
+    keys: number[];
+    depth: number;
+}
+/** how close (px) the pointer must be to a diamond to grab it */
+export declare const KEY_HIT = 5;
+/**
+ * Rows for one animation: the "all keys" summary, then one group per animated target followed by its tracks.
+ * Groups come in the order the rig reads: bones parent-first, then slots, deform (by attachment), ik, transform,
+ * path and drawOrder — each filtered to the targets that actually have keys, ids the document no longer knows
+ * kept at the end of their kind so an orphaned track is still visible (and deletable).
+ */
+export declare function rows(doc: RigDocument, anim: Animation): Row[];
+/** where the rows start (`left` px of labels, `headerH` px of ruler) and how far a second and a row reach */
+export interface Layout {
+    left: number;
+    rowH: number;
+    headerH: number;
+    pxPerSec: number;
+    scrollX: number;
+    scrollY: number;
+}
+export declare const xOfTime: (l: Layout, t: number) => number;
+export declare const timeOfX: (l: Layout, x: number) => number;
+/** row index at a canvas y — negative inside the header, past the last row below the sheet */
+export declare const rowAtY: (l: Layout, y: number) => number;
+/** the key under (x, y): the nearest diamond of that row within `KEY_HIT` px, or nothing */
+export declare function keyAt(l: Layout, rs: Row[], x: number, y: number): {
+    row: number;
+    t: number;
+} | undefined;
+/** the nearest frame boundary — the grid every human edit lands on */
+export declare const snap: (t: number, fps: number) => number;
+/** written key times live on a 1e-6 grid: float drift never turns one key into two */
+export declare const roundTime: (t: number) => number;
+/** two keys of one track are "the same key" this close — the format wants strictly increasing times */
+export declare const COLLIDE = 0.000001;
+/**
+ * How close a dragged key may come to a key that stays put. Comfortably above `roundTime`'s 1e-6 grid, so
+ * rounding a clamped time can never push it onto its neighbour (the reason this is not simply `COLLIDE`).
+ */
+export declare const MIN_GAP = 0.0001;
+/**
+ * Where the selected keys of one track land when the pointer asks for `dt` seconds.
+ *
+ * `all` is every key time of the track, `selected` the ones being dragged; the result gives their new times in
+ * the same order, rounded to the written grid. Δt is clamped as a whole (so the selection keeps its shape): the
+ * earliest key stays ≥ 0, the latest ≤ `duration`, and no moved key crosses — or lands within `minGap` of — a key
+ * that stays put. `snapFps` snaps each moved time to that frame grid, unless snapping would break one of those
+ * rules, in which case the unsnapped positions are used.
+ */
+export declare function moveKeyTimes(all: number[], selected: number[], dt: number, duration: number, opts?: {
+    snapFps?: number;
+    minGap?: number;
+}): number[];
+/** the duration a drag asks for, floored by the last key/event (the registry refuses less) and by one frame */
+export declare function clampDuration(requested: number, lastKeyOrEventTime: number, fps: number): number;

package/dist/lib/editor/timeline.d.ts

@@ -0,0 +1,45 @@
+export declare class Timeline {
+    private host;
+    private canvas;
+    private g;
+    private dispose;
+    private w;
+    private h;
+    private dpr;
+    private pxPerSec;
+    private scrollX;
+    private scrollY;
+    private drag?;
+    constructor(host: HTMLElement);
+    destroy(): void;
+    private layout;
+    /**
+     * The rows of the animation shown right now. `peek` so pointer handlers never subscribe to anything, and
+     * memoized on identity — this runs on every redraw (60/s while playing) and on every hover.
+     */
+    private rowsMemo?;
+    private rowsNow;
+    /** canvas-relative CSS px of a `track` row's centre (the first one, or `ref`'s) and of t = 0.3 — the e2e drives the sheet through this */
+    debugTrackRow(ref?: {
+        target: string;
+        id: string;
+        prop: string;
+    }): {
+        y: number;
+        xEmpty: number;
+    };
+    /** canvas-relative CSS x of a time */
+    debugX(t: number): number;
+    private resize;
+    private diamond;
+    private draw;
+    private seek;
+    /** where the selected keys of the dragged track land for a raw Δt (all the arithmetic is in timeline-layout) */
+    private moveKeys;
+    /** one gesture, one tool call: the moved track's full key list with new times, `v` and `ease` untouched */
+    private endKeyDrag;
+    private endDurationDrag;
+    /** a double-click on free space keys the value already shown there, so the pose does not jump */
+    private addKey;
+    private bindPointer;
+}

package/dist/lib/editor-entry.d.ts

@@ -0,0 +1,2 @@
+/** `@energy8platform/golem/editor` — the editor's HTTP/SSE server (node). */
+export { startEditorServer, type EditorServer } from "./editor/server";