@glissade/scene 0.57.1-pre.0 → 0.58.0-pre.0

package/dist/describe.js

@@ -23,7 +23,7 @@ import { easings, listValueTypes } from "@glissade/core";
 * never pulled onto the base embed path — a scene that never calls `describe()`
 * pays zero bytes for it.
 */
-const RAW_VERSION = "0.57.1-pre.0";
+const RAW_VERSION = "0.58.0-pre.0";
 const PACKAGE_VERSION = RAW_VERSION.includes("GLISSADE_".concat("VERSION")) ? "0.0.0-dev" : RAW_VERSION;
 /**
 * Parse the documented positional-arg count from a helper `usage` string — the
@@ -682,7 +682,7 @@ const HELPERS = [
 		name: "typeOn",
 		summary: "Kinetic type: one-call typewriter over the shipped typewriter(). DEFAULT emits a STRING hold-key track on `<id>/text` (round-trips to Lottie as stepped text docs). { cursor: true } adds a render-only caret sibling (export warns+drops it); { mask: true } swaps to a render-only `<id>/reveal` grapheme mask (export warns 'reveal not exported'). Factory (no `new`). Inject with tl.tracks([r.track]); draw r.node (+ r.cursor). On @glissade/scene/type.",
 		import: "@glissade/scene/type",
-		usage: "typeOn(source: Text | TextProps, opts?: { perChar?, start?, cursor?: boolean, mask?: boolean, cursorWidth?, blinkPeriod? }): { node: Text, cursor?: TextCursor, track: Track, marks, duration }"
+		usage: "typeOn(source: Text | TextProps, opts?: { perChar?, start?, cursor?: boolean, mask?: boolean, cursorWidth?, blinkPeriod?, cursorFill?, cursorProps? }): { node: Text, cursor?: TextCursor, track: Track, marks, duration } — cursorFill sets a contrasting caret color (default follows text fill); cursorProps forwards any other TextCursor prop"
 	},
 	{
 		name: "revealWords",

package/dist/gradient.d.ts

@@ -0,0 +1,16 @@
+import { ColorStop, GradientInterpolation } from "@glissade/core";
+
+//#region src/gradient.d.ts
+
+/** Resolution of the densified ramp — enough that the piecewise-linear blit of
+ * the easing curve shows no banding, cheap enough to rebuild per frame. */
+declare const GRADIENT_RAMP_STEPS = 64;
+/**
+ * Densify `stops` into a `smooth`/`gaussian` oklab ramp. The output spans the
+ * input's offset range with GRADIENT_RAMP_STEPS uniformly-spaced stops; each
+ * point eases its blend within the authored segment it falls in. Returns the
+ * input unchanged for `linear` (or a single stop) — the canvas-native path.
+ */
+declare function densifyStops(stops: ColorStop[], mode: GradientInterpolation): ColorStop[];
+//#endregion
+export { GRADIENT_RAMP_STEPS, densifyStops };

package/dist/gradient.js

@@ -0,0 +1,48 @@
+import { lerpColor } from "@glissade/core";
+//#region src/gradient.ts
+/**
+* Gradient stop densification (§3 Paint, 0.10.1). Canvas gradients interpolate
+* BETWEEN stops linearly in the canvas color space, which Mach-bands a 2-3 stop
+* soft-light fill. For `smooth`/`gaussian` interpolation we resample the stops
+* into a dense ramp eased per-segment with oklab `lerpColor`, so the blit melts
+* like a wide blur with no banding and no filter. Pure + deterministic: the same
+* (stops, mode) always produce the same dense stops, so Skia stays byte-exact.
+* `linear` is the canvas-native ramp and is never densified (byte-identical).
+*/
+/** Resolution of the densified ramp — enough that the piecewise-linear blit of
+* the easing curve shows no banding, cheap enough to rebuild per frame. */
+const GRADIENT_RAMP_STEPS = 64;
+const smoothstep = (u) => u * u * (3 - 2 * u);
+const GAUSS_K = 2.4;
+const GAUSS_NORM = 1 - Math.exp(-5.76 / 2);
+const gaussianEase = (u) => (1 - Math.exp(-((u * GAUSS_K) ** 2) / 2)) / GAUSS_NORM;
+/**
+* Densify `stops` into a `smooth`/`gaussian` oklab ramp. The output spans the
+* input's offset range with GRADIENT_RAMP_STEPS uniformly-spaced stops; each
+* point eases its blend within the authored segment it falls in. Returns the
+* input unchanged for `linear` (or a single stop) — the canvas-native path.
+*/
+function densifyStops(stops, mode) {
+	if (mode === "linear" || stops.length < 2) return stops;
+	const ease = mode === "gaussian" ? gaussianEase : smoothstep;
+	const o0 = stops[0].offset;
+	const span = stops[stops.length - 1].offset - o0;
+	if (span <= 0) return stops;
+	const out = [];
+	let seg = 0;
+	for (let i = 0; i < 64; i++) {
+		const offset = o0 + span * (i / 63);
+		while (seg < stops.length - 2 && offset > stops[seg + 1].offset) seg++;
+		const a = stops[seg];
+		const b = stops[seg + 1];
+		const w = b.offset - a.offset;
+		const u = w > 0 ? Math.min(1, Math.max(0, (offset - a.offset) / w)) : 0;
+		out.push({
+			offset,
+			color: lerpColor(a.color, b.color, ease(u))
+		});
+	}
+	return out;
+}
+//#endregion
+export { GRADIENT_RAMP_STEPS, densifyStops };

package/dist/index.js

@@ -3,8 +3,9 @@ import { a as evaluate, i as createScene, n as ReservedNodeIdError, r as bindSce
 import { i as setLayoutEngine, n as getLayoutEngine, r as requireLayoutEngine, t as LayoutEngineMissingError } from "./layoutEngine.js";
 import { n as TextCursor, r as textCursor, t as typewriter } from "./typewriter.js";
 import { i as echo, n as motionBlur, r as Echo, t as MotionBlur } from "./motionBlur.js";
+import { densifyStops } from "./gradient.js";
 import { n as each, t as EachError } from "./each.js";
-import { emitDevWarning, key, lerpColor, oklabToRgba, parseColor, rgbaToOklab, signal, stagger, track } from "@glissade/core";
+import { emitDevWarning, key, oklabToRgba, parseColor, rgbaToOklab, signal, stagger, track } from "@glissade/core";
 //#region src/taxonomy.ts
 /**
 * The CLOSED node taxonomy (DESIGN.md §3.1): exactly nine built-in node TYPES.
@@ -323,38 +324,6 @@ function trackMatte(content, matte, props = {}) {
 		matte
 	});
 }
-const smoothstep = (u) => u * u * (3 - 2 * u);
-const GAUSS_K = 2.4;
-const GAUSS_NORM = 1 - Math.exp(-5.76 / 2);
-const gaussianEase = (u) => (1 - Math.exp(-((u * GAUSS_K) ** 2) / 2)) / GAUSS_NORM;
-/**
-* Densify `stops` into a `smooth`/`gaussian` oklab ramp. The output spans the
-* input's offset range with GRADIENT_RAMP_STEPS uniformly-spaced stops; each
-* point eases its blend within the authored segment it falls in. Returns the
-* input unchanged for `linear` (or a single stop) — the canvas-native path.
-*/
-function densifyStops(stops, mode) {
-	if (mode === "linear" || stops.length < 2) return stops;
-	const ease = mode === "gaussian" ? gaussianEase : smoothstep;
-	const o0 = stops[0].offset;
-	const span = stops[stops.length - 1].offset - o0;
-	if (span <= 0) return stops;
-	const out = [];
-	let seg = 0;
-	for (let i = 0; i < 64; i++) {
-		const offset = o0 + span * (i / 63);
-		while (seg < stops.length - 2 && offset > stops[seg + 1].offset) seg++;
-		const a = stops[seg];
-		const b = stops[seg + 1];
-		const w = b.offset - a.offset;
-		const u = w > 0 ? Math.min(1, Math.max(0, (offset - a.offset) / w)) : 0;
-		out.push({
-			offset,
-			color: lerpColor(a.color, b.color, ease(u))
-		});
-	}
-	return out;
-}
 //#endregion
 //#region src/meshGradient.ts
 /**

package/dist/type.d.ts

@@ -1,5 +1,5 @@
 import { K as TextMeasurer, a as Group, c as LineBox, h as TextProps, i as GraphemeBox, m as Text, v as WordBox } from "./nodes.js";
-import { o as TextCursor, t as EditMark } from "./typewriter.js";
+import { o as TextCursor, s as TextCursorProps, t as EditMark } from "./typewriter.js";
 import { EaseSpec, Track } from "@glissade/core";
 
 //#region src/type.d.ts
@@ -139,6 +139,20 @@ interface TypeOnOpts {
   cursorWidth?: number;
   /** Caret blink period seconds when `cursor: true` (passthrough to textCursor). */
   blinkPeriod?: number;
+  /**
+   * Caret COLOR when `cursor: true` (passthrough to the textCursor sibling's `fill`).
+   * Default '' = follow the Text's own fill; set a hex/PropInit for a deliberately
+   * contrasting caret (bindable via the `<id>/cursor/fill` track). Ignored without `cursor`.
+   */
+  cursorFill?: TextCursorProps['fill'];
+  /**
+   * Escape hatch: any other {@link TextCursor} construction prop (e.g. `blinkPeriod`,
+   * `width`, or a NodeProp) forwarded to the caret sibling when `cursor: true`. The
+   * explicit `cursorWidth`/`blinkPeriod`/`cursorFill` options win over the matching
+   * key here, and the caret's `id` (`<id>/cursor`) is always set by typeOn. Ignored
+   * without `cursor`.
+   */
+  cursorProps?: Omit<TextCursorProps, 'text' | 'id'>;
 }
 interface TypeOnResult {
   /** The Text to draw. In the DEFAULT (string-track) mode its `text` is driven by

package/dist/type.js

@@ -252,9 +252,11 @@ function typeOn(source, opts = {}) {
 		duration: tw.duration
 	};
 	if (opts.cursor) result.cursor = textCursor(node, {
+		...opts.cursorProps ?? {},
 		id: `${id}/cursor`,
 		...opts.cursorWidth !== void 0 ? { width: opts.cursorWidth } : {},
-		...opts.blinkPeriod !== void 0 ? { blinkPeriod: opts.blinkPeriod } : {}
+		...opts.blinkPeriod !== void 0 ? { blinkPeriod: opts.blinkPeriod } : {},
+		...opts.cursorFill !== void 0 ? { fill: opts.cursorFill } : {}
 	});
 	return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/scene",
-  "version": "0.57.1-pre.0",
+  "version": "0.58.0-pre.0",
   "description": "glissade scene graph: nodes, transforms, DisplayList emission. Renderer-agnostic; zero DOM/Node dependencies.",
   "license": "Apache-2.0",
   "engines": {
@@ -63,6 +63,10 @@
       "types": "./dist/motion.d.ts",
       "default": "./dist/motion.js"
     },
+    "./gradient": {
+      "types": "./dist/gradient.d.ts",
+      "default": "./dist/gradient.js"
+    },
     "./identity": {
       "types": "./dist/identity.d.ts",
       "default": "./dist/identity.js"
@@ -77,7 +81,7 @@
   ],
   "dependencies": {
     "yoga-layout": "^3.2.1",
-    "@glissade/core": "0.57.1-pre.0"
+    "@glissade/core": "0.58.0-pre.0"
   },
   "repository": {
     "type": "git",