@cardstack/choreo 0.0.0 → 0.1.0-unstable.0

package/declarations/easings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The cosine easings, recovered from boxel-motion (`easings/cosine.ts` at
+ * `cardstack/boxel@394503e3b7^`) — the ones its own flagship transition used.
+ *
+ * `easeInAndOut` is the interesting one: a raised cosine has zero slope at both
+ * ends, so an animation interrupted at t=0 inherits none of its own curve and
+ * all of whatever it is replacing. That is the property Ember Animated leans on
+ * to make a summed corrective curve continuous; here the same shape is simply
+ * available as an `@ease`.
+ *
+ *   <c.Tween @of={{c.kept 'card'}} @opacity={{1}} @ms={{300}} @ease={{easeIn}} />
+ *
+ * `@ease` also takes an engine easing name or a cubic-bezier as four numbers;
+ * these exist because a bezier cannot express a raised cosine exactly.
+ */
+/** a raised cosine: zero slope at both ends */
+export declare function easeInAndOut(t: number): number;
+export declare function easeIn(t: number): number;
+export declare function easeOut(t: number): number;
+//# sourceMappingURL=easings.d.ts.map

package/declarations/easings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easings.d.ts","sourceRoot":"","sources":["../src/easings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9C;AAYD,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzC"}

package/declarations/far.d.ts

@@ -0,0 +1,33 @@
+import type { ChoreoNode, Sprite } from './types.ts';
+/** one region's measured pass, waiting for the others before it runs */
+export interface Pass {
+    claimed: ChoreoNode[];
+    host: PassHost;
+    inserted: Sprite[];
+    kept: Sprite[];
+    removed: Sprite[];
+    root: HTMLElement;
+}
+export interface PassHost {
+    /** phase 3: compile and play, now that identities have been reconciled */
+    finishPass(pass: Pass): void;
+    /** phase 1: snapshot vs. now, into a changeset — no animation started yet */
+    measurePass(): Pass | undefined;
+}
+export declare function setPassScheduler(fn: (run: () => void) => void): void;
+/**
+ * Announce that this region has a pass coming. Called while Glimmer is still
+ * rendering, so by the time the barrier runs, every region taking part in this
+ * pass is known — which is what lets the match be synchronous.
+ */
+export declare function join(host: PassHost): void;
+export declare function leave(host: PassHost): void;
+/**
+ * Drop a barrier that will never run. A test torn down between `join` and the
+ * post-render callback leaves a destroyed region parked in `intents`, and the
+ * next test's first pass would try to measure it. `setupChoreo(hooks)` runs
+ * this before and after every test.
+ */
+export declare function resetBarrier(): void;
+export declare function setBeforeMeasure(fn: () => void): void;
+//# sourceMappingURL=far.d.ts.map

package/declarations/far.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"far.d.ts","sourceRoot":"","sources":["../src/far.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAErD,wEAAwE;AACxE,MAAM,WAAW,IAAI;IACnB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,MAAM,WAAW,QAAQ;IACvB,0EAA0E;IAC1E,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAC7B,6EAA6E;IAC7E,WAAW,IAAI,IAAI,GAAG,SAAS,CAAC;CACjC;AAOD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,IAAI,KAAK,IAAI,QAE7D;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,QAAQ,QAMlC;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,QAAQ,QAEnC;AAKD;;;;;GAKG;AACH,wBAAgB,YAAY,SAG3B;AAID,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,IAAI,QAE9C"}

package/declarations/film/clip.d.ts

@@ -0,0 +1,51 @@
+import Component from '@glimmer/component';
+import type { ClipSpec, ClipState } from './clips.ts';
+import type { ElementModifier } from './types.ts';
+export interface ClipSignature {
+    Args: {
+        /** the picture, read back, when the clip is a freeze */
+        freeze?: string;
+        /** a new element per clip window, so the entrance replays */
+        key: string;
+        /** which lane this clip is on: the film's own handle is per lane */
+        lane: number;
+        /** the film's handle on the media element, for the per-frame sync */
+        mount: ElementModifier<HTMLElement, [number]>;
+        spec: ClipSpec;
+        /** the resolved source, under `assets` */
+        src: string;
+        state: ClipState;
+    };
+}
+/**
+ * A CLIP ON THE PICTURE. A video, a still or a freeze of the picture
+ * itself, standing over the frame for its window — full frame, or as an
+ * inset with its caption like the photograph. The media is not played by
+ * the browser's own clock: the film writes its source time every frame
+ * (a paused element seeked, a playing one corrected), so a clip is where
+ * the clock says it is whether the film played there or was scrubbed
+ * there. It arrives the way the insert does — wiped in — and leaves in a
+ * short fade.
+ */
+export declare class Clip extends Component<ClipSignature> {
+    /** a pip is placed by the score, in percent of the frame */
+    get place(): string;
+    /** a pip fades; the editorial card is wiped in and out */
+    get isPip(): boolean;
+    /**
+     * THE LOOK THIS CLIP IS WEARING, as a CSS filter — composed in the same
+     * order the picture's own shader composes its grade (saturate, then
+     * contrast, then brightness, then sepia and hue), because filter order
+     * is not commutative and the two should agree about what a number
+     * means. Blur goes last, where a lens would put it.
+     *
+     * It rides the MEDIA, not the figure, so an inset's caption and its card
+     * are not graded with the footage.
+     */
+    get look(): string;
+    /** seconds a pip takes to arrive and to go */
+    get fade(): number;
+    get muted(): boolean;
+    get volume(): number;
+}
+//# sourceMappingURL=clip.d.ts.map

package/declarations/film/clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../src/film/clip.gts"],"names":[],"mappings":"AA+LA,OAAO,SAAS,MAAM,oBAAoB,CAAC;AAI3C,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE;QACJ,wDAAwD;QACxD,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,6DAA6D;QAC7D,GAAG,EAAE,MAAM,CAAC;QACZ,oEAAoE;QACpE,IAAI,EAAE,MAAM,CAAC;QACb,qEAAqE;QACrE,KAAK,EAAE,eAAe,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9C,IAAI,EAAE,QAAQ,CAAC;QACf,0CAA0C;QAC1C,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,SAAS,CAAC;KAClB,CAAC;CACH;AAED;;;;;;;;;GASG;AACH,qBAAa,IAAK,SAAQ,SAAS,CAAC,aAAa,CAAC;IAChD,4DAA4D;IAC5D,IAAI,KAAK,IAAI,MAAM,CAYlB;IAED,0DAA0D;IAC1D,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED;;;;;;;;;OASG;IACH,IAAI,IAAI,IAAI,MAAM,CAgCjB;IAED,8CAA8C;IAC9C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;CA6IF"}

package/declarations/film/clips.d.ts

@@ -0,0 +1,155 @@
+/**
+ * CLIPS — a source-time window over the film's clock.
+ *
+ * A beat is a shot of the picture. A clip is something else laid over it
+ * for a while: a video, a still, or a freeze of the picture itself. Its
+ * arithmetic is the compositor's (notes/choreo-composition.md, Phase C3),
+ * lifted whole because it was already right:
+ *
+ *   source = in + (film − start) × rate
+ *   window = for, or (out − in) / rate, or the rest of the beat
+ *
+ * Before `start` the clip is absent; inside its window it is active and
+ * its source time is the number above; past it the end policy applies —
+ * `remove` (the default) takes it off, `hold` keeps the last sample on
+ * screen, `freeze` keeps it on screen and writes nothing further. Every
+ * state is re-derived from the film time on every frame, never discovered
+ * by playing from zero — which is what lets an exact film scrub into the
+ * middle of a clip and find it where it should be.
+ *
+ * A clip may outlive its beat: the window is measured on the film's
+ * clock, so a still that starts late in one shot can cross the seam into
+ * the next. That is the clip overlap an editor means.
+ */
+import type { Beat } from './types.ts';
+export type ClipKind = 'freeze' | 'image' | 'video';
+export type ClipEnd = 'freeze' | 'hold' | 'remove';
+export interface ClipSpec {
+    /** seconds into the beat at which the clip appears (default 0) */
+    at?: number;
+    /** a line under an inset, and who to credit */
+    caption?: string;
+    credit?: string;
+    /** past its window: taken off (default), held on its last sample, or frozen */
+    end?: ClipEnd;
+    /** a pip's own fade, seconds in and out (default 0.4) */
+    fade?: number;
+    /**
+     * `cover` is the full frame over the picture; `inset` is the editorial
+     * photograph, a paper card in the corner the type is not using; `pip`
+     * is a LAYER — placed, sized and faded by the score, with nothing
+     * around it. A pip is what a picture-in-picture actually is, and the
+     * card is what an inset actually is; they were one thing and should
+     * not have been.
+     */
+    fit?: 'cover' | 'inset' | 'pip';
+    /** seconds it stays; default: to the end of the beat, or the source's own length */
+    for?: number;
+    /** the source's in point, seconds (video) */
+    in?: number;
+    kind: ClipKind;
+    /**
+     * WHICH LANE THIS CLIP IS ON, and it is the whole reason a beat can
+     * carry more than one.
+     *
+     * Within a lane the rule is what it always was: the newest clip wins,
+     * an older one is never reached past it, and an end policy decides
+     * whether the lane empties or holds. Across lanes clips coexist, which
+     * is what a picture-in-picture over a full-frame video needs and what a
+     * single slot could not do — a second clip on a beat used to overwrite
+     * the first silently.
+     *
+     * Defaults to the clip's own position among its beat's clips, so two
+     * insets on one shot are two lanes without anybody saying so; name it
+     * when a later beat should REPLACE an earlier clip rather than sit
+     * beside it.
+     */
+    lane?: number;
+    /** a look held on this clip alone (`f.clip.Look`) */
+    look?: ClipLook;
+    /** the source's out point, seconds (video); with `in`, sets the window */
+    out?: number;
+    /** a pip's corner radius, in percent of its width */
+    radius?: number;
+    /** source seconds per film second (video) */
+    rate?: number;
+    /** under `assets`; a freeze needs none */
+    src?: string;
+    /** the clip's own sound, 0..1; 0 (the default) keeps the film's voice in charge */
+    volume?: number;
+    /** a pip's width, percent of the frame (default 30) */
+    w?: number;
+    /** a pip's left edge, percent of the frame (default 66) */
+    x?: number;
+    /** a pip's top edge, percent of the frame (default 10) */
+    y?: number;
+}
+/**
+ * A LOOK HELD ON A CLIP — the first adjustment that belongs to something
+ * other than the picture.
+ *
+ * `f.picture.Look` reaches the WebGL page's own grade; a clip is a DOM
+ * element and has never had one, so a video inset over a graded picture
+ * was ungraded and there was no way to say otherwise. These are the
+ * operations a browser can do to an element without a texture, composed
+ * in the order the film's own shader composes them (saturate, contrast,
+ * brightness, then sepia and hue) — because filter order is not
+ * commutative and the two should agree.
+ *
+ * What this is NOT is the whole filter stack: curves, secondaries and a
+ * LUT need the pixels, which needs the clip through a texture. This is
+ * the half a browser gives for free.
+ */
+export interface ClipLook {
+    /** gaussian blur, pixels */
+    blur?: number;
+    /** exposure, 1 is unchanged */
+    bri?: number;
+    /** contrast, 1 is unchanged */
+    con?: number;
+    /** to grey, 0..1 */
+    gray?: number;
+    /** hue rotation, degrees */
+    hue?: number;
+    /** the whole layer's opacity, 0..1 */
+    opacity?: number;
+    /** saturation, 1 is unchanged, 0 is monochrome */
+    sat?: number;
+    /** to sepia, 0..1 */
+    sepia?: number;
+}
+export type ClipState = 'absent' | 'active' | 'frozen' | 'held';
+export interface ResolvedClip {
+    /** which beat's clip this is */
+    index: number;
+    /** film seconds since the clip's window opened */
+    since: number;
+    /** the source time to show, seconds; null when frozen */
+    source: null | number;
+    spec: ClipSpec;
+    state: ClipState;
+}
+/** how long a clip's window is, in film seconds */
+export declare function clipWindow(spec: ClipSpec, beatStart: number, nextStart: number): number;
+/**
+ * The clip on screen at a film time, if any: the most recent beat at or
+ * before `index` whose clip's window holds the time, or whose end policy
+ * keeps it on screen past its window. Older clips are never reached past
+ * a newer one — a clip that was removed is gone, and one that is held is
+ * the one on screen.
+ */
+export declare function resolveClip(beats: readonly Beat[], beatStart: (i: number) => number, film: number, index: number, total: number, lane?: number): ResolvedClip | null;
+/** every lane any beat up to `index` puts a clip on, in order */
+export declare function clipLanes(beats: readonly Beat[], index: number): number[];
+/**
+ * EVERY CLIP ON SCREEN AT A FILM TIME, one per lane, in lane order — which
+ * is also paint order, so a score decides what sits over what by which
+ * lane it puts a thing on.
+ *
+ * A beat used to carry one clip and a second on the same shot overwrote
+ * the first without saying so. Lanes are the smallest thing that fixes
+ * that without inventing a track model: the resolver below is the old
+ * one, run once per lane.
+ */
+export declare function resolveClips(beats: readonly Beat[], beatStart: (i: number) => number, film: number, index: number, total: number): ResolvedClip[];
+//# sourceMappingURL=clips.d.ts.map

package/declarations/film/clips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clips.d.ts","sourceRoot":"","sources":["../../src/film/clips.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAEpD,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnD,MAAM,WAAW,QAAQ;IACvB,kEAAkE;IAClE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,CAAC;IAChC,oFAAoF;IACpF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;IACf;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,0EAA0E;IAC1E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,QAAQ;IACvB,4BAA4B;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEhE,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,mDAAmD;AACnD,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CASR;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,SAAI,GACP,YAAY,GAAG,IAAI,CAuCrB;AAgBD,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAMzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,YAAY,EAAE,CAShB"}