@springbrand/message-panel 0.1.3-alpha.8 → 0.2.0-alpha.37

package/springbrand-pet/bot/cycles.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest'
+import {
+  MAX_BLOCK,
+  MAX_BLOCS,
+  MAX_CYCLES,
+  MIN_BLOCK,
+  blockAt,
+  blocksWith,
+  clampDuration,
+  defaultCycle,
+  makeBlock,
+  minDurationOf,
+  moveBlock,
+  nextCycleId,
+  parseCycles,
+  totalDuration,
+  type Cycle,
+  uniqueName
+} from './cycles'
+import { SEQUENCE, STATES, STATE_BY_ID } from './states'
+
+describe('cycle par defaut', () => {
+  it('reprend la sequence relevee sur la video, dans l ordre', () => {
+    expect(defaultCycle().blocks.map((b) => b.state)).toEqual(SEQUENCE)
+  })
+
+  it('tient chaque etat sa duree mesuree', () => {
+    for (const block of defaultCycle().blocks) {
+      expect(block.duration).toBe(STATE_BY_ID.get(block.state)!.duration)
+    }
+  })
+
+  it('est reconstruit a l identique a chaque appel', () => {
+    expect(defaultCycle()).toEqual(defaultCycle())
+    // ...sans partager d'objet, sinon editer un montage toucherait l amorce
+    expect(defaultCycle().blocks[0]).not.toBe(defaultCycle().blocks[0])
+  })
+
+  it('laisse toujours de la place pour un nouveau cycle, sans collision', () => {
+    const reference = defaultCycle()
+    const un: Cycle = {
+      id: nextCycleId([reference]),
+      name: uniqueName('Mon cycle', [reference]),
+      blocks: []
+    }
+    const deux: Cycle = {
+      id: nextCycleId([reference, un]),
+      name: uniqueName('Mon cycle', [reference, un]),
+      blocks: []
+    }
+    expect(un.id).not.toBe(reference.id)
+    expect(deux.id).not.toBe(un.id)
+    expect(deux.name).not.toBe(un.name)
+  })
+})
+
+describe('durees', () => {
+  it('ne descend pas sous le plancher du moteur', () => {
+    // en dessous, le bloc est plus court que le fondu d entree du suivant
+    expect(clampDuration('idle', 0.1)).toBe(MIN_BLOCK)
+    expect(clampDuration('idle', -5)).toBe(MIN_BLOCK)
+  })
+
+  it('respecte la mesure des etats qui ont besoin d aboutir', () => {
+    // le "!" revient a 2.0, le corps se recompose a 2.4
+    expect(minDurationOf('alert')).toBe(2)
+    expect(minDurationOf('burst')).toBe(2.4)
+    expect(clampDuration('orbit', 1)).toBe(2.5)
+    // un etat qui ignore le temps n a que le plancher
+    expect(minDurationOf('idle')).toBe(MIN_BLOCK)
+  })
+
+  it('n autorise aucun etat a descendre sous sa mesure', () => {
+    for (const state of SEQUENCE) {
+      expect(clampDuration(state, 0)).toBeGreaterThanOrEqual(minDurationOf(state))
+    }
+  })
+
+  it('plafonne et tombe sur le pas, sans trainee de flottants', () => {
+    expect(clampDuration('idle', 999)).toBe(MAX_BLOCK)
+    expect(clampDuration('idle', 2.44)).toBe(2.4)
+    expect(clampDuration('idle', 2.46)).toBe(2.5)
+  })
+})
+
+describe('lecture', () => {
+  const cycle: Cycle = {
+    id: 'c1',
+    name: 'Test',
+    blocks: [
+      { state: 'idle', duration: 2 },
+      { state: 'wink', duration: 1 },
+      { state: 'egg', duration: 3 }
+    ]
+  }
+
+  it('additionne les blocs', () => {
+    expect(totalDuration(cycle.blocks)).toBe(6)
+  })
+
+  it('trouve le bloc joue et le temps ecoule dedans', () => {
+    expect(blockAt(cycle.blocks, 0)).toEqual({ index: 0, elapsed: 0 })
+    expect(blockAt(cycle.blocks, 1.9)).toEqual({ index: 0, elapsed: 1.9 })
+    // la borne appartient au bloc suivant
+    expect(blockAt(cycle.blocks, 2)).toEqual({ index: 1, elapsed: 0 })
+    expect(blockAt(cycle.blocks, 3.5)).toEqual({ index: 2, elapsed: 0.5 })
+  })
+
+  it('boucle au-dela du dernier bloc', () => {
+    expect(blockAt(cycle.blocks, 6)).toEqual({ index: 0, elapsed: 0 })
+    expect(blockAt(cycle.blocks, 8)).toEqual({ index: 1, elapsed: 0 })
+  })
+
+  it('ne casse pas sur un cycle vide', () => {
+    expect(blockAt([], 3)).toEqual({ index: 0, elapsed: 0 })
+    expect(totalDuration([])).toBe(0)
+  })
+
+  it('deplace un bloc sans toucher la liste d origine', () => {
+    const blocks = cycle.blocks
+    expect(moveBlock(blocks, 0, 2).map((b) => b.state)).toEqual(['wink', 'egg', 'idle'])
+    expect(moveBlock(blocks, 2, 0).map((b) => b.state)).toEqual(['egg', 'idle', 'wink'])
+    expect(blocks.map((b) => b.state)).toEqual(['idle', 'wink', 'egg'])
+  })
+})
+
+describe('relecture du stockage', () => {
+  it('ne casse pas sur du vide ou du JSON invalide', () => {
+    expect(parseCycles(null)).toEqual([])
+    expect(parseCycles('')).toEqual([])
+    expect(parseCycles('{pas du json')).toEqual([])
+    expect(parseCycles('{"id":"c1"}')).toEqual([])
+  })
+
+  it('jette les blocs dont l etat n existe plus', () => {
+    const raw = '[{"id":"c1","name":"A","blocks":[{"state":"idle","duration":2},' +
+      '{"state":"disparu","duration":2}]}]'
+    expect(parseCycles(raw)[0]!.blocks.map((b) => b.state)).toEqual(['idle'])
+  })
+
+  it('ramene les durees aberrantes dans leurs bornes', () => {
+    const raw = '[{"id":"c1","name":"A","blocks":[{"state":"idle","duration":-4},' +
+      '{"state":"egg","duration":9999}]}]'
+    expect(parseCycles(raw)[0]!.blocks.map((b) => b.duration)).toEqual([MIN_BLOCK, MAX_BLOCK])
+  })
+
+  it('jette un cycle vide, sans nom, ou en double', () => {
+    expect(parseCycles('[{"id":"c1","name":"A","blocks":[]}]')).toEqual([])
+    expect(parseCycles('[{"id":"c1","blocks":[{"state":"idle","duration":2}]}]')).toEqual([])
+    const doublon = '[{"id":"c1","name":"A","blocks":[{"state":"idle","duration":2}]},' +
+      '{"id":"c1","name":"B","blocks":[{"state":"egg","duration":2}]}]'
+    expect(parseCycles(doublon).map((c) => c.name)).toEqual(['A'])
+  })
+
+  it('ne garde que les champs du modele, pas ce qu on lui glisse en plus', () => {
+    const raw = '[{"id":"defaut","name":"Mon montage","locked":true,"secret":1,' +
+      '"blocks":[{"state":"idle","duration":2,"vitesse":3}]}]'
+    const cycle = parseCycles(raw)[0]!
+    expect(Object.keys(cycle).sort()).toEqual(['blocks', 'id', 'name'])
+    expect(Object.keys(cycle.blocks[0]!).sort()).toEqual(['duration', 'state'])
+  })
+
+  /*
+   * Le stockage est modifiable et tient quelques megaoctets, alors que rien en aval n'est
+   * dimensionne pour ca. Un seul cycle de 150 000 blocs — environ 4 Mo de JSON, donc dans
+   * le budget — donnait 1 500 000 s de duree, autant de graduations a allouer et une piste
+   * de 29 700 000 px : l'onglet figeait en entrant dans la vue Animations.
+   */
+  it('borne la taille d un montage relu', () => {
+    const blocs = Array.from({ length: 200_000 }, () => ({ state: 'idle', duration: 10 }))
+    const raw = JSON.stringify([{ id: 'c1', name: 'A', blocks: blocs }])
+    expect(parseCycles(raw)[0]!.blocks).toHaveLength(MAX_BLOCS)
+  })
+
+  /*
+   * Le plancher est DERIVE du plus long `morph`, il n'est plus ecrit a la main. Ce test
+   * garde le lien visible : il valait 0,6 en dur, ce qui ne marchait que parce que 0,6
+   * etait justement le morph d'`orbit`. Un etat qui morphe plus lentement le suit.
+   */
+  it('le plancher de bloc couvre le plus long fondu du catalogue', () => {
+    const plusLong = Math.max(...STATES.map((s) => s.morph))
+    expect(MIN_BLOCK).toBeGreaterThanOrEqual(plusLong)
+    // et il n'est pas gratuitement plus grand : c'est exactement ce fondu
+    expect(MIN_BLOCK).toBe(plusLong)
+  })
+
+  it('borne aussi l ajout depuis l editeur, pas seulement la relecture', () => {
+    let blocs = Array.from({ length: MAX_BLOCS }, () => makeBlock('idle'))
+    expect(blocksWith(blocs, 'egg')).toHaveLength(MAX_BLOCS)
+    // et il reste possible d'ajouter juste en dessous de la borne
+    blocs = blocs.slice(0, MAX_BLOCS - 1)
+    expect(blocksWith(blocs, 'egg')).toHaveLength(MAX_BLOCS)
+  })
+
+  it('borne le nombre de montages relus', () => {
+    const raw = JSON.stringify(
+      Array.from({ length: 5000 }, (_, i) => ({
+        id: `c${i}`,
+        name: `A${i}`,
+        blocks: [{ state: 'idle', duration: 2 }]
+      }))
+    )
+    expect(parseCycles(raw)).toHaveLength(MAX_CYCLES)
+  })
+
+  /*
+   * `swirl` est la transition d'entree des reglages, deliberement hors de `SEQUENCE` : un
+   * test la garde hors de la palette et de la planche. Un montage utilisateur ne se
+   * construit qu'a partir de la palette, donc elle ne peut arriver ici que par un stockage
+   * bricole a la main — et on l'y refuse comme partout ailleurs.
+   */
+  it('refuse un etat hors catalogue, `swirl` compris', () => {
+    const raw = '[{"id":"c1","name":"A","blocks":[{"state":"swirl","duration":2},' +
+      '{"state":"idle","duration":2}]}]'
+    expect(parseCycles(raw)[0]!.blocks.map((b) => b.state)).toEqual(['idle'])
+    // un montage qui n'en contiendrait QUE devient vide, donc tombe
+    expect(parseCycles('[{"id":"c1","name":"A","blocks":[{"state":"swirl","duration":2}]}]')).toEqual(
+      []
+    )
+  })
+})

package/springbrand-pet/bot/cycles.ts

@@ -0,0 +1,225 @@
+import { SEQUENCE, STATES, STATE_BY_ID, type StateId } from './states'
+
+/**
+ * Un cycle est un montage : une suite de blocs, chacun un etat tenu pendant une
+ * duree choisie. C'est la partie "editeur" du dossier, et elle en garde les
+ * regles — donnees pures, aucune horloge, aucun import Vue : le meme cycle doit
+ * pouvoir etre relu par les tests, par le lecteur et par la timeline.
+ *
+ * Un bloc n'a pas d'identifiant : c'est une position dans une liste, la cle de
+ * rendu est l'index. Ca garde le JSON du localStorage lisible et les tests
+ * deterministes.
+ */
+export interface Block {
+  state: StateId
+  duration: number
+}
+
+export interface Cycle {
+  id: string
+  name: string
+  blocks: Block[]
+}
+
+/**
+ * Plancher commun a tous les blocs. Le moteur ne garde qu'une case d'historique
+ * (`BotEngine.setState` ecrase `prev`), donc un bloc plus court que le fondu d'entree du
+ * bloc suivant saute a l'image au lieu de se fondre.
+ *
+ * DERIVE du catalogue et non ecrit a la main. La valeur etait 0,6, ce qui marchait
+ * uniquement parce que 0,6 se trouvait etre le plus long `morph` du catalogue — celui
+ * d'`orbit`. Rien ne le garantissait : ajouter un etat qui morphe en 0,8 s aurait fait
+ * trembler l'editeur sans qu'aucun test ne bronche. Maintenant le plancher suit.
+ */
+export const MIN_BLOCK = Math.max(...STATES.map((s) => s.morph))
+
+/**
+ * Garde-fou d'editeur, pas une mesure : allonger un bloc est sans risque (les
+ * etats saturent leurs rampes et tiennent leur pose finale), mais une piste de
+ * blocs d'une minute n'est plus lisible.
+ */
+export const MAX_BLOCK = 10
+
+/**
+ * Combien de blocs et de montages on accepte, a l'edition comme a la relecture.
+ *
+ * Ce ne sont pas des limites de produit mais des bornes contre un stockage hostile, qui
+ * est modifiable et tient quelques megaoctets alors que rien en aval n'est dimensionne
+ * pour ca : un seul cycle de 150 000 blocs, soit environ 4 Mo de JSON, donne 1 500 000 s
+ * de duree, autant de graduations a allouer et une piste de 29 700 000 px de large.
+ * L'onglet figeait en entrant dans la vue Animations.
+ *
+ * 200 blocs font une demi-heure de montage, largement au-dela de tout usage.
+ */
+export const MAX_BLOCS = 200
+export const MAX_CYCLES = 50
+
+/** Pas de la molette et du redimensionnement, en secondes. */
+export const STEP = 0.1
+
+const DEFAULT_CYCLE_ID = 'defaut'
+
+/** Duree minimale d'un bloc : le plancher moteur, ou la mesure de l'etat. */
+export function minDurationOf(state: StateId): number {
+  return Math.max(MIN_BLOCK, STATE_BY_ID.get(state)?.minDuration ?? MIN_BLOCK)
+}
+
+/** Ramene une duree dans ses bornes et sur le pas, sans trainee de flottants. */
+export function clampDuration(state: StateId, seconds: number): number {
+  const snapped = Math.round(seconds / STEP) * STEP
+  const bounded = Math.min(MAX_BLOCK, Math.max(minDurationOf(state), snapped))
+  return Math.round(bounded * 100) / 100
+}
+
+export function makeBlock(state: StateId): Block {
+  // la duree de reference est celle relevee sur la video pour cet etat
+  return { state, duration: clampDuration(state, STATE_BY_ID.get(state)?.duration ?? 2) }
+}
+
+/**
+ * Le montage releve sur la video : l'ordre de `SEQUENCE`, chaque etat tenu sa
+ * duree mesuree. Il sert d'amorce au premier lancement, puis il appartient a
+ * l'utilisateur — il s'edite et se stocke comme les autres. La reference, elle,
+ * reste dans le code : vider le stockage la fait revenir.
+ */
+export function defaultCycle(): Cycle {
+  return {
+    /**
+     * Nom vide = « jamais nomme par l'utilisateur », donc affiche dans la langue
+     * courante. Ecrire ici « Cycle par defaut » l'aurait fige : le nom part au
+     * localStorage des la premiere visite et redevient une donnee utilisateur,
+     * que changer de langue ne retraduirait plus.
+     */
+    name: '',
+    id: DEFAULT_CYCLE_ID,
+    blocks: SEQUENCE.map(makeBlock)
+  }
+}
+
+export function totalDuration(blocks: Block[]): number {
+  return blocks.reduce((sum, b) => sum + b.duration, 0)
+}
+
+/** Date de debut d'un bloc dans le montage. */
+export function offsetOf(blocks: Block[], index: number): number {
+  let acc = 0
+  for (let i = 0; i < index && i < blocks.length; i++) acc += blocks[i]!.duration
+  return acc
+}
+
+/**
+ * Bloc joue a la date `t` et temps ecoule dedans. Au-dela du dernier bloc on
+ * retombe au debut : la lecture boucle. L'appelant verifie que le montage n'est
+ * pas vide.
+ */
+export function blockAt(blocks: Block[], t: number): { index: number; elapsed: number } {
+  const total = totalDuration(blocks)
+  if (!blocks.length || total <= 0) return { index: 0, elapsed: 0 }
+  // le modulo n'est applique que s'il sert : sur une date deja dans le cycle il
+  // n'ajouterait qu'une trainee de flottants au temps ecoule
+  const wrapped = t >= 0 && t < total ? t : ((t % total) + total) % total
+  let acc = 0
+  for (let i = 0; i < blocks.length; i++) {
+    const end = acc + blocks[i]!.duration
+    if (wrapped < end) return { index: i, elapsed: wrapped - acc }
+    acc = end
+  }
+  return { index: blocks.length - 1, elapsed: 0 }
+}
+
+/**
+ * Ajoute une animation a la fin du montage (palette de droite ou carte « + »).
+ *
+ * Plafonnee a `MAX_BLOCS`, comme la relecture. Sans ca l'editeur laissait construire un
+ * montage plus grand que ce que le stockage rend au rechargement, et le travail
+ * disparaissait en silence — une borne de relecture qui n'est pas aussi une borne d'edition
+ * est un piege, pas une protection.
+ */
+export function blocksWith(blocks: Block[], state: StateId): Block[] {
+  if (blocks.length >= MAX_BLOCS) return blocks
+  return [...blocks, makeBlock(state)]
+}
+
+/** Deplace un bloc, en rendant une nouvelle liste (les etats Vue sont remplaces). */
+export function moveBlock(blocks: Block[], from: number, to: number): Block[] {
+  const next = blocks.slice()
+  const [moved] = next.splice(from, 1)
+  if (!moved) return blocks
+  next.splice(Math.min(Math.max(to, 0), next.length), 0, moved)
+  return next
+}
+
+/** `Mon cycle`, `Mon cycle 2`, `Mon cycle 3`... — jamais deux fois le meme nom. */
+export function uniqueName(base: string, cycles: Cycle[]): string {
+  const taken = new Set(cycles.map((c) => c.name))
+  if (!taken.has(base)) return base
+  let n = 2
+  while (taken.has(`${base} ${n}`)) n++
+  return `${base} ${n}`
+}
+
+/** Identifiant sans collision, y compris avec un localStorage bricole a la main. */
+export function nextCycleId(cycles: Cycle[]): string {
+  const taken = new Set(cycles.map((c) => c.id))
+  let n = 1
+  while (taken.has(`c${n}`)) n++
+  return `c${n}`
+}
+
+/* ------------------------------------------------------- lecture du stockage */
+
+function parseBlock(raw: unknown): Block | null {
+  if (typeof raw !== 'object' || raw === null) return null
+  const { state, duration } = raw as { state?: unknown; duration?: unknown }
+  /*
+   * Valide contre SEQUENCE et non contre `STATE_BY_ID` : ce dernier contient `swirl`, qui
+   * est deliberement hors du catalogue — c'est la transition d'entree des reglages, un
+   * test la verrouille hors de la palette et de la planche. Un montage utilisateur ne se
+   * construit qu'a partir de la palette, donc un `swirl` ne peut y arriver que par un
+   * stockage bricole a la main, et il n'y a aucune raison de l'y tolerer quand on l'exclut
+   * partout ailleurs.
+   */
+  if (typeof state !== 'string' || !SEQUENCE.includes(state as StateId)) return null
+  if (typeof duration !== 'number' || !Number.isFinite(duration)) return null
+  return { state: state as StateId, duration: clampDuration(state as StateId, duration) }
+}
+
+function parseCycle(raw: unknown, seen: Cycle[]): Cycle | null {
+  if (typeof raw !== 'object' || raw === null) return null
+  const { id, name, blocks } = raw as { id?: unknown; name?: unknown; blocks?: unknown }
+  if (typeof id !== 'string' || !id) return null
+  // le nom peut etre vide — c'est le montage d'amorce, qui suit la langue
+  if (typeof name !== 'string') return null
+  if (!Array.isArray(blocks)) return null
+  // on tronque AVANT de relire : valider 150 000 blocs pour n'en garder que 200 serait
+  // faire le travail qu'on cherche justement a eviter
+  const kept = blocks
+    .slice(0, MAX_BLOCS)
+    .map(parseBlock)
+    .filter((b): b is Block => b !== null)
+  if (!kept.length) return null
+  if (seen.some((c) => c.id === id)) return null
+  return { id, name, blocks: kept }
+}
+
+/**
+ * Le localStorage est modifiable a la main : on ne lui fait pas confiance, meme
+ * regle que pour le hash de l'URL. Tout ce qui ne se relit pas est jete
+ * silencieusement plutot que de casser l'application au demarrage.
+ */
+export function parseCycles(raw: string | null): Cycle[] {
+  if (!raw) return []
+  let data: unknown
+  try {
+    data = JSON.parse(raw)
+  } catch {
+    return []
+  }
+  if (!Array.isArray(data)) return []
+  const out: Cycle[] = []
+  for (const item of data.slice(0, MAX_CYCLES)) {
+    const cycle = parseCycle(item, out)
+    if (cycle) out.push(cycle)
+  }
+  return out
+}