@lemoncat7/dsh-theme-xiaohei 0.3.0-alpha.23 → 0.3.2

package/lib/vendor/bloub/decor.js

@@ -0,0 +1,198 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+import { TAU, clamp, createRng, r2 } from './math.js';
+/* ------------------------------------------------------------------ couleurs */
+/**
+ * Les anneaux ne sont pas des couleurs plates : la video montre une roue de
+ * teintes complete a luminosite constante, avec un degrade le long de chaque
+ * trace. Mesure : S 45-62 %, L 50-67 %.
+ */
+function wheel(hue, s = 0.55, l = 0.62) {
+    const h = ((hue % 360) + 360) % 360;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = l - c / 2;
+    const [r, g, b] = h < 60
+        ? [c, x, 0]
+        : h < 120
+            ? [x, c, 0]
+            : h < 180
+                ? [0, c, x]
+                : h < 240
+                    ? [0, x, c]
+                    : h < 300
+                        ? [x, 0, c]
+                        : [c, 0, x];
+    const hex = (v) => Math.round((v + m) * 255)
+        .toString(16)
+        .padStart(2, '0');
+    return `#${hex(r)}${hex(g)}${hex(b)}`;
+}
+/**
+ * Projette un cercle 3D incline en orthographique.
+ *
+ * Le cercle vit dans le plan engendre par u (dans l'ecran) et v (qui plonge
+ * dans la profondeur). La composante z sert a couper l'arc en deux : la moitie
+ * arriere est dessinee avant le corps, donc occultee par lui. C'est ce vrai tri
+ * en profondeur qui fait lire les anneaux comme des orbites et pas comme un
+ * dessin plat.
+ */
+export function arcRender(seed, t, scale, id, opacity = 1) {
+    const spin = seed.phase + t * seed.speed * TAU;
+    const cu = Math.cos(seed.tilt);
+    const su = Math.sin(seed.tilt);
+    const kz = Math.sqrt(Math.max(0, 1 - seed.k * seed.k));
+    const N = 64;
+    const span = seed.sweep * TAU;
+    let front = '';
+    let back = '';
+    let prev = null;
+    for (let i = 0; i <= N; i++) {
+        const th = spin + (i / N) * span;
+        const ct = Math.cos(th);
+        const st = Math.sin(th);
+        // u = (cos tilt, sin tilt, 0) ; v = (-sin tilt * k, cos tilt * k, kz)
+        const x = seed.a * (ct * cu + st * -su * seed.k) + seed.cx;
+        const y = seed.a * (ct * su + st * cu * seed.k) + seed.cy;
+        const z = seed.a * st * kz;
+        const behind = z < 0;
+        const sx = r2(x * scale);
+        const sy = r2(y * scale);
+        const cmd = behind !== prev ? 'M' : 'L';
+        if (behind)
+            back += `${cmd}${sx} ${sy}`;
+        else
+            front += `${cmd}${sx} ${sy}`;
+        prev = behind;
+    }
+    const gx = Math.cos(seed.tilt) * seed.a * scale;
+    const gy = Math.sin(seed.tilt) * seed.a * scale;
+    return {
+        id,
+        front,
+        back,
+        width: seed.width * scale,
+        opacity,
+        grad: {
+            x1: r2(seed.cx * scale - gx),
+            y1: r2(seed.cy * scale - gy),
+            x2: r2(seed.cx * scale + gx),
+            y2: r2(seed.cy * scale + gy),
+            stops: [wheel(seed.hue), wheel(seed.hue + seed.hueSpan * 0.5), wheel(seed.hue + seed.hueSpan)]
+        }
+    };
+}
+/* ---------------------------------------------------------------- anneaux */
+const RING_RNG = createRng(0xa11ce);
+/**
+ * 6 anneaux, demi-grand axe 1.30-1.40 (donc nettement plus grands que la
+ * boule), aplatissement toujours <= 0.45, epaisseur 0.055, ~3.3 tours/s.
+ */
+export const RINGS = Array.from({ length: 6 }, (_, i) => ({
+    a: 1.3 + RING_RNG() * 0.1,
+    k: 0.05 + RING_RNG() * 0.4,
+    tilt: (i / 6) * Math.PI + RING_RNG() * 0.5,
+    speed: 3 + RING_RNG() * 0.7,
+    phase: RING_RNG() * TAU,
+    sweep: 0.6 + RING_RNG() * 0.25,
+    hue: (i * 360) / 6 + RING_RNG() * 30,
+    hueSpan: 60 + RING_RNG() * 60,
+    width: 0.05 + RING_RNG() * 0.012,
+    cx: 0,
+    cy: 0.1
+}));
+/**
+ * Bouquet d'arcs emboites qui balaie le triangle juste avant les orbites.
+ * Vus quasiment par la tranche (d'ou la forme en epingle a cheveux), rmax 1.37.
+ */
+export const SWOOSH = Array.from({ length: 4 }, (_, i) => ({
+    a: 0.78 + i * 0.2,
+    k: 0.05 + i * 0.02,
+    tilt: -0.62 + i * 0.05,
+    speed: 0.3,
+    phase: 0.06 * i,
+    sweep: 0.4,
+    hue: 95 + i * 62,
+    hueSpan: 100,
+    width: 0.05,
+    cx: 0,
+    cy: -0.12
+}));
+/* ------------------------------------------------------------- 3 points */
+/** x mesures : -0.557 / -0.013 / +0.532, y = 0. */
+export const DOT_X = [-0.557, -0.013, 0.532];
+export const DOT_R = 0.165;
+export const DOT_PEAK = 1.25;
+/* ------------------------------------------------------------ particules */
+const P_RNG = createRng(0xbeef);
+/** 5 particules, une nouvelle toutes les 0.2 s, duree de vie 0.55 s. */
+const PARTICLES = Array.from({ length: 5 }, (_, i) => ({
+    birth: i * 0.2,
+    angle: P_RNG() * TAU,
+    rho: 0.58 + P_RNG() * 0.18
+}));
+/**
+ * Les particules ne partent pas en ligne droite : elles spiralent vers le
+ * centre (rayon x0.75 par frame, angle +100 deg/s) en grossissant, et passent
+ * derriere le noyau ou elles sont avalees.
+ */
+export function particles(t, scale) {
+    const out = [];
+    for (const p of PARTICLES) {
+        const u = t - p.birth;
+        if (u < 0 || u > 0.62)
+            continue;
+        const rho = p.rho * Math.pow(0.75, u * 10);
+        const a = p.angle + (u * 100 * Math.PI) / 180;
+        out.push({
+            x: Math.cos(a) * rho * scale,
+            y: Math.sin(a) * rho * scale,
+            r: (0.04 + 0.028 * clamp(u / 0.55)) * scale,
+            depth: clamp(1 - rho / 0.8),
+            opacity: clamp(u / 0.06) * clamp((0.62 - u) / 0.08)
+        });
+    }
+    return out;
+}
+/* ------------------------------------------------------------------ comete */
+/**
+ * Contrairement a l'intuition, le point ne traverse pas l'ecran : il reste au
+ * centre et c'est la trainee qui l'orbite. Ellipse a = 0.85, b = 0.15,
+ * grand axe incline de +34deg, 4 rubans, ~210 deg/s.
+ */
+const COMET_RNG = createRng(0xc0e7);
+export const COMET_RIBBONS = Array.from({ length: 4 }, (_, i) => {
+    const d = i - 1.5;
+    return {
+        a: 0.85 * (1 + d * 0.03),
+        // meme aplatissement a +-5 % pres : les rubans forment un faisceau serre
+        k: (0.15 / 0.85) * (1 + d * 0.16),
+        tilt: (34 * Math.PI) / 180 + d * 0.035,
+        speed: 210 / 360,
+        // dephasage mesure : 10 a 20 degres entre rubans, pas davantage
+        phase: -i * 0.045 + COMET_RNG() * 0.012,
+        sweep: 0.34,
+        hue: i * 85 + COMET_RNG() * 20,
+        hueSpan: 80,
+        width: 0.095,
+        cx: 0,
+        cy: 0
+    };
+});
+/** Rayon du point de la comete, mesure a 0.129. */
+export const COMET_DOT = 0.129;
+/* --------------------------------------------------- pastille notification */
+/** Bleu releve au pixel. */
+export const NOTIF_BLUE = '#2496e8';
+/** La pastille est posee exactement sur la circonference, a -42deg. */
+export const NOTIF_ANGLE = -42;
+export const NOTIF_DIST = 1.003;
+/** Rayon au repos ; le pop culmine 14 % au-dessus. */
+export const NOTIF_R = 0.15;
+export const NOTIF_POP = 1.14;
+/**
+ * L'encoche est un disque concentrique a la pastille, soustrait du corps.
+ * La marge est constante (0.054 R) et suit l'echelle du corps.
+ */
+export const NOTIF_MARGIN = 0.054;
+//# sourceMappingURL=decor.js.map

package/lib/vendor/bloub/engine.d.ts

@@ -0,0 +1,213 @@
+import { type ArcRender, type DotRender } from './decor.js';
+import { type BotExpression } from './expressions.js';
+import { type StateId } from './states.js';
+export interface RenderedEye {
+    d: string;
+    matrix: string;
+    alpha: number;
+    /** Original local bounds, exposed for the theme's hollow ellipse renderer. */
+    width: number;
+    height: number;
+    /** Uncompressed tangent and lid allow a stroked eye to close without vanishing. */
+    openMatrix: string;
+    lid: number;
+}
+export interface BotFrame {
+    bodyPath: string;
+    bodyAlpha: number;
+    eyes: RenderedEye[];
+    dots: DotRender[];
+    /** true = les points passent derriere le corps (particules de l'eclatement) */
+    dotsBehind: boolean;
+    arcs: ArcRender[];
+    notif: {
+        x: number;
+        y: number;
+        r: number;
+    } | null;
+    notch: {
+        x: number;
+        y: number;
+        r: number;
+    } | null;
+}
+/**
+ * Ou le bot porte son regard quand quelque chose d'exterieur le pilote — le
+ * pointeur de la souris, aujourd'hui.
+ *
+ * `yaw` et `pitch` sont des directions ABSOLUES, qui remplacent celles de la pose
+ * a mesure que `mix` monte. Deux raisons, chacune un piege deja tombe :
+ *
+ * - c'est le MOTEUR qui doit faire ce melange, pas l'appelant, parce que lui seul
+ *   connait la pose A CET INSTANT. Un appelant qui compenserait l'orientation de
+ *   l'expression lirait sa valeur d'arrivee pendant que le morph est encore en
+ *   cours, et les yeux sautaient a chaque changement d'humeur ;
+ * - et il faut que ce soit absolu sur les DEUX axes. En relatif, la hauteur des
+ *   yeux suivait celle de chaque expression — « neutre » regarde a +28,6deg quand
+ *   les autres sont entre -9 et +9 — donc les yeux tombaient d'un coup au premier
+ *   changement d'humeur. Ce qui fait le caractere d'une expression pendant le
+ *   suivi, c'est la FORME de ses yeux (plisses, ronds, dissymetriques), pas
+ *   l'endroit ou elle regarde : celui-la, c'est le curseur qui le decide.
+ *
+ * `mix` dit a quel point l'exterieur commande la DIRECTION (0 = pas du tout).
+ *
+ * `wander` dit, separement, ce qui reste de derive automatique. Les deux ne se
+ * confondent pas : quand le pointeur bouge, la derive doit s'eteindre — cumulees,
+ * le bot aurait l'air de chercher le curseur sans jamais le tenir. Mais quand il
+ * n'y a PAS de pointeur (arrivee au clavier, au tactile, ou souris sortie de la
+ * fenetre), la tete doit rester tournee ET continuer de vivre. Les confondre
+ * figeait le regard des que la vue s'ouvrait.
+ *
+ * `spin` est un tour a parcourir EN CHEMIN, en degres, qu'on fait fondre vers 0
+ * avec l'arrivee. Comme les yeux vivent sur une sphere, un tour les fait passer
+ * derriere la boule et revenir de l'autre cote — et `-360deg` etant le meme
+ * angle que `0`, il ne change rien a l'endroit ou ils se posent.
+ */
+export interface Look {
+    yaw: number;
+    pitch: number;
+    mix: number;
+    spin: number;
+    wander: number;
+}
+/**
+ * Moteur sans horloge : `sample(t)` est une fonction pure du temps.
+ *
+ * Consequence pratique : pause, reprise, ralenti et saut a une date arbitraire
+ * donnent exactement la meme image, et le rendu est testable sans DOM.
+ */
+export declare class BotEngine {
+    /** rayon de la boule au repos, en unites de viewBox */
+    readonly scale: number;
+    private cur;
+    private prev;
+    /**
+     * Pose de depart FIGEE, posee seulement quand un changement d'etat arrive alors qu'un
+     * fondu est deja en cours. Cf. `setState`.
+     */
+    private departFige;
+    private tCur;
+    private tPrev;
+    private blinkAt;
+    private pts;
+    private shape;
+    private shapePrev;
+    private shapeAt;
+    private expr;
+    private exprPrev;
+    private exprAt;
+    private look;
+    private lookPrev;
+    private lookAt;
+    /** duree de rattrapage en cours ; voir `LOOK_MORPH`, sa valeur par defaut */
+    private lookMorph;
+    /** duree du morph quand on change la forme du corps */
+    static readonly SHAPE_MORPH = 0.45;
+    /**
+     * Duree de rattrapage du regard vers la cible. Plus court que `SHAPE_MORPH` :
+     * un regard qui suit doit paraitre attentif, pas visqueux. Comme la cible est
+     * reposee a chaque mouvement de souris, c'est cette duree qui donne au suivi
+     * son inertie — le regard n'atteint jamais tout a fait un curseur qui bouge.
+     */
+    static readonly LOOK_MORPH = 0.24;
+    constructor(scale?: number, initial?: StateId, shape?: number[] | null, expression?: BotExpression | null);
+    /**
+     * Expression de repos choisie dans le personnalisateur. Comme la forme, elle
+     * glisse vers la nouvelle valeur au lieu de sauter.
+     */
+    setExpression(expression: BotExpression | null, now?: number): void;
+    /** Expression effective a l'instant `now`, morph en cours compris. */
+    private exprAtTime;
+    /**
+     * Forme choisie dans le personnalisateur. Elle ne remplace le corps que sur
+     * les etats au repos (`baseBody`) : sur les autres, la silhouette EST
+     * l'animation et ne doit pas etre ecrasee.
+     *
+     * Le changement se fait en morph, pas d'un coup : comme toutes les formes sont
+     * echantillonnees aux memes angles, il suffit d'interpoler les rayons.
+     */
+    setShape(radii: number[] | null, now?: number): void;
+    /**
+     * Forme effective a l'instant `now`, morph en cours compris.
+     *
+     * Ne remet PAS `shapePrev` a null en fin de morph : `sample` doit rester une
+     * fonction pure du temps, donc relire une date passee doit redonner l'image
+     * intermediaire. On garde juste une reference de plus.
+     */
+    private shapeAtTime;
+    /**
+     * Nouvelle cible de regard, `null` pour revenir a celui de l'etat.
+     *
+     * Elle repart de la valeur COURANTE, et non de la cible precedente comme
+     * `setShape` : cette methode est appelee a chaque mouvement de pointeur, et
+     * repartir de l'ancienne cible ferait reculer le regard d'un cran avant
+     * chaque rattrapage — le suivi tremblerait au lieu de glisser.
+     *
+     * Meme contrat que `setShape` par ailleurs : l'etat externe entre par un
+     * setter horodate, jamais par une variable lue pendant `sample`, sinon le
+     * moteur cesse d'etre une fonction pure du temps.
+     */
+    setLook(look: Look | null, now: number, morph?: number): void;
+    /** Regard effectif a l'instant `now`, rattrapage en cours compris. */
+    private lookAtTime;
+    private posed;
+    /**
+     * Decalage des yeux a l'instant `now` pour un etat donne, en unites de rayon de boule.
+     *
+     * Il est LU dans une table et interpole, jamais recalcule : `eyefit.ts` explique
+     * pourquoi cette distinction est tout le correctif. Ici il ne reste qu'a l'interpoler
+     * sur l'axe de la forme, avec exactement la courbe et la duree du morph de silhouette
+     * — c'est la meme cause, donc ce doit etre le meme mouvement.
+     *
+     * On interroge la table sur les BORNES du morph (`shapePrev` et `shape`) et non sur le
+     * profil que rend `shapeAtTime` : celui-la est un tableau neuf alloue a chaque image,
+     * donc sans identite, et il n'existe dans aucune table.
+     */
+    private decalageAtTime;
+    get state(): StateId;
+    /**
+     * Repart sur `id` SANS etat precedent, comme un moteur neuf pose sur cet etat.
+     *
+     * C'est ce que veut dire « rembobiner » pour ce moteur. `setState` seul ne peut pas le
+     * faire : il garde l'etat quitte pour le fondre, ce qui est exactement son role en
+     * lecture, et exactement ce qu'il ne faut pas quand on revient au debut d'une sequence.
+     * Rejouer l'image 0 apres une passe complete melangeait le premier etat avec le DERNIER,
+     * et l'export GIF s'ouvrait sur une boule sans yeux — la comete a un `eyeAlpha` nul.
+     *
+     * `sample` reste une fonction pure du temps : comme `setState`, ceci est un setter DATE,
+     * appele par le pilote de la sequence, jamais pendant un echantillonnage.
+     */
+    reset(id: StateId, now: number): void;
+    /**
+     * Origine du fondu en cours : la pose figee s'il y en a une, sinon l'etat quitte evalue
+     * a son propre temps ecoule — donc encore en train de s'animer, ce qui est voulu.
+     */
+    private origine;
+    /**
+     * Pose composite a l'instant `now`, fondu en cours compris : exactement ce que `sample`
+     * melange, avant la couche de vie au repos et de regard. Extraite pour que `setState`
+     * puisse la figer.
+     */
+    private poseComposee;
+    /**
+     * Changement d'etat, date.
+     *
+     * Le moteur ne garde qu'UNE case d'historique, donc un changement qui arrive pendant un
+     * fondu remplacait l'origine du melange par la pose PLEINE de l'etat qu'on quittait, au
+     * lieu de l'image partiellement melangee qui etait a l'ecran. Mesure sur
+     * `idle -> wide -> idle` a 100 ms : 35,9 px de saut contre 8,0 px de mouvement normal.
+     *
+     * On fige donc la pose composite courante et on melange depuis elle. Continu par
+     * construction, quel que soit le nombre de changements enchaines.
+     *
+     * Et SEULEMENT dans ce cas. Figer a chaque changement arreterait net l'animation de
+     * l'etat qu'on quitte pendant tout le fondu — le « ! » d'`alert` se figerait en pleine
+     * course — alors qu'il n'y a rien a corriger hors morph : l'etat quitte y est deja
+     * exactement l'image affichee. La lecture d'un montage, dont les blocs durent au moins
+     * le plus long fondu (`MIN_BLOCK`), ne fige donc jamais rien et rend au bit ce qu'elle
+     * rendait.
+     */
+    setState(id: StateId, now: number): void;
+    sample(now: number): BotFrame;
+}
+//# sourceMappingURL=engine.d.ts.map