@miliastry/quasar 1.0.6 → 1.1.0

package/src/Syntax/GreenNodePool.ts

@@ -252,18 +252,18 @@ export class GreenNodePool {
   }
 }
 
-/** Convenience helper for interning green leaves */
+/**
+ * Convenience helper for interning green leaves, over the shared singleton.
+ *
+ * The internal-node twin of this helper used to sit alongside it and was
+ * removed: nothing imported it, and it could not have worked if anything had.
+ * `GreenNodePool.instance` is built with the default `'leaves'` mode, and
+ * `internNode` returns a fresh `GreenNode` unconditionally in that mode — so
+ * the one thing the helper existed for, structural sharing of internal nodes,
+ * was unreachable through the only pool it could reach. Interning internal
+ * nodes is done by passing a `GreenNodePool.create('full')` to the parser,
+ * which is what `BBCodeDocumentModel` does per document.
+ */
 export function internGreenLeaf(kind: string, text: string, width = text.length): GreenNode {
   return GreenNodePool.instance.internLeaf(kind, text, width)
 }
-
-/** Convenience helper for interning green nodes */
-export function internGreenNode(
-  kind: string,
-  text: string,
-  children: GreenNode[],
-  leadingWidth = 0,
-  trailingWidth = 0,
-): GreenNode {
-  return GreenNodePool.instance.internNode(kind, text, children, leadingWidth, trailingWidth)
-}

package/src/Syntax/RedNode.ts

@@ -175,6 +175,22 @@ export class RedNode {
     }
     node._range.start += delta
     node._range.end += delta
+    RedNode.shiftDescendants(node, delta)
+  }
+
+  /**
+   * Push `delta` into every red node that lives under `node` — its title nodes
+   * as well as its children.
+   *
+   * The title subtree of a rich `[box=[b]heading[/b]]` is stored in
+   * `metadata.titleNodes`, never appended to `children`, so a loop over
+   * `children` alone leaves it at pre-edit offsets. That is not cosmetic:
+   * `findNodeAtOffset` consults `metadata.titleNodes` BEFORE `children`, so a
+   * stale title range mis-resolves caret, hover and selection inside the
+   * heading. Both shift paths — the recursive one and `materialize`'s ancestor
+   * loop — route through here so they cannot drift apart again.
+   */
+  private static shiftDescendants(node: RedNode, delta: number): void {
     const titleNodes = node.metadata?.titleNodes as RedNode[] | undefined
     if (titleNodes) {
       for (let i = 0; i < titleNodes.length; i++) {
@@ -223,9 +239,7 @@ export class RedNode {
       ancestor._lazyShift = 0
       ancestor._range.start += delta
       ancestor._range.end += delta
-      for (let c = 0; c < ancestor.children.length; c++) {
-        RedNode.applyShift(ancestor.children[c], delta)
-      }
+      RedNode.shiftDescendants(ancestor, delta)
     }
   }
 

package/src/Syntax/RedNodeStore.ts

@@ -145,9 +145,17 @@ export class RedNodeStore {
 
   /**
    * Check if a GreenNode already has a canonical RedNode.
+   *
+   * Mirrors `getOrCreate`'s discriminator, including the identity check. A
+   * present hash entry only proves *some* structure registered under this
+   * 32-bit hash; if it is a different green, `getOrCreate` counts a collision
+   * and builds an unregistered node, so answering `true` here would be the
+   * opposite of the truth for any caller deciding whether canonicalization has
+   * already happened.
    */
   has(green: GreenNode): boolean {
-    return this.canonicals.has(green._hash.toString())
+    const existing = this.canonicals.get(green._hash.toString())
+    return existing !== undefined && existing.green === green
   }
 
   /**

package/src/Syntax/nodeAttr.ts

@@ -0,0 +1,172 @@
+/**
+ * Cómo se lee el atributo de una etiqueta BBCode, y qué valores se aceptan.
+ *
+ * ── Por qué esto vive fuera del renderizador ───────────────────────────────
+ *
+ * Era privado de `HTMLRenderer`, así que cualquier otro consumidor que
+ * necesitara el mismo dato tenía que reinventarlo — y se reinventó mal. Los
+ * presets del lienzo de BBCodeCanvas leían `node.text` en crudo, con el `=`
+ * pegado delante: `[color=#ff0000]` acababa produciendo `color: "=#ff0000"`,
+ * que es CSS inválido, así que el color no se pintaba en absoluto. Lo mismo con
+ * `font_size` y `url`.
+ *
+ * No es un helper nuevo: es el mismo código, movido a donde los dos lo ven. Si
+ * el renderizador y el lienzo vuelven a divergir, al menos divergirán desde el
+ * mismo sitio.
+ */
+
+import type { RedNode } from './RedNode'
+import type { TokenResolverFn } from '../Tokens'
+
+/** #rgb / #rgba / #rrggbb / #rrggbbaa, una palabra clave CSS, o rgb()/hsl(). */
+const CSS_COLOR_RE =
+  /^(?:#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})|[a-z]{3,20}|(?:rgb|hsl)a?\([0-9a-z.,%\s/+-]{1,64}\))$/i
+
+/** Número desnudo — se interpola como porcentaje. */
+const CSS_SIZE_RE = /^\d{1,4}(?:\.\d{1,2})?$/
+
+/** Lista de familias. Las comillas se rechazan; sin comillas es CSS válido. */
+const CSS_FONT_RE = /^[A-Za-z0-9 ,_-]{1,120}$/
+
+const BARE_HEX_RE = /^[0-9a-f]{3,8}$/i
+
+/**
+ * El valor del atributo de un nodo.
+ *
+ * Los atributos BBCode vienen como `=VALOR` (`=#61afef`, `="Autor"`,
+ * `=https://osu.ppy.sh`): se quita el `=` y las comillas envolventes. Una
+ * etiqueta sin atributo —el contenido de un `[img]`, por ejemplo— devuelve su
+ * texto tal cual.
+ *
+ * Con `key`, gana lo que haya en `metadata`: es lo que escribe el Inspector al
+ * editar una propiedad, y tiene que pesar más que el texto original del
+ * documento, que todavía no se ha reescrito.
+ */
+export function nodeAttrValue(node: RedNode, key?: string): string {
+  if (key) {
+    const meta = node.metadata?.[key]
+    if (typeof meta === 'string' && meta) return meta
+  }
+
+  const text = node.text || ''
+  if (!text) return ''
+
+  const eqIdx = text.indexOf('=')
+  if (eqIdx < 0) return text
+
+  let value = text.slice(eqIdx + 1)
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    value = value.slice(1, -1)
+  }
+  return value
+}
+
+/**
+ * Un color que se puede meter en un `style`, o `null`.
+ *
+ * Devolver `null` en vez de el valor crudo no es remilgo: `[color=red;"
+ * onmouseover="alert(1)]` cierra el atributo e inyecta un manejador de eventos.
+ * Escapar solo neutralizaría la inyección, pero dejaría CSS roto, así que se
+ * valida la FORMA y se descarta lo que no sea un valor que quisiéramos admitir.
+ *
+ * Un hex sin `#` se completa: `[color=ff0000]` es como lo escribe medio mundo.
+ */
+export function sanitizeColor(raw: string, resolver?: TokenResolverFn): string | null {
+  // Atajo para `#RRGGBB`, que es la forma que produce el propio motor y con
+  // la que llega la inmensa mayoría de las llamadas. Un degradado sin
+  // fusionar emite UN SEGMENTO POR CARÁCTER y cada uno pasaba por `trim`,
+  // dos expresiones regulares y el `startsWith` de los tokens. La comprobación
+  // por códigos de carácter acepta exactamente el mismo conjunto que
+  // `CSS_COLOR_RE` para siete caracteres, así que la garantía no cambia:
+  // sigue siendo imposible que salga de aquí algo que no sea un color.
+  if (raw.length === 7 && raw.charCodeAt(0) === 35 /* # */ && isPlainHex6(raw)) return raw
+
+  let v = raw.trim()
+  if (!v) return null
+  if (v.startsWith('$') && resolver) {
+    const resolved = resolver(v.slice(1)) ?? resolver(v)
+    if (resolved !== undefined) {
+      v = resolved.trim()
+    }
+  }
+  if (BARE_HEX_RE.test(v) && (v.length === 3 || v.length === 4 || v.length === 6 || v.length === 8)) {
+    v = '#' + v
+  }
+  return CSS_COLOR_RE.test(v) ? v : null
+}
+
+/** `true` si `s[1..7]` son seis dígitos hexadecimales. Sin asignar nada. */
+function isPlainHex6(s: string): boolean {
+  for (let i = 1; i < 7; i++) {
+    const c = s.charCodeAt(i)
+    const isDigit = c >= 0x30 && c <= 0x39
+    const isLower = c >= 0x61 && c <= 0x66
+    const isUpper = c >= 0x41 && c <= 0x46
+    if (!isDigit && !isLower && !isUpper) return false
+  }
+  return true
+}
+
+/** El tamaño de `[size=…]` como número, o `null`. Se interpola en `%`. */
+export function sanitizeFontSize(raw: string, resolver?: TokenResolverFn): string | null {
+  let v = raw.trim()
+  if (v.startsWith('$') && resolver) {
+    const resolved = resolver(v.slice(1)) ?? resolver(v)
+    if (resolved !== undefined) {
+      v = resolved.trim()
+      if (v.endsWith('%')) {
+        v = v.slice(0, -1).trim()
+      }
+    }
+  }
+  return CSS_SIZE_RE.test(v) ? v : null
+}
+
+/** La familia de `[font=…]`, o `null`. */
+export function sanitizeFontFamily(raw: string, resolver?: TokenResolverFn): string | null {
+  let v = raw.trim()
+  if (v.startsWith('$') && resolver) {
+    const resolved = resolver(v.slice(1)) ?? resolver(v)
+    if (resolved !== undefined) {
+      v = resolved.trim()
+      if (
+        (v.startsWith('"') && v.endsWith('"')) ||
+        (v.startsWith("'") && v.endsWith("'"))
+      ) {
+        v = v.slice(1, -1).trim()
+      }
+    }
+  }
+  return CSS_FONT_RE.test(v) ? v : null
+}
+
+/** Lo que puede significar el atributo de un `[img=…]`. */
+export interface ImgAttr {
+  w?: number
+  h?: number
+  round?: boolean
+  shadow?: boolean
+  float?: boolean
+}
+
+/**
+ * El modificador de una imagen: `[img=200x100]`, `[img=round]`, `[img=shadow]`,
+ * `[img=float]`.
+ *
+ * Vive aquí y no en el renderizador porque es interpretación del ATRIBUTO, no
+ * de cómo se pinta: quien quiera respetar un `round` necesita este mismo
+ * significado, y hasta ahora el lienzo simplemente lo ignoraba.
+ */
+export function parseImgAttr(v: string | null): ImgAttr {
+  if (!v) return {}
+  const t = v.trim().toLowerCase()
+  if (t === 'round') return { round: true }
+  if (t === 'shadow') return { shadow: true }
+  if (t === 'float') return { float: true }
+  const m = /^(\d{1,4})x(\d{1,4})$/i.exec(t)
+  if (m) return { w: Math.min(2000, parseInt(m[1], 10)), h: Math.min(2000, parseInt(m[2], 10)) }
+  return {}
+}

package/src/Tokens/TokenResolver.ts

@@ -0,0 +1,55 @@
+/**
+ * Quasar Document Engine — Design Tokens
+ *
+ * Provides token types and normalization utilities for design token resolution.
+ * Completely independent of @miliastry/core.
+ */
+
+export interface DocumentTokens {
+  palette?: Record<string, string>
+  variables?: Record<string, string>
+}
+
+export type TokenResolverFn = (name: string) => string | undefined
+export type TokenSource = DocumentTokens | TokenResolverFn
+
+/**
+ * Normalizes a TokenSource into a TokenResolverFn.
+ *
+ * For DocumentTokens, checks palette[name] ?? variables[name], handling both
+ * with and without leading `$`.
+ * If source is already a function, passes it through.
+ */
+export function toTokenResolver(source?: TokenSource): TokenResolverFn | undefined {
+  if (!source) return undefined
+  if (typeof source === 'function') return source
+
+  return (name: string): string | undefined => {
+    const bare = name.startsWith('$') ? name.slice(1) : name
+    const dollar = '$' + bare
+    const palette = source.palette
+    const variables = source.variables
+
+    return (
+      palette?.[name] ??
+      palette?.[bare] ??
+      palette?.[dollar] ??
+      variables?.[name] ??
+      variables?.[bare] ??
+      variables?.[dollar]
+    )
+  }
+}
+
+/**
+ * Resolves a token value if val starts with `$`.
+ * Strips `$` and looks up in resolver. If found, returns resolved value; otherwise returns val.
+ */
+export function resolveTokenValue(val: string, resolver?: TokenResolverFn): string {
+  if (!resolver || !val.startsWith('$')) {
+    return val
+  }
+  const tokenName = val.slice(1)
+  const resolved = resolver(tokenName) ?? resolver(val)
+  return resolved !== undefined ? resolved : val
+}

package/src/Tokens/index.ts

@@ -0,0 +1 @@
+export * from './TokenResolver'

package/src/Types/core.ts

@@ -92,8 +92,23 @@ export type NodeKind =
   | 'grow'
   | 'sinewave'
   | 'rainbow'
+  | 'paint'
   | 'spacing'
   | 'empty_line'
+  /**
+   * Una etiqueta de cierre que no cerró nada y que no debe verse.
+   *
+   * Nace cuando un cierre llega tarde: su etiqueta ya se cerró sola porque un
+   * cierre anterior pasó por encima de ella (ver `Parser.ts`, modo legacy).
+   * osu! tira esos cierres, así que el renderer los omite.
+   *
+   * Existe como nodo, y no como texto, por dos razones. Conserva su rango, que
+   * es lo que necesita el parser incremental para saber a qué nodo pertenece
+   * cada carácter. Y el exportador puede saltárselo: escrito como texto volvía
+   * a salir por el otro lado convertido en etiqueta viva, y el documento no
+   * era estable al reexportarlo.
+   */
+  | 'discarded_tag'
   | 'group'
   | 'wnotice'
   | 'align'