@miliastry/quasar 1.0.6 → 1.1.0

package/src/Markdown/MarkdownToGreenNode.ts

@@ -18,16 +18,13 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
         for (const child of node.children) children.push(convert(child));
         break;
       case 'paragraph':
-        kind = 'text'; // DocumentEngine paragraphs are usually groups or blocks, treating as paragraph block if we want.
-        // Actually DocumentEngine uses 'text' or 'group'
-        kind = 'document'; // Let's use group or document as container
+        kind = 'paragraph';
         for (const child of node.children) children.push(convert(child));
         break;
       case 'heading':
         kind = 'heading';
-        // Faking the '#' text length for the heading level offset
         currentOffset += node.level; 
-        text = `=${node.level}`; // Use text as metadata like BBCode
+        text = `=${node.level}`;
         for (const child of node.children) children.push(convert(child));
         break;
       case 'strong':
@@ -38,6 +35,58 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
         kind = 'italic';
         for (const child of node.children) children.push(convert(child));
         break;
+      case 'strikethrough':
+        kind = 'strikethrough';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'underline':
+        kind = 'underline';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'color':
+        kind = 'color';
+        text = `=${node.color}`;
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'font_size':
+        kind = 'font_size';
+        text = `=${node.size}`;
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'font':
+        kind = 'font';
+        text = `=${node.font}`;
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'center':
+        kind = 'center';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'right':
+        kind = 'right';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'left':
+        kind = 'left';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'align':
+        kind = 'align';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'box':
+        kind = 'box';
+        text = node.title ? `=${node.title}` : '';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'spoilerbox':
+        kind = 'spoilerbox';
+        text = node.title ? `=${node.title}` : '';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'separator':
+        kind = 'separator';
+        break;
       case 'text':
         kind = 'text';
         text = node.value;
@@ -48,11 +97,6 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
         text = `=${node.url}`;
         for (const child of node.children) children.push(convert(child));
         break;
-      case 'image':
-        kind = 'image';
-        text = node.url;
-        currentOffset += text.length;
-        break;
       case 'code_block':
         kind = 'code';
         children.push(greenLeaf('text', node.value));
@@ -60,6 +104,7 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
         break;
       case 'list':
         kind = 'list';
+        text = node.ordered ? '=1' : '';
         for (const child of node.children) children.push(convert(child));
         break;
       case 'list_item':
@@ -72,10 +117,17 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
         break;
       case 'notice':
         kind = 'notice';
+        text = node.color ? `=${node.color}` : '';
+        for (const child of node.children) children.push(convert(child));
+        break;
+      case 'wnotice':
+        kind = 'wnotice';
+        text = node.color ? `=${node.color}` : '';
         for (const child of node.children) children.push(convert(child));
         break;
       case 'blockquote':
         kind = 'quote';
+        text = node.source ? `=${node.source}` : '';
         for (const child of node.children) children.push(convert(child));
         break;
       case 'spacing':
@@ -88,24 +140,23 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
         text = '\n\n';
         currentOffset += 2;
         break;
-      // `image` and `code_inline` used to land in `default`, which discarded
-      // them as empty text nodes — Markdown images never survived conversion.
       case 'image':
         kind = 'image';
-        text = `=${node.url}`;
-        if (node.alt) {
-          children.push(greenLeaf('text', node.alt));
-          currentOffset += node.alt.length;
-        }
+        // In osu! BBCode, image content is the URL between [img] and [/img]
+        children.push(greenLeaf('text', node.url));
+        currentOffset += node.url.length;
         break;
       case 'code_inline':
         kind = 'inline_code';
         children.push(greenLeaf('text', node.value));
         currentOffset += node.value.length;
         break;
+      case 'bbcode_tag':
+        kind = node.tagName as NodeKind;
+        text = node.attrValue ? `=${node.attrValue}` : '';
+        for (const child of node.children) children.push(convert(child));
+        break;
       default: {
-        // Exhaustiveness guard: adding a MarkdownNode variant without a case
-        // here is now a compile error rather than a silently dropped node.
         const unhandled: never = node;
         void unhandled;
         kind = 'text';
@@ -113,25 +164,95 @@ export function markdownAstToGreenTree(root: MarkdownNode): GreenNode {
       }
     }
 
-    const end = currentOffset;
-    // Map text container to group for proper DocumentEngine representation if not text
-    const actualKind = kind === 'document' && node.type === 'paragraph' ? 'group' : kind;
-    return greenNode(actualKind as string, text, children);
+    return greenNode(kind as string, text, children);
   }
 
   return convert(root);
 }
 
+const EFFECT_TAGS = new Set(['glow', 'neon', 'outline', 'shimmer', 'ghost', 'rainbow', 'fire', 'ice', 'emboss', 'engrave']);
+const ANIM_TAGS = new Set(['typewriter', 'wave', 'sparkle', 'glitch', 'levitate', 'pulse', 'bounce', 'shake', 'fade-in', 'fade-out']);
+const CONTAINER_TAGS = new Set(['card', 'glass', 'neon-box', 'neonbox', 'square', 'circle', 'stack', 'flex', 'grid', 'middle']);
+
 export function greenToRedNode(green: GreenNode, parent?: RedNode | null): RedNode {
-  // Simple metadata extraction based on heading text
   let metadata: Record<string, unknown> = {};
-  if (green.kind === 'heading' && green.text.startsWith('=')) {
-    metadata = { level: parseInt(green.text.slice(1)) || 1 };
+  let kind = (green.kind as NodeKind) || 'text';
+
+  const attrValue = green.text.startsWith('=') ? green.text.slice(1) : undefined;
+
+  if (EFFECT_TAGS.has(green.kind)) {
+    kind = 'effect';
+    metadata.effectType = green.kind;
+    if (attrValue) metadata.color = attrValue;
+  } else if (ANIM_TAGS.has(green.kind)) {
+    kind = 'anim';
+    metadata.animType = green.kind;
+    if (attrValue) metadata.animParam = attrValue;
+  } else if (CONTAINER_TAGS.has(green.kind)) {
+    kind = 'container';
+    metadata.containerType = green.kind;
+    if (attrValue) metadata.color = attrValue;
+  } else if (green.kind === 'row') {
+    kind = 'table_row';
+  } else if (green.kind === 'col') {
+    kind = 'table_col';
+    if (attrValue) metadata.variant = attrValue;
+  } else if (green.kind === 'th') {
+    kind = 'table_th';
+    if (attrValue) metadata.variant = attrValue;
+  } else if (green.kind === 'tables') {
+    kind = 'tables';
+    if (attrValue) metadata.variant = attrValue;
+  } else if (green.kind === 'columns') {
+    kind = 'columns';
+    if (attrValue) metadata.columns = parseInt(attrValue) || 2;
+  } else if (green.kind === 'scroll') {
+    kind = 'scroll';
+    if (attrValue) metadata.height = attrValue;
+  } else if (green.kind === 'separator') {
+    kind = 'separator';
+    if (attrValue) metadata.variant = attrValue;
+  } else if (green.kind === 'heading' && attrValue) {
+    metadata.level = parseInt(attrValue) || 1;
+  } else if (green.kind === 'color' && attrValue) {
+    metadata.color = attrValue;
+  } else if (green.kind === 'font_size' && attrValue) {
+    metadata.size = attrValue;
+  } else if (green.kind === 'font' && attrValue) {
+    metadata.font = attrValue;
+  } else if (green.kind === 'url' && attrValue) {
+    metadata.href = attrValue;
+  } else if (green.kind === 'list' && attrValue === '1') {
+    metadata.ordered = true;
+  } else if ((green.kind === 'box' || green.kind === 'boxw' || green.kind === 'spoilerbox') && attrValue) {
+    metadata.title = attrValue;
+    metadata.rawTitle = attrValue;
+  } else if ((green.kind === 'notice' || green.kind === 'wnotice') && attrValue) {
+    metadata.color = attrValue;
+  } else if (green.kind === 'quote' && attrValue) {
+    metadata.source = attrValue;
+  } else if (green.kind === 'abbr' && attrValue) {
+    metadata.title = attrValue;
+  } else if (green.kind === 'tooltip' && attrValue) {
+    metadata.tip = attrValue;
+  } else if (green.kind === 'style' || green.kind === 'style_tag') {
+    kind = 'style_tag';
+    if (attrValue) metadata.style = attrValue;
+  } else if (green.kind === 'image') {
+    if (green.children.length > 0) {
+      const first = green.children[0] as GreenNode;
+      if (first.kind === 'text') {
+        metadata.src = first.text;
+      }
+    }
+  } else if (attrValue) {
+    metadata.value = attrValue;
+    metadata.raw = attrValue;
   }
 
   const red = new RedNode(green, {
     parent: parent ?? null,
-    kind: (green.kind as NodeKind) || 'text',
+    kind,
     metadata
   });
 

package/src/MilHibri/MilHibriDocumentModel.ts

@@ -0,0 +1,56 @@
+import { DocumentModel, type DocumentModelOptions } from '../Model/DocumentModel';
+import { GreenNode, greenLeaf } from '../Syntax/GreenNode';
+import { RedNode } from '../Syntax/RedNode';
+import { scanMarkdown } from '../Markdown/MarkdownLexer';
+import { parseMarkdown } from '../Markdown/MarkdownParser';
+import { markdownAstToGreenTree, greenToRedNode } from '../Markdown/MarkdownToGreenNode';
+
+export interface MilHibriDocumentModelOptions extends DocumentModelOptions {
+  source?: string;
+}
+
+/**
+ * DocumentEngine — MilHibriDocumentModel
+ * 
+ * First-class DocumentModel for the MilHibri language:
+ * Unifies 100% of osu! BBCode and 100% of Markdown + Modern Industry Extensions
+ * into a single unified, collision-free AST.
+ */
+export class MilHibriDocumentModel extends DocumentModel {
+  constructor(options: MilHibriDocumentModelOptions = {}) {
+    super({ source: '', language: 'milhibri' });
+    if (options.source) {
+      this.rebuild(options.source);
+    }
+  }
+
+  static fromSource(source: string): MilHibriDocumentModel {
+    return new MilHibriDocumentModel({ source });
+  }
+
+  protected parseToGreen(source: string): GreenNode {
+    try {
+      const tokens = scanMarkdown(source);
+      const ast = parseMarkdown(tokens);
+      return markdownAstToGreenTree(ast);
+    } catch (error) {
+      console.warn('[MilHibriDocumentModel] Parse error:', error);
+      return greenLeaf('text', source);
+    }
+  }
+
+  protected buildRedFromGreen(green: GreenNode): RedNode {
+    return greenToRedNode(green);
+  }
+
+  applyTextUpdate(newSource: string): void {
+    if (this.source === newSource) return;
+    this.rebuild(newSource);
+  }
+
+  applyChange(change: any): void {
+    const before = this.source.slice(0, change.start);
+    const after = this.source.slice(change.end);
+    this.rebuild(before + change.text + after);
+  }
+}

package/src/Model/DocumentModel.ts

@@ -27,6 +27,7 @@ import {
   IncrementalParser,
   type ReparseParseOptions,
   type FallbackReason,
+  type SourceSpan,
 } from '../Incremental/IncrementalParser'
 import { ChangeTracker } from '../Incremental/ChangeTracker'
 import type { TextChange, TextChangeRange } from '../Incremental/ChangeTracker'
@@ -84,6 +85,34 @@ export interface DocumentModelOptions {
   reuseRed?: boolean
 }
 
+/**
+ * A span of the OLD text, in the coordinates of the text `change` produced.
+ *
+ * An endpoint before the change does not move and one after it moves by the
+ * change's delta; one INSIDE it has no image, so it is pushed outwards — the
+ * start down to where the change begins, the end up to where the replacement
+ * ends. The span this belongs to is a re-validation window, and a window that
+ * covers slightly more than it must costs nodes, never correctness.
+ */
+function shiftSpan(span: SourceSpan | null, change: TextChange): SourceSpan | null {
+  if (span === null) return null
+  const delta = change.text.length - (change.end - change.start)
+  const newEnd = change.start + change.text.length
+  const start = span.start <= change.start
+    ? span.start
+    : span.start >= change.end ? span.start + delta : change.start
+  const end = span.end <= change.start
+    ? span.end
+    : span.end >= change.end ? span.end + delta : newEnd
+  return { start, end }
+}
+
+/** The smallest span containing both. */
+function unionSpans(a: SourceSpan | null, b: SourceSpan): SourceSpan {
+  if (a === null) return b
+  return { start: Math.min(a.start, b.start), end: Math.max(a.end, b.end) }
+}
+
 export class DocumentModel {
   // ── Core State ──
   private _source: string
@@ -123,6 +152,32 @@ export class DocumentModel {
   /** Why the last reparse fell back to a full rebuild, if it did. */
   lastReparseFallbackReason: FallbackReason | null = null
   lastReparseTimings: { findAffected: number; safeBoundary: number; parse: number; buildRed: number; mutate: number; other: number } | null = null
+  /**
+   * The span of the current source the last reparse actually re-parsed, in
+   * CURRENT coordinates — `null` after a full rebuild, where the answer is
+   * "all of it". See {@link ReparseResult.window}.
+   */
+  lastReparseWindow: SourceSpan | null = null
+
+  // ── Incremental analysis bookkeeping ──
+  //
+  // `analyzeWindow` re-validates the nodes an edit could have changed and
+  // keeps every other node's verdict. What makes that sound is a promise only
+  // the model can make: that this tree grew out of the analysed one through
+  // incremental reparses WITH red-subtree reuse, so every node outside the
+  // windows is the same object over the same text. These two fields are that
+  // promise, tracked edit by edit.
+
+  /**
+   * The union of every reparse window since the last analysis, in CURRENT
+   * coordinates — `null` when nothing is pending. A bounding span rather than
+   * a list: over-covering only means re-validating a few more nodes, and the
+   * arithmetic to keep several spans current across later edits costs more
+   * than the nodes do.
+   */
+  private _analysisWindow: SourceSpan | null = null
+  /** Set by anything a window pass cannot be built on: a rebuild, a reparse that fell back. */
+  private _analysisWindowBroken = true
 
   constructor(options: DocumentModelOptions = {}) {
     this._options = {
@@ -181,6 +236,12 @@ export class DocumentModel {
     return this._diagnostics
   }
 
+  /**
+   * What the last analysis cost and how it was obtained — its `scope` says
+   * whether it walked the document or only the edit's window, and `window`
+   * carries that span when it did. The diagnostics themselves are on
+   * {@link diagnostics}, and are the whole document's on either route.
+   */
   get lastAnalyze(): AnalyzeResult | null {
     return this._lastAnalyzeResult
   }
@@ -215,6 +276,12 @@ export class DocumentModel {
     // incrementally, so the range is cleared and the preview falls back to its
     // full reconcile (which is what it must do for undo/redo/load anyway).
     this._lastChangeRange = null
+    this.lastReparseWindow = null
+    // A rebuild replaces every node in the tree, so nothing a previous
+    // analysis knew about any of them survives. Set BEFORE `analyze()` below,
+    // which reads it.
+    this._analysisWindow = null
+    this._analysisWindowBroken = true
     this._attachChangeRange(this._redRoot)
     // Unchanged nodes keep the identity they had before the rebuild, so the
     // HTML of untouched subtrees stays byte-identical between renders and the
@@ -296,8 +363,22 @@ export class DocumentModel {
   }
 
   /**
-   * Apply a source text change (e.g. from Monaco editor input).
-   * Uses incremental parsing when possible.
+   * Apply one exact source change — THE edit path, and the one an editor
+   * should use.
+   *
+   * An editor already knows what the user did: Monaco's
+   * `onDidChangeModelContent` hands over `rangeOffset`, `rangeLength` and
+   * `text`, which is exactly a {@link TextChange}. Handing that over instead
+   * of the new document text skips the only part of the pipeline that is
+   * unavoidably proportional to the whole document — the prefix/suffix diff
+   * in {@link applyTextUpdate} — and the difference is not marginal. Typing
+   * 120 characters into the middle of the 500 KB fixture, per keystroke:
+   *
+   *     applyTextUpdate   p50 7.35 ms   p95 28.79 ms
+   *     applyChange       p50 1.85 ms   p95  8.18 ms
+   *
+   * Everything downstream is already windowed, so what is left after the diff
+   * goes is work proportional to the edit.
    *
    * `origin` tags where the change came from — `'local'` (default) for the
    * user's own editing, anything else for programmatic or synced sources
@@ -357,6 +438,7 @@ export class DocumentModel {
         this.lastReparsePath = result.path
         this.lastReparseFallbackReason = result.reason ?? null
         this.lastReparseTimings = result.timings
+        this.lastReparseWindow = result.window
         this._greenRoot = result.green
         this._redRoot = result.red
         // Identity across the edit, by whichever mechanism applies.
@@ -377,6 +459,20 @@ export class DocumentModel {
         if (oldRoot && reuse.adopted === 0) {
           preserveNodeIds(oldRoot, this._redRoot)
         }
+        // Carry the analysis window across this edit, or give up on it. Both
+        // conditions matter: without a reparse window every node is new, and
+        // without adopted subtrees `preserveNodeIds` has just moved ids
+        // between different nodes, which is exactly what an id-keyed snapshot
+        // of the previous analysis cannot survive.
+        if (result.window === null || reuse.adopted === 0) {
+          this._analysisWindow = null
+          this._analysisWindowBroken = true
+        } else if (!this._analysisWindowBroken) {
+          this._analysisWindow = unionSpans(
+            shiftSpan(this._analysisWindow, change),
+            result.window,
+          )
+        }
         this._version++
         // The incremental path resolved: the range stays attached to the new
         // root so the preview can find the edited region.
@@ -384,6 +480,8 @@ export class DocumentModel {
       } catch {
         this.lastReparsePath = 'full_rebuild'
         this.lastReparseTimings = null
+        this.lastReparseWindow = null
+        // `rebuild` clears the analysis window itself.
         this.rebuild(this._source)
         return
       }
@@ -427,6 +525,10 @@ export class DocumentModel {
           version: this._version,
           source: this._source,
           diagnostics: this._diagnostics,
+          // How they were arrived at, not what they are: `diagnostics` is the
+          // whole document's on both routes. See `DocumentEvent.analysisScope`.
+          analysisScope: this._lastAnalyzeResult?.scope,
+          analysisWindow: this._lastAnalyzeResult?.window ?? null,
           timestamp: Date.now()
         }
         this.defineLazyNodeMatch(diagnosticsEvent, oldRoot, this._redRoot)
@@ -456,8 +558,14 @@ export class DocumentModel {
   }
 
   /**
-   * Calculate a simple diff between the current source and the new source,
-   * then apply the change.
+   * Recover the edit from the new document text, then apply it.
+   *
+   * The FALLBACK, for a caller that only has the text: a textarea's `value`,
+   * a CRDT that hands over a materialised document, a paste normaliser. It is
+   * a shared-prefix/shared-suffix diff, so it costs one pass over the
+   * unchanged part of the document before any of the incremental machinery
+   * gets to run — which is precisely the term {@link applyChange} does not
+   * pay. Anything that knows the edit should say so and use that instead.
    */
   applyTextUpdate(newSource: string, origin: string = 'local'): void {
     if (this._source === newSource) return
@@ -568,12 +676,35 @@ export class DocumentModel {
 
   /**
    * Run semantic analysis on the current tree.
+   *
+   * Incremental when it can be: if every edit since the last analysis was an
+   * incremental reparse that adopted subtrees, only the nodes inside those
+   * reparse windows — plus the ones whose document-wide facts the edits moved
+   * — are re-validated, and every other node keeps the verdict it already
+   * had. The DIAGNOSTICS ARE THE SAME EITHER WAY; the difference is how long
+   * it took to arrive at them, and {@link AnalyzeResult.scope} says which
+   * route was taken. The differential in `Chars500kAnalysis.test.ts` compares
+   * the two, edit by edit, on the real fixture.
+   *
+   * Falls back to the full pass whenever the window pass declines — no
+   * previous pass to build on, the validator set or the token source changed
+   * under it, or a validator whose verdicts are not a function of one node
+   * (see `Validator.scope`).
    */
   analyze(): AnalyzeResult {
     if (!this._redRoot) {
       throw new Error('Cannot analyze: no document loaded')
     }
-    const result = this.semanticAnalyzer.analyze(this._redRoot, this._source)
+    const window = this._analysisWindowBroken ? null : this._analysisWindow
+    const result =
+      (window !== null
+        ? this.semanticAnalyzer.analyzeWindow(this._redRoot, this._source, window)
+        : null)
+      ?? this.semanticAnalyzer.analyze(this._redRoot, this._source)
+    // Whatever route it took, the tree is now fully analysed and the next
+    // edit starts a fresh window on top of this pass.
+    this._analysisWindow = null
+    this._analysisWindowBroken = false
     this._diagnostics = result.diagnostics
 
     // Keep the id index out of the retained result: holding it would pin every
@@ -584,6 +715,8 @@ export class DocumentModel {
       diagnostics: result.diagnostics,
       duration: result.duration,
       nodesAnalyzed: result.nodesAnalyzed,
+      scope: result.scope,
+      window: result.window,
     }
 
     // Attaching diagnostics to nodes used to happen here, and needed an id→node