@glissade/core 0.39.0 → 0.40.0-pre.0

package/dist/clips.js

@@ -1,4 +1,5 @@
-import { C as inferValueType, i as resolveTweenTarget, m as track, s as key, t as TARGET_PATH } from "./targetRef.js";
+import { b as inferValueType, d as track, n as key } from "./track.js";
+import { i as resolveTweenTarget, t as TARGET_PATH } from "./targetRef.js";
 //#region src/clip.ts
 /**
 * Motion clips (DESIGN.md §2 build-time sugar): `clip()` captures a relative-time

package/dist/expr.d.ts

@@ -0,0 +1,32 @@
+import { i as Track } from "./track.js";
+
+//#region src/expr.d.ts
+
+declare class ExprError extends Error {
+  constructor(message: string);
+}
+/** A compiled expression: evaluate at a scope (must include `t`). */
+interface CompiledExpr {
+  /** the original source (serializable — a Track stores this). */
+  readonly source: string;
+  /** evaluate the formula; `scope.t` is the playhead time. Pure in its scope. */
+  eval(scope: Record<string, number>): number;
+}
+/**
+ * Compile an expression source to a {@link CompiledExpr}. Parses ONCE (fails loud
+ * on syntax / unknown function / arity / trailing tokens); `eval(scope)` is a fast
+ * pure closure. `scope.t` is the playhead time; add more vars (e.g. `i`, `n`) as
+ * the binding provides them.
+ */
+declare function compileExpr(source: string): CompiledExpr;
+/** The names available to an expression (for docs / a describe() surface). */
+declare const EXPR_FUNCTIONS: string[];
+declare const EXPR_CONSTANTS: string[];
+/**
+ * A raw formula-driven numeric track — `exprTrack('circle/opacity', '0.5 +
+ * 0.5*sin(t*3)')`. Sampled by evaluating the formula at the playhead `t` (no
+ * keys); compile-validated now (fail loud on bad syntax / unknown fn / arity).
+ */
+declare function exprTrack(target: string, formula: string): Track<number>;
+//#endregion
+export { CompiledExpr, EXPR_CONSTANTS, EXPR_FUNCTIONS, ExprError, compileExpr, exprTrack };

package/dist/expr.js

@@ -0,0 +1,344 @@
+import { c as setExprCompiler, r as makeExprTrack } from "./track.js";
+import { t as random } from "./rng.js";
+//#region src/expr.ts
+/**
+* `Expr` (0.40) — a deterministic math-expression evaluator for animating a prop
+* by a FORMULA of time: `expr('100 + 50*sin(t*2)')`. Compiles a source string ONCE
+* to a fast closure `(scope) => number`; the Track sampler evaluates it at the
+* playhead `t` through the SAME channel keyframe interpolation uses (so it's a pure
+* function of time, byte-identical run-to-run, and needs no ambient-time design —
+* glissade already threads `t` to the sampler).
+*
+* Grammar (arithmetic; no side effects): numbers, the variable `t` (+ any scope
+* var), `+ - * / % ^` (^ = pow, right-assoc), unary ±, parens, and a WHITELIST of
+* pure functions/constants. Determinism is enforced by construction: the only
+* randomness is `rand(x)` (a seeded hash → [0,1)); there is no `Date`/`Math.random`
+* reachable, and an unknown identifier/function fails loud at COMPILE time.
+*/
+var ExprError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExprError";
+	}
+};
+const fract = (x) => x - Math.floor(x);
+const clamp = (x, lo, hi) => x < lo ? lo : x > hi ? hi : x;
+const lerp = (a, b, t) => a + (b - a) * t;
+const smoothstep = (e0, e1, x) => {
+	const t = clamp(e1 === e0 ? 0 : (x - e0) / (e1 - e0), 0, 1);
+	return t * t * (3 - 2 * t);
+};
+/** deterministic hash of `x` → [0, 1) — the ONLY randomness (seeded, pure). */
+const rand = (x) => {
+	const buf = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	buf.setFloat64(0, x);
+	return random((buf.getUint32(0) ^ buf.getUint32(4)) >>> 0)();
+};
+const CONSTS = {
+	PI: Math.PI,
+	TAU: Math.PI * 2,
+	E: Math.E
+};
+const FNS = {
+	sin: {
+		fn: Math.sin,
+		arity: 1
+	},
+	cos: {
+		fn: Math.cos,
+		arity: 1
+	},
+	tan: {
+		fn: Math.tan,
+		arity: 1
+	},
+	asin: {
+		fn: Math.asin,
+		arity: 1
+	},
+	acos: {
+		fn: Math.acos,
+		arity: 1
+	},
+	atan: {
+		fn: Math.atan,
+		arity: 1
+	},
+	abs: {
+		fn: Math.abs,
+		arity: 1
+	},
+	sqrt: {
+		fn: Math.sqrt,
+		arity: 1
+	},
+	exp: {
+		fn: Math.exp,
+		arity: 1
+	},
+	log: {
+		fn: Math.log,
+		arity: 1
+	},
+	floor: {
+		fn: Math.floor,
+		arity: 1
+	},
+	ceil: {
+		fn: Math.ceil,
+		arity: 1
+	},
+	round: {
+		fn: Math.round,
+		arity: 1
+	},
+	sign: {
+		fn: Math.sign,
+		arity: 1
+	},
+	fract: {
+		fn: fract,
+		arity: 1
+	},
+	rand: {
+		fn: rand,
+		arity: 1
+	},
+	atan2: {
+		fn: Math.atan2,
+		arity: 2
+	},
+	pow: {
+		fn: Math.pow,
+		arity: 2
+	},
+	mod: {
+		fn: (a, b) => (a % b + b) % b,
+		arity: 2
+	},
+	step: {
+		fn: (edge, x) => x < edge ? 0 : 1,
+		arity: 2
+	},
+	min: {
+		fn: Math.min,
+		arity: "variadic"
+	},
+	max: {
+		fn: Math.max,
+		arity: "variadic"
+	},
+	clamp: {
+		fn: clamp,
+		arity: 3
+	},
+	lerp: {
+		fn: lerp,
+		arity: 3
+	},
+	mix: {
+		fn: lerp,
+		arity: 3
+	},
+	smoothstep: {
+		fn: smoothstep,
+		arity: 3
+	}
+};
+function tokenize(src) {
+	const toks = [];
+	let i = 0;
+	const n = src.length;
+	while (i < n) {
+		const c = src[i];
+		if (c === " " || c === "	" || c === "\n" || c === "\r") {
+			i++;
+			continue;
+		}
+		if (c === "(") {
+			toks.push({ k: "(" });
+			i++;
+			continue;
+		}
+		if (c === ")") {
+			toks.push({ k: ")" });
+			i++;
+			continue;
+		}
+		if (c === ",") {
+			toks.push({ k: "," });
+			i++;
+			continue;
+		}
+		if ("+-*/%^".includes(c)) {
+			toks.push({
+				k: "op",
+				v: c
+			});
+			i++;
+			continue;
+		}
+		if (c >= "0" && c <= "9" || c === ".") {
+			let j = i + 1;
+			while (j < n && /[0-9.eE+\-]/.test(src[j])) {
+				if ((src[j] === "+" || src[j] === "-") && !/[eE]/.test(src[j - 1])) break;
+				j++;
+			}
+			const num = Number(src.slice(i, j));
+			if (!Number.isFinite(num)) throw new ExprError(`invalid number '${src.slice(i, j)}' in expr`);
+			toks.push({
+				k: "num",
+				v: num
+			});
+			i = j;
+			continue;
+		}
+		if (/[a-zA-Z_]/.test(c)) {
+			let j = i + 1;
+			while (j < n && /[a-zA-Z0-9_]/.test(src[j])) j++;
+			toks.push({
+				k: "id",
+				v: src.slice(i, j)
+			});
+			i = j;
+			continue;
+		}
+		throw new ExprError(`unexpected character '${c}' in expr '${src}'`);
+	}
+	return toks;
+}
+const BINOP = {
+	"+": {
+		prec: 1,
+		apply: (a, b) => a + b
+	},
+	"-": {
+		prec: 1,
+		apply: (a, b) => a - b
+	},
+	"*": {
+		prec: 2,
+		apply: (a, b) => a * b
+	},
+	"/": {
+		prec: 2,
+		apply: (a, b) => a / b
+	},
+	"%": {
+		prec: 2,
+		apply: (a, b) => (a % b + b) % b
+	},
+	"^": {
+		prec: 4,
+		rightAssoc: true,
+		apply: (a, b) => Math.pow(a, b)
+	}
+};
+function parse(src) {
+	const toks = tokenize(src);
+	if (toks.length === 0) throw new ExprError(`empty expr`);
+	let p = 0;
+	const peek = () => toks[p];
+	const next = () => toks[p++];
+	function parsePrimary() {
+		const t = peek();
+		if (!t) throw new ExprError(`unexpected end of expr '${src}'`);
+		if (t.k === "op" && (t.v === "-" || t.v === "+")) {
+			next();
+			const operand = parseUnary();
+			return t.v === "-" ? (s) => -operand(s) : operand;
+		}
+		if (t.k === "num") {
+			next();
+			return () => t.v;
+		}
+		if (t.k === "(") {
+			next();
+			const e = parseExpr(0);
+			if (peek()?.k !== ")") throw new ExprError(`missing ')' in expr '${src}'`);
+			next();
+			return e;
+		}
+		if (t.k === "id") {
+			next();
+			const name = t.v;
+			if (peek()?.k === "(") {
+				next();
+				const args = [];
+				if (peek()?.k !== ")") {
+					args.push(parseExpr(0));
+					while (peek()?.k === ",") {
+						next();
+						args.push(parseExpr(0));
+					}
+				}
+				if (peek()?.k !== ")") throw new ExprError(`missing ')' after ${name}(… in expr '${src}'`);
+				next();
+				const spec = FNS[name];
+				if (!spec) throw new ExprError(`unknown function '${name}' in expr '${src}' (have: ${Object.keys(FNS).join(", ")})`);
+				if (spec.arity !== "variadic" && spec.arity !== args.length) throw new ExprError(`${name}() takes ${spec.arity} arg(s), got ${args.length}`);
+				return (s) => spec.fn(...args.map((a) => a(s)));
+			}
+			if (name in CONSTS) {
+				const v = CONSTS[name];
+				return () => v;
+			}
+			return (s) => {
+				const v = s[name];
+				if (v === void 0) throw new ExprError(`unknown variable '${name}' in expr '${src}' (scope has: ${Object.keys(s).join(", ") || "nothing"})`);
+				return v;
+			};
+		}
+		throw new ExprError(`unexpected token in expr '${src}'`);
+	}
+	function parseUnary() {
+		return parsePrimary();
+	}
+	function parseExpr(minPrec) {
+		let left = parseUnary();
+		for (;;) {
+			const t = peek();
+			if (!t || t.k !== "op") break;
+			const op = BINOP[t.v];
+			if (!op || op.prec < minPrec) break;
+			next();
+			const right = parseExpr(op.rightAssoc ? op.prec : op.prec + 1);
+			const l = left;
+			left = (s) => op.apply(l(s), right(s));
+		}
+		return left;
+	}
+	const root = parseExpr(0);
+	if (p !== toks.length) throw new ExprError(`unexpected trailing tokens in expr '${src}'`);
+	return root;
+}
+/**
+* Compile an expression source to a {@link CompiledExpr}. Parses ONCE (fails loud
+* on syntax / unknown function / arity / trailing tokens); `eval(scope)` is a fast
+* pure closure. `scope.t` is the playhead time; add more vars (e.g. `i`, `n`) as
+* the binding provides them.
+*/
+function compileExpr(source) {
+	const node = parse(source);
+	return {
+		source,
+		eval: (scope) => node(scope)
+	};
+}
+/** The names available to an expression (for docs / a describe() surface). */
+const EXPR_FUNCTIONS = Object.keys(FNS);
+const EXPR_CONSTANTS = Object.keys(CONSTS);
+/**
+* A raw formula-driven numeric track — `exprTrack('circle/opacity', '0.5 +
+* 0.5*sin(t*3)')`. Sampled by evaluating the formula at the playhead `t` (no
+* keys); compile-validated now (fail loud on bad syntax / unknown fn / arity).
+*/
+function exprTrack(target, formula) {
+	return makeExprTrack(target, formula);
+}
+setExprCompiler((src) => {
+	const c = compileExpr(src);
+	return (t) => c.eval({ t });
+});
+//#endregion
+export { EXPR_CONSTANTS, EXPR_FUNCTIONS, ExprError, compileExpr, exprTrack };

package/dist/index.js

@@ -1,4 +1,6 @@
-import { A as stringType, B as emitDevWarning, C as inferValueType, D as pathType, E as paintType, F as formatColor, G as springPresets, H as spring, I as lerpColor, J as cubicBezier, K as DEFAULT_EASE, L as oklabToRgba, M as vec2Equals, N as vec2Type, O as registerValueType, P as ColorParseError, Q as namedEasing, R as parseColor, S as getValueType, T as numberType, U as springEasing, V as setDevWarning, W as springEasingDerivative, X as easingDerivatives, Y as cubicBezierDerivative, Z as easings, _ as UnknownValueTypeError, a as targetNodeId, b as colorType, c as resolveEase, d as sampleTrack, f as springTo, g as velocityAt, h as validateTrack, i as resolveTweenTarget, j as vec2ArcType, k as reprOf, l as resolveEaseDerivative, m as track, n as UnresolvableTargetError, o as TrackValidationError, p as stagger, q as UnknownEasingError, r as isEditableNodeId, s as key, t as TARGET_PATH, u as retime, v as ValueTypeInferenceError, w as listValueTypes, x as fontAxesType, y as booleanType, z as rgbaToOklab } from "./targetRef.js";
+import { A as vec2Type, B as springEasing, C as paintType, D as stringType, E as reprOf, F as parseColor, G as cubicBezier, H as springPresets, I as rgbaToOklab, J as easings, K as cubicBezierDerivative, L as emitDevWarning, M as formatColor, N as lerpColor, O as vec2ArcType, P as oklabToRgba, R as setDevWarning, S as numberType, T as registerValueType, U as DEFAULT_EASE, V as springEasingDerivative, W as UnknownEasingError, Y as namedEasing, _ as colorType, a as resolveEaseDerivative, b as inferValueType, d as track, f as validateTrack, g as booleanType, h as ValueTypeInferenceError, i as resolveEase, j as ColorParseError, k as vec2Equals, l as springTo, m as UnknownValueTypeError, n as key, o as retime, p as velocityAt, q as easingDerivatives, s as sampleTrack, t as TrackValidationError, u as stagger, v as fontAxesType, w as pathType, x as listValueTypes, y as getValueType, z as spring } from "./track.js";
+import { a as targetNodeId, i as resolveTweenTarget, n as UnresolvableTargetError, r as isEditableNodeId, t as TARGET_PATH } from "./targetRef.js";
+import { t as random } from "./rng.js";
 import { t as parseCmap } from "./cmap.js";
 import { a as isDurationEditable, i as compileTimeline, n as audioOffsetSamples, o as namespaceCallName, r as callMarkerPrefix, s as timeline$1, t as TimelineValidationError } from "./timeline.js";
 //#region src/ticker.ts
@@ -1002,21 +1004,6 @@ function evaluateAt(playhead, t, read) {
 	}
 }
 //#endregion
-//#region src/rng.ts
-/** Returns a deterministic [0,1) generator for the given integer seed. */
-function random(seed) {
-	let a = seed >>> 0;
-	return () => {
-		a = a + 2654435769 | 0;
-		let t = a ^ a >>> 16;
-		t = Math.imul(t, 569420461);
-		t = t ^ t >>> 15;
-		t = Math.imul(t, 1935289751);
-		t = t ^ t >>> 15;
-		return (t >>> 0) / 4294967296;
-	};
-}
-//#endregion
 //#region src/bake.ts
 /**
 * bake() (DESIGN.md §2.8): stateful simulation as a compilation step. Run the

package/dist/rng.js

@@ -0,0 +1,16 @@
+//#region src/rng.ts
+/** Returns a deterministic [0,1) generator for the given integer seed. */
+function random(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 2654435769 | 0;
+		let t = a ^ a >>> 16;
+		t = Math.imul(t, 569420461);
+		t = t ^ t >>> 15;
+		t = Math.imul(t, 1935289751);
+		t = t ^ t >>> 15;
+		return (t >>> 0) / 4294967296;
+	};
+}
+//#endregion
+export { random as t };

package/dist/sidecar.js

@@ -1,4 +1,5 @@
-import { B as emitDevWarning, H as spring, a as targetNodeId, o as TrackValidationError, r as isEditableNodeId } from "./targetRef.js";
+import { L as emitDevWarning, t as TrackValidationError, z as spring } from "./track.js";
+import { a as targetNodeId, r as isEditableNodeId } from "./targetRef.js";
 //#region src/sidecar.ts
 /**
 * The editor sidecar (DESIGN.md §6.2): code declares scene structure and