@roobscoob/vibes 0.0.0-stage → 0.1.0

package/dist/parse.js

@@ -0,0 +1,208 @@
+// Colors from text, read as generously as can be: anything CSS takes (hex
+// codes with or without #, names, rgb(), hsl(), hwb(), oklch(), oklab(),
+// lab(), lch(), color()), color temperatures ("2700K", "candlelight"), the
+// lights' own ("lemtone(265 0.3 40)", or "265° C0.30 · 40 lm" as a color
+// prints itself), and any of those with lumens or a fidelity alongside
+// ("#f80 · 120 lm", "2700K @ 400lm").
+//
+// This only reads the text: what it says comes back as a Spec, and color.ts
+// makes the color.
+import { cssNamed, LIGHT_NAMES } from "./names.js";
+const NUMBER = /^([-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(%|deg|rad|grad|turn)?$/;
+function token(text) {
+    if (text === "none")
+        return { value: 0, unit: "" };
+    const m = NUMBER.exec(text);
+    return m ? { value: Number(m[1]), unit: (m[2] ?? "") } : null;
+}
+/** An angle in degrees. */
+function angle(t) {
+    if (t.unit === "rad")
+        return (t.value * 180) / Math.PI;
+    if (t.unit === "grad")
+        return t.value * 0.9;
+    if (t.unit === "turn")
+        return t.value * 360;
+    return t.value;
+}
+/** A number, with 100% as `hundred`. */
+const scaled = (t, hundred) => (t.unit === "%" ? (t.value / 100) * hundred : t.value);
+/** A fraction 0–1, from a percentage, or a number: 0–1 as it is, past 1 read as a percentage (hsl(240, 100, 50)). */
+const fraction = (t) => (t.unit === "%" || Math.abs(t.value) > 1 ? t.value / 100 : t.value);
+/** Lightness 0–1, from a percentage, or a number: 0–1 as it is, past 1 read as a percentage (oklch(70 0.2 265)). */
+const lightness = fraction;
+/** What `text` says a color is, or null if it can't be read. */
+export function parseColor(text) {
+    const s = text.trim().toLowerCase();
+    if (!s)
+        return null;
+    const whole = one(s);
+    if (whole)
+        return whole;
+    // A color, its lumens and its fidelity, in any order: "#f80 · 120 lm", "2700k @ 400lm", "2700k 400lm".
+    const found = {};
+    for (const part of s.split(/\s*[·@]\s*/)) {
+        if (!part || read(part, found))
+            continue;
+        if (part.includes("("))
+            return null;
+        // Word by word, a number with the unit after it first ("50 lumens", "fidelity 0.5").
+        const words = part.split(/\s+/);
+        for (let i = 0; i < words.length; i++) {
+            if (i + 1 < words.length && read(`${words[i]} ${words[i + 1]}`, found))
+                i++;
+            else if (!read(words[i], found))
+                return null;
+        }
+    }
+    if (!found.spec)
+        return null;
+    if (found.lm !== undefined)
+        found.spec.lm = found.lm;
+    if (found.fidelity !== undefined)
+        found.spec.fidelity = found.fidelity;
+    return found.spec;
+}
+/** One part of a longer text, into `found`: lumens ("400 lm"), a fidelity ("F0.50"), or the color. */
+function read(part, found) {
+    let m;
+    if ((m = /^([-+]?(?:\d+\.?\d*|\.\d+))\s*(?:lm|lumens?)$/.exec(part))) {
+        found.lm = Number(m[1]);
+        return true;
+    }
+    // "f0.5" needs its point, so it isn't taken for a hex code like "f80".
+    if ((m = /^(?:f(\d*\.\d+)|fidelity\s*[:=]?\s*(\d*\.?\d+))$/.exec(part))) {
+        found.fidelity = Number(m[1] ?? m[2]);
+        return true;
+    }
+    const c = one(part);
+    if (!c || found.spec)
+        return false;
+    found.spec = c;
+    return true;
+}
+/** One color, alone. */
+function one(s) {
+    if (s === "off" || s === "none" || s === "dark" || s === "transparent")
+        return { space: "off" };
+    const name = cssNamed(s.replace(/[\s_-]/g, ""));
+    if (name)
+        return hex(name);
+    const kelvin = LIGHT_NAMES[s.replace(/[\s_-]/g, "")];
+    if (kelvin)
+        return { space: "kelvin", kelvin };
+    let m;
+    if ((m = /^(\d+(?:\.\d+)?)\s*(?:k|kelvin)$/.exec(s)))
+        return { space: "kelvin", kelvin: Number(m[1]) };
+    // As a color prints itself: "265° c0.300".
+    if ((m = /^([-+]?\d+(?:\.\d+)?)\s*(?:°|deg)\s*c\s*(\d*\.?\d+)$/.exec(s)))
+        return { space: "lemtone", hue: Number(m[1]), chroma: Number(m[2]) };
+    if (/^#?(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(s))
+        return hex(s.replace("#", ""));
+    if ((m = /^([a-z][a-z0-9-]*)\((.*)\)$/.exec(s)))
+        return fn(m[1], m[2]);
+    return null;
+}
+/** Hex digits (3, 4, 6 or 8 of them, the last as alpha) as sRGB. */
+function hex(digits) {
+    const full = digits.length <= 4 ? [...digits].map((d) => d + d).join("") : digits;
+    const at = (i) => parseInt(full.slice(i, i + 2), 16) / 255;
+    const spec = { space: "srgb", rgb: [at(0), at(2), at(4)] };
+    if (full.length === 8)
+        spec.alpha = at(6);
+    return spec;
+}
+/** A function: rgb(…), oklch(…), color(display-p3 …), lemtone(…), … */
+function fn(name, inside) {
+    const [main = "", alphaText] = inside.split("/");
+    const words = main.trim().split(/[\s,]+/).filter(Boolean);
+    let space;
+    if (name === "color")
+        space = words.shift();
+    const t = words.map(token);
+    if (t.some((x) => x === null))
+        return null;
+    const v = t;
+    // Old-style rgba(1, 2, 3, 0.5): a fourth number is alpha.
+    let alpha;
+    if (alphaText !== undefined) {
+        const a = token(alphaText.trim());
+        if (!a)
+            return null;
+        alpha = scaled(a, 1);
+    }
+    else if (v.length === 4 && name !== "lemtone")
+        alpha = scaled(v.pop(), 1);
+    const spec = make(name, space, v);
+    if (spec && alpha !== undefined)
+        spec.alpha = alpha;
+    return spec;
+}
+function make(name, space, v) {
+    const need = (n) => v.length >= n;
+    switch (name) {
+        case "rgb":
+        case "rgba":
+            if (!need(3))
+                return null;
+            return { space: "srgb", rgb: [scaled(v[0], 255) / 255, scaled(v[1], 255) / 255, scaled(v[2], 255) / 255] };
+        case "hsl":
+        case "hsla":
+            if (!need(3))
+                return null;
+            return { space: "hsl", h: angle(v[0]), s: fraction(v[1]), l: fraction(v[2]) };
+        case "hwb":
+            if (!need(3))
+                return null;
+            return { space: "hwb", h: angle(v[0]), w: fraction(v[1]), b: fraction(v[2]) };
+        case "oklab":
+            if (!need(3))
+                return null;
+            return { space: "oklab", lab: [lightness(v[0]), scaled(v[1], 0.4), scaled(v[2], 0.4)] };
+        case "oklch":
+            if (!need(3))
+                return null;
+            return { space: "oklch", l: lightness(v[0]), c: scaled(v[1], 0.4), h: angle(v[2]) };
+        case "lab":
+            if (!need(3))
+                return null;
+            return { space: "lab", lab: [scaled(v[0], 100), scaled(v[1], 125), scaled(v[2], 125)] };
+        case "lch":
+            if (!need(3))
+                return null;
+            return { space: "lch", l: scaled(v[0], 100), c: scaled(v[1], 150), h: angle(v[2]) };
+        case "color": {
+            if (!need(3))
+                return null;
+            const c = [scaled(v[0], 1), scaled(v[1], 1), scaled(v[2], 1)];
+            if (space === "srgb" || space === "srgb-linear" || space === "display-p3")
+                return { space, rgb: c };
+            if (space === "xyz" || space === "xyz-d65")
+                return { space: "xyz", xyz: c };
+            if (space === "xyz-d50")
+                return { space: "xyz-d50", xyz: c };
+            return null;
+        }
+        case "lemtone": {
+            if (!need(2))
+                return null;
+            const spec = { space: "lemtone", hue: angle(v[0]), chroma: v[1].value };
+            if (v[2])
+                spec.lm = v[2].value;
+            if (v[3])
+                spec.fidelity = v[3].value;
+            return spec;
+        }
+        case "white":
+        case "kelvin": {
+            if (!need(1))
+                return null;
+            const spec = { space: "kelvin", kelvin: v[0].value };
+            if (v[1])
+                spec.lm = v[1].value;
+            return spec;
+        }
+        default:
+            return null;
+    }
+}

package/dist/shape.d.ts

@@ -0,0 +1,44 @@
+/** The fractional part: 2.25 → 0.25, -0.25 → 0.75. */
+export declare const fract: (x: number) => number;
+export declare const clamp: (x: number, lo?: number, hi?: number) => number;
+/** From a (at t = 0) to b (at t = 1). */
+export declare const lerp: (a: number, b: number, t: number) => number;
+/** x from the range [inLo, inHi] to [outLo, outHi], not clamped. */
+export declare const remap: (x: number, inLo: number, inHi: number, outLo?: number, outHi?: number) => number;
+/** 0 below e0, 1 above e1, and a smooth S between. */
+export declare function smoothstep(e0: number, e1: number, x: number): number;
+/** A smooth wave, one cycle per unit: 0 at whole numbers, 1 halfway between. */
+export declare const wave: (x: number) => number;
+/** Rises from 0 to 1 over each cycle, then drops back at once. */
+export declare const saw: (x: number) => number;
+/** Rises from 0 to 1 over the first half of each cycle and falls back over the second. */
+export declare const tri: (x: number) => number;
+/** 1 for the first `duty` of each cycle, 0 for the rest: a hard on and off. */
+export declare const square: (x: number, duty?: number) => 0 | 1;
+/** Easings, 0 to 1 onto 0 to 1 (cubic). */
+export declare const ease: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+/** A number from 0 to 1 that looks random but is always the same for the same inputs. */
+export declare function hash(...ns: number[]): number;
+/**
+ * Smooth noise from 0 to 1, in up to three dimensions: nearby inputs give
+ * nearby values, and features are about 1 unit apart. noiseAt(x / 4, y / 4,
+ * t / 5) makes blobs about 4 m across that change over about 5 s.
+ */
+export declare function noiseAt(x: number, y?: number, z?: number): number;
+/**
+ * How much of something is left after dt seconds, if half goes every
+ * `halfLife` seconds: value *= decay(dt, 2) halves it every 2 s, whatever the
+ * tick rate.
+ */
+export declare const decay: (dt: number, halfLife: number) => number;
+/**
+ * True with the chance of something that happens `perSecond` times a second
+ * on average, over the last dt seconds: the same in the room (100 ticks a
+ * second) as in the preview (about 30).
+ */
+export declare const chance: (perSecond: number, dt: number) => boolean;
+//# sourceMappingURL=shape.d.ts.map

package/dist/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../src/shape.ts"],"names":[],"mappings":"AAMA,sDAAsD;AACtD,eAAO,MAAM,KAAK,MAAO,MAAM,WAAsB,CAAC;AAEtD,eAAO,MAAM,KAAK,MAAO,MAAM,qCAAoD,CAAC;AAEpF,yCAAyC;AACzC,eAAO,MAAM,IAAI,MAAO,MAAM,KAAK,MAAM,KAAK,MAAM,WAAoB,CAAC;AAEzE,oEAAoE;AACpE,eAAO,MAAM,KAAK,MAAO,MAAM,QAAQ,MAAM,QAAQ,MAAM,2CACE,CAAC;AAE9D,sDAAsD;AACtD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED,gFAAgF;AAChF,eAAO,MAAM,IAAI,MAAO,MAAM,WAAkC,CAAC;AAEjE,kEAAkE;AAClE,eAAO,MAAM,GAAG,MAAO,MAAM,WAAa,CAAC;AAE3C,0FAA0F;AAC1F,eAAO,MAAM,GAAG,MAAO,MAAM,WAAmC,CAAC;AAEjE,+EAA+E;AAC/E,eAAO,MAAM,MAAM,MAAO,MAAM,yBAA0C,CAAC;AAE3E,2CAA2C;AAC3C,eAAO,MAAM,IAAI;IACf,EAAE,MAAM,MAAM;IACd,GAAG,MAAM,MAAM;IACf,KAAK,MAAM,MAAM;CAIlB,CAAC;AAMF,yFAAyF;AACzF,wBAAgB,IAAI,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,GAAG,MAAM,CAQ5C;AAiBD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,GAAG,MAAM,CAavD;AAED;;;;GAIG;AACH,eAAO,MAAM,KAAK,OAAQ,MAAM,YAAY,MAAM,WAAgD,CAAC;AAEnG;;;;GAIG;AACH,eAAO,MAAM,MAAM,cAAe,MAAM,MAAM,MAAM,YAAkD,CAAC"}

package/dist/shape.js

@@ -0,0 +1,89 @@
+// Numbers to numbers: waves, easing, ranges, hashing, noise, and time steps.
+// Waves count in cycles: wave(t / 8) goes round once every 8 seconds. They
+// all run 0 to 1, starting at 0, so they make good brightnesses and mixes.
+const TAU = 2 * Math.PI;
+/** The fractional part: 2.25 → 0.25, -0.25 → 0.75. */
+export const fract = (x) => x - Math.floor(x);
+export const clamp = (x, lo = 0, hi = 1) => (x < lo ? lo : x > hi ? hi : x);
+/** From a (at t = 0) to b (at t = 1). */
+export const lerp = (a, b, t) => a + (b - a) * t;
+/** x from the range [inLo, inHi] to [outLo, outHi], not clamped. */
+export const remap = (x, inLo, inHi, outLo = 0, outHi = 1) => outLo + ((x - inLo) / (inHi - inLo || 1)) * (outHi - outLo);
+/** 0 below e0, 1 above e1, and a smooth S between. */
+export function smoothstep(e0, e1, x) {
+    const t = clamp((x - e0) / (e1 - e0 || 1));
+    return t * t * (3 - 2 * t);
+}
+/** A smooth wave, one cycle per unit: 0 at whole numbers, 1 halfway between. */
+export const wave = (x) => 0.5 - 0.5 * Math.cos(TAU * x);
+/** Rises from 0 to 1 over each cycle, then drops back at once. */
+export const saw = (x) => fract(x);
+/** Rises from 0 to 1 over the first half of each cycle and falls back over the second. */
+export const tri = (x) => 1 - Math.abs(2 * fract(x) - 1);
+/** 1 for the first `duty` of each cycle, 0 for the rest: a hard on and off. */
+export const square = (x, duty = 0.5) => (fract(x) < duty ? 1 : 0);
+/** Easings, 0 to 1 onto 0 to 1 (cubic). */
+export const ease = {
+    in: (x) => clamp(x) ** 3,
+    out: (x) => 1 - (1 - clamp(x)) ** 3,
+    inOut: (x) => {
+        const t = clamp(x);
+        return t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+    },
+};
+// Each number's exact bits, so any number (not only whole ones) hashes.
+const bits = new Float64Array(1);
+const words = new Uint32Array(bits.buffer);
+/** A number from 0 to 1 that looks random but is always the same for the same inputs. */
+export function hash(...ns) {
+    let h = 0x9e3779b9;
+    for (const n of ns) {
+        bits[0] = n === 0 ? 0 : n; // -0 and 0 hash the same
+        h = mixBits(h ^ words[0]);
+        h = mixBits(h ^ words[1]);
+    }
+    return (h >>> 0) / 4294967296;
+}
+function mixBits(h) {
+    h = Math.imul(h ^ (h >>> 16), 0x85ebca6b);
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
+    return h ^ (h >>> 16);
+}
+// Whole-number lattice hashing for noise: faster than hash() and as good there.
+function lattice(x, y, z) {
+    let h = Math.imul(x, 0x27d4eb2d) ^ Math.imul(y, 0x165667b1) ^ Math.imul(z, 0x9e3779b1);
+    h = mixBits(h);
+    return (h >>> 0) / 4294967296;
+}
+const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+/**
+ * Smooth noise from 0 to 1, in up to three dimensions: nearby inputs give
+ * nearby values, and features are about 1 unit apart. noiseAt(x / 4, y / 4,
+ * t / 5) makes blobs about 4 m across that change over about 5 s.
+ */
+export function noiseAt(x, y = 0, z = 0) {
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    const zi = Math.floor(z);
+    const u = fade(x - xi);
+    const v = fade(y - yi);
+    const w = fade(z - zi);
+    const c = (dx, dy, dz) => lattice(xi + dx, yi + dy, zi + dz);
+    const x00 = lerp(c(0, 0, 0), c(1, 0, 0), u);
+    const x10 = lerp(c(0, 1, 0), c(1, 1, 0), u);
+    const x01 = lerp(c(0, 0, 1), c(1, 0, 1), u);
+    const x11 = lerp(c(0, 1, 1), c(1, 1, 1), u);
+    return lerp(lerp(x00, x10, v), lerp(x01, x11, v), w);
+}
+/**
+ * How much of something is left after dt seconds, if half goes every
+ * `halfLife` seconds: value *= decay(dt, 2) halves it every 2 s, whatever the
+ * tick rate.
+ */
+export const decay = (dt, halfLife) => (halfLife > 0 ? 0.5 ** (dt / halfLife) : 0);
+/**
+ * True with the chance of something that happens `perSecond` times a second
+ * on average, over the last dt seconds: the same in the room (100 ticks a
+ * second) as in the preview (about 30).
+ */
+export const chance = (perSecond, dt) => Math.random() < 1 - Math.exp(-perSecond * dt);

package/dist/signal.d.ts

@@ -0,0 +1,26 @@
+import { type Field } from "./field.ts";
+export interface Every {
+    /** How many marks so far: 0, 1, 2, … */
+    count: Field<number>;
+    /** 0 to 1 from one mark to the next. */
+    ramp: Field<number>;
+    /** Seconds since the last mark. */
+    since: Field<number>;
+    /** 0, up to 1 in `attack` seconds after each mark (default 0.01), and back to 0 over `release` (default 0.3). */
+    env(options?: {
+        attack?: number;
+        release?: number;
+    }): Field<number>;
+    /** The next of these at each mark, round and round. */
+    seq<T>(list: readonly T[]): Field<T>;
+}
+export interface Clock {
+    readonly bpm: number;
+    /** Beats so far (not whole: 2.5 is halfway through the third). */
+    beats: Field<number>;
+    /** Marks every n beats: every(1) is each beat, every(4) each bar of four. */
+    every(n: number): Every;
+}
+/** A clock at `bpm` beats a minute, starting with the sketch. */
+export declare function clock(bpm: number): Clock;
+//# sourceMappingURL=signal.d.ts.map

package/dist/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../src/signal.ts"],"names":[],"mappings":"AAQA,OAAO,EAAS,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAG/C,MAAM,WAAW,KAAK;IACpB,wCAAwC;IACxC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,wCAAwC;IACxC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB,mCAAmC;IACnC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,iHAAiH;IACjH,GAAG,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACpE,uDAAuD;IACvD,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,6EAA6E;IAC7E,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACzB;AAED,iEAAiE;AACjE,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CA+BxC"}

package/dist/signal.js

@@ -0,0 +1,44 @@
+// Signals: fields that only read the time, for wiring into any number a field
+// or source takes. A clock counts beats; every(n) marks each n-th one, and
+// from those come envelopes (a flash on each), sequences (a new value each)
+// and ramps (0 to 1 across each).
+//
+//   const beat = clock(96);
+//   osc(4).rotate(beat.every(4).seq([0, 45, 90, 135])).color(palettes.dusk).boost(beat.every(1).env(), 0.8)
+import { field } from "./field.js";
+import { fract } from "./shape.js";
+/** A clock at `bpm` beats a minute, starting with the sketch. */
+export function clock(bpm) {
+    const beats = field(({ t }) => (t * bpm) / 60);
+    return {
+        bpm,
+        beats,
+        every(n) {
+            const at = (t) => (t * bpm) / 60 / n;
+            const seconds = (60 / bpm) * n;
+            const since = field(({ t }) => fract(at(t)) * seconds);
+            return {
+                count: field(({ t }) => Math.floor(at(t))),
+                ramp: field(({ t }) => fract(at(t))),
+                since,
+                env({ attack = 0.01, release = 0.3 } = {}) {
+                    return field((here) => {
+                        const s = since(here);
+                        if (s < attack)
+                            return s / attack;
+                        const k = Math.max(0, 1 - (s - attack) / release);
+                        return k * k;
+                    });
+                },
+                seq(list) {
+                    if (list.length === 0)
+                        throw new Error("seq(): give it at least one value");
+                    return field(({ t }) => {
+                        const i = Math.floor(at(t)) % list.length;
+                        return list[i < 0 ? i + list.length : i];
+                    });
+                },
+            };
+        },
+    };
+}

package/dist/sketch.d.ts

@@ -0,0 +1,21 @@
+import { type ColorInput, type Palette } from "./color.ts";
+import type { Update } from "./arclamp.ts";
+import { Here } from "./here.ts";
+/** What a light should make, here and now; null, undefined or false leaves it as it is below. */
+export type LookResult = ColorInput | null | undefined | false | void;
+/**
+ * What a light should make, here and now: a function of here giving a color,
+ * one color for every light, or a palette, laid across the room.
+ */
+export type Look = ((here: Here) => LookResult) | ColorInput | Palette;
+export interface SketchOptions {
+    /** Old bulbs switch on when asked for this many lumens or more (default 100: about halfway, to the eye, to one that's on). */
+    switchOn?: number;
+    /** And off when asked for fewer than this (default 70). */
+    switchOff?: number;
+}
+/** Your look (a function of here, or a field) as arclamp's update(). */
+export declare function sketch(look: (here: Here) => LookResult, options?: SketchOptions): Update;
+/** One color for every light, or a palette laid across the room, as arclamp's update(). */
+export declare function sketch(look: ColorInput | Palette, options?: SketchOptions): Update;
+//# sourceMappingURL=sketch.d.ts.map

package/dist/sketch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sketch.d.ts","sourceRoot":"","sources":["../src/sketch.ts"],"names":[],"mappings":"AAeA,OAAO,EAA2B,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AACpF,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAW,IAAI,EAAiC,MAAM,WAAW,CAAC;AAKzE,iGAAiG;AACjG,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,GAAG,IAAI,CAAC;AAEtE;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,UAAU,CAAC,GAAG,UAAU,GAAG,OAAO,CAAC;AAEvE,MAAM,WAAW,aAAa;IAC5B,8HAA8H;IAC9H,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD,wEAAwE;AACxE,wBAAgB,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;AAC1F,2FAA2F;AAC3F,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC"}

package/dist/sketch.js

@@ -0,0 +1,89 @@
+// sketch(): your look as arclamp's update().
+//
+// A look is a function of here (your own, or a field), or one color for
+// every light (a palette is laid across the room, left to right). Each tick
+// sketch() asks it what every light should make now, and turns that into
+// channels: lemtone channels for color lights, and on or off for old bulbs
+// (on at `switchOn` lumens or more, off below `switchOff`, and left as they
+// were between, so a pattern hovering near the line doesn't chatter).
+//
+// Anything a look gives that says a color will do: a Color, "#f80",
+// "2700K", { r, g, b }, … Null, undefined or false leaves the light as it is
+// below. Something that isn't a color, or a color that isn't all numbers,
+// leaves it as it is too, with a warning (once for each kind of mistake), so
+// one slip doesn't stop the sketch.
+import { Color, color, isPalette } from "./color.js";
+import { colorOf, Here, roomOf, sameLayout } from "./here.js";
+// A tick after a long gap (the sketch paused, or held up) counts as at most this long.
+const MAX_DT = 0.25;
+export function sketch(look, options = {}) {
+    const ask = lookOf(look);
+    const switchOn = options.switchOn ?? 100;
+    const switchOff = Math.min(options.switchOff ?? 70, switchOn);
+    let room = null;
+    let last = null;
+    const on = new Map();
+    const warned = new Set();
+    const warn = (kind, text) => {
+        if (warned.has(kind))
+            return;
+        warned.add(kind);
+        console.warn(`${text} (warning once)`);
+    };
+    return (prev, nowMs, initialMs) => {
+        const list = Array.isArray(prev?.lights) ? prev.lights : [];
+        if (!room || !sameLayout(prev, room))
+            room = roomOf(prev, room);
+        const t = (nowMs - initialMs) / 1000;
+        const dt = last === null ? 0 : Math.min(MAX_DT, Math.max(0, (nowMs - last) / 1000));
+        last = nowMs;
+        const lights = [];
+        for (let i = 0; i < list.length; i++) {
+            const light = room.lights[i];
+            light.below = colorOf(list[i], light.kind);
+            const v = ask(new Here(light.x, light.y, t, dt, nowMs, light, room));
+            if (v === null || v === undefined || v === false)
+                continue;
+            let c;
+            try {
+                c = v instanceof Color ? v : color(v);
+            }
+            catch (err) {
+                if (typeof v === "number") {
+                    warn("number", `light ${light.id} was given ${v}, and a number is read as a color temperature in kelvin; for a pattern from 0 to 1, color it first, like osc(3).color(palettes.dusk)`);
+                }
+                else {
+                    warn("unreadable", `light ${light.id} was given something that isn't a color, so it's left as it is: ${err.message}`);
+                }
+                continue;
+            }
+            if (light.kind === "switch") {
+                if (!Number.isFinite(c.lm)) {
+                    warn("nan", `light ${light.id} was given a color that isn't all numbers, ${JSON.stringify(c)}, so it's left as it is`);
+                    continue;
+                }
+                const was = on.get(light.id) ?? c.lm >= switchOn;
+                const now = c.lm >= switchOn ? true : c.lm < switchOff ? false : was;
+                on.set(light.id, now);
+                lights.push({ id: light.id, channels: { on: now ? 1 : 0 } });
+                continue;
+            }
+            const channels = c.channels;
+            if (!Number.isFinite(channels.a) || !Number.isFinite(channels.b) || !Number.isFinite(channels.brightness) || !Number.isFinite(channels.fidelity)) {
+                warn("nan", `light ${light.id} was given a color that isn't all numbers, ${JSON.stringify(c)}, so it's left as it is`);
+                continue;
+            }
+            lights.push({ id: light.id, channels });
+        }
+        return { lights };
+    };
+}
+/** The look as a function of here. One color is the same everywhere (and said wrong, an error now, not each tick). */
+function lookOf(look) {
+    if (isPalette(look))
+        return (here) => look(here.u);
+    if (typeof look === "function")
+        return look;
+    const c = color(look);
+    return () => c;
+}

package/dist/spaces.d.ts

@@ -0,0 +1,24 @@
+import { type Vec3 } from "./lemtone.ts";
+/** The light a screen's white stands for, in lumens. */
+export declare const SCREEN_WHITE_LM = 1000;
+export declare const linearSrgbToXyz: (rgb: Vec3) => Vec3;
+export declare const xyzToLinearSrgb: (X: Vec3) => Vec3;
+/** sRGB's gamma, undone (extended past 0 and 1 the same way both sides, as CSS does). */
+export declare function decode(v: number): number;
+/** sRGB's gamma. */
+export declare function encode(v: number): number;
+export declare const linearP3ToXyz: (rgb: Vec3) => Vec3;
+export declare const xyzD50ToXyz: (X: Vec3) => Vec3;
+/** CIE Lab (L 0–100) as XYZ (D65). */
+export declare function labToXyz(L: number, a: number, b: number): Vec3;
+/** HSL (hue in degrees, saturation and lightness 0–1) as gamma-encoded sRGB (CSS Color 4). */
+export declare function hslToSrgb(h: number, s: number, l: number): Vec3;
+/** HWB (hue in degrees, whiteness and blackness 0–1) as gamma-encoded sRGB (CSS Color 4). */
+export declare function hwbToSrgb(h: number, w: number, b: number): Vec3;
+/** Gamma-encoded sRGB as HSL (CSS Color 4): hue in degrees (0 for grays), saturation and lightness 0–1. */
+export declare function srgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+//# sourceMappingURL=spaces.d.ts.map

package/dist/spaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaces.d.ts","sourceRoot":"","sources":["../src/spaces.ts"],"names":[],"mappings":"AASA,OAAO,EAA4B,KAAK,IAAI,EAAE,MAAM,cAAc,CAAC;AAEnE,wDAAwD;AACxD,eAAO,MAAM,eAAe,OAAO,CAAC;AAcpC,eAAO,MAAM,eAAe,QAAS,IAAI,KAAG,IAAqC,CAAC;AAClF,eAAO,MAAM,eAAe,MAAO,IAAI,KAAG,IAAmC,CAAC;AAE9E,yFAAyF;AACzF,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC;AAED,oBAAoB;AACpB,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC;AAQD,eAAO,MAAM,aAAa,QAAS,IAAI,KAAG,IAAyB,CAAC;AASpE,eAAO,MAAM,WAAW,MAAO,IAAI,KAAG,IAAwB,CAAC;AAE/D,sCAAsC;AACtC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAU9D;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAO/D;AAED,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAM/D;AAED,2GAA2G;AAC3G,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAU9F"}

package/dist/spaces.js

@@ -0,0 +1,91 @@
+// The color spaces people know, to and from the light they stand for.
+//
+// They're all screens' spaces, so their brightness is relative to a screen's
+// white. Here that white is a fixed amount of light, 1000 lm (lemtone's
+// brightness 1.0), the same on every light: rgb(1, 1, 1) asks for 1000 lm,
+// and a screen's full blue, #0000ff, for about 72, as dim next to white as on
+// a screen. Everything goes through XYZ (D65, Y = 1 for that white), with the
+// matrices CSS Color 4 uses.
+import { lmsToXyz, mul3, xyzToLms } from "./lemtone.js";
+/** The light a screen's white stands for, in lumens. */
+export const SCREEN_WHITE_LM = 1000;
+// Linear sRGB <-> OKLab's LMS (Björn Ottosson's), so sRGB and OKLab agree exactly.
+const SRGB_LMS = [
+    [0.4122214708, 0.5363325363, 0.0514459929],
+    [0.2119034982, 0.6806995451, 0.1073969566],
+    [0.0883024619, 0.2817188376, 0.6299787005],
+];
+const LMS_SRGB = [
+    [4.0767416621, -3.3077115913, 0.2309699292],
+    [-1.2684380046, 2.6097574011, -0.3413193965],
+    [-0.0041960863, -0.7034186147, 1.707614701],
+];
+export const linearSrgbToXyz = (rgb) => lmsToXyz(mul3(SRGB_LMS, rgb));
+export const xyzToLinearSrgb = (X) => mul3(LMS_SRGB, xyzToLms(X));
+/** sRGB's gamma, undone (extended past 0 and 1 the same way both sides, as CSS does). */
+export function decode(v) {
+    const x = Math.abs(v);
+    return Math.sign(v) * (x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4);
+}
+/** sRGB's gamma. */
+export function encode(v) {
+    const x = Math.abs(v);
+    return Math.sign(v) * (x <= 0.0031308 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055);
+}
+// Linear Display P3 -> XYZ (CSS Color 4).
+const P3_XYZ = [
+    [0.48657094864821626, 0.26566769316909294, 0.1982172852343625],
+    [0.22897456406974884, 0.6917385218365062, 0.079286914093745],
+    [0, 0.045113381858902575, 1.0439443689009757],
+];
+export const linearP3ToXyz = (rgb) => mul3(P3_XYZ, rgb);
+// CIE Lab and LCh are relative to D50; back to D65 by Bradford (CSS Color 4).
+const D50 = [0.3457 / 0.3585, 1, (1 - 0.3457 - 0.3585) / 0.3585];
+const D50_D65 = [
+    [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
+    [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
+    [0.012314014864481998, -0.020507649298898964, 1.330365926242124],
+];
+export const xyzD50ToXyz = (X) => mul3(D50_D65, X);
+/** CIE Lab (L 0–100) as XYZ (D65). */
+export function labToXyz(L, a, b) {
+    const k = 24389 / 27;
+    const e = 216 / 24389;
+    const f1 = (L + 16) / 116;
+    const f0 = a / 500 + f1;
+    const f2 = f1 - b / 200;
+    const x = f0 ** 3 > e ? f0 ** 3 : (116 * f0 - 16) / k;
+    const y = L > k * e ? f1 ** 3 : L / k;
+    const z = f2 ** 3 > e ? f2 ** 3 : (116 * f2 - 16) / k;
+    return xyzD50ToXyz([x * D50[0], y, z * D50[2]]);
+}
+/** HSL (hue in degrees, saturation and lightness 0–1) as gamma-encoded sRGB (CSS Color 4). */
+export function hslToSrgb(h, s, l) {
+    const hue = ((h % 360) + 360) % 360;
+    const f = (n) => {
+        const k = (n + hue / 30) % 12;
+        return l - s * Math.min(l, 1 - l) * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+    };
+    return [f(0), f(8), f(4)];
+}
+/** HWB (hue in degrees, whiteness and blackness 0–1) as gamma-encoded sRGB (CSS Color 4). */
+export function hwbToSrgb(h, w, b) {
+    if (w + b >= 1) {
+        const gray = w / (w + b);
+        return [gray, gray, gray];
+    }
+    return hslToSrgb(h, 1, 0.5).map((v) => v * (1 - w - b) + w);
+}
+/** Gamma-encoded sRGB as HSL (CSS Color 4): hue in degrees (0 for grays), saturation and lightness 0–1. */
+export function srgbToHsl(r, g, b) {
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    const d = max - min;
+    if (d === 0)
+        return { h: 0, s: 0, l };
+    const s = l === 0 || l === 1 ? 0 : (max - l) / Math.min(l, 1 - l);
+    let h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+    h *= 60;
+    return { h, s, l };
+}