CompilerEvolution

eQuantic.UI Compiler Evolution Roadmap

Vision

Transform the current TypeScriptEmitter from a syntax-based transpiler into a semantic-aware, extensible compiler capable of handling complex business logic and producing optimized, type-safe TypeScript/JavaScript.

Rules of the Game: Controlled Environment & Boundaries

To prevent "spaghetti code" and unsupported operations in the browser, the compiler will enforce strict boundaries, inspired by Next.js (Server/Client split) and Flutter (Constraints).

1. Server vs. Client Split

• Server Components (.cs only): Can use System.IO, DbContext, and any .NET library. Renders static HTML or initial state.
• Client Components (StatefulComponent / StatelessComponent):
  • Allowed: UI Logic, State Management, System.Linq (via compilation), Basic Types (string, int, DateTime).
  • Forbidden: System.IO, System.Net.Http (direct), blocking .Wait().
  • Bridge: Data fetching MUST use ServerActions (RPC style).

2. Semantic Validation (The "Guardrail")

The compiler will reject code that breaks these rules before emitting JS:

• ❌ File.ReadAllText() in a StatefulComponent.
• ❌ Direct SQL queries in OnMount.
• ✅ Calling a method annotated with [ServerAction].

---

Phase 1: Extensibility & Intelligence (Current Focus)

1. Type Mapping Registry

Goal: Replace hardcoded method translations with a data-driven registry. Implementation:

• Create TypeMappingRegistry class.
• Support key-value mapping for types (DateTime -> Date) and methods (Console.WriteLine -> console.log).
• Replace switch statements in CSharpToJsConverter with registry lookups.

2. Structured Code Builder

Goal: Eliminate StringBuilder fragility and ensure syntactically correct output. Implementation:

• Create TypeScriptCodeBuilder class.
• Methods for Class(), Method(), If(), Block(), avoiding manual indentation management.

Phase 2: Semantic Analysis

3. Roslyn Semantic Model

Goal: Resolve types to handle overloads and extension methods correctly. Implementation:

• Update ComponentCompiler to compile C# trees (Roslyn CSharpCompilation).
• Pass SemanticModel to CSharpToJsConverter.
• Use symbol information to distinguish between List.Add and other Add methods.

Phase 3: Advanced Features

4. LINQ Support

Goal: Translate C# LINQ to JS Array methods. Implementation:

• Map .Where -> .filter
• Map .Select -> .map
• Map .First -> .find

5. Async/Await & Tasks

Goal: Robust Task handling. Implementation:

• Ensure all Task returning methods are marked async in JS.
• Automatically await calls to these methods if they are awaited in C#.

2026-08-07 — the spreadsheet model's first transpile caught three emitter gaps

The new sheet model went through eqc on day one and its vitest twin failed three ways — each a GENERAL fix, none a workaround:

• Char arithmetic. A C# char in + - * / % promotes to int and computes on the code unit; the transpiled char is a 1-length string, so 'A' + col concatenated ("A01") and text[i] - '0' went NaN. When the RESULT type is numeric, char operands now lower to code units (constant literals fold to the number; expressions read charCodeAt(0)), and (char)numeric lowers to String.fromCharCode — previously the cast silently vanished. char + string stays concatenation: its result type is string, so the branch never sees it.
• Dictionary enumeration. A transpiled primitive-keyed Dictionary is a plain object — not iterable — so foreach over one (and new List<KeyValuePair<,>>(dict)) emitted dead code. Both now lower through $eq.entries(obj, numericKeys): pairs that destructure as [key, value] AND answer .key/.value (both C# consumption shapes), with numeric keys restored as numbers (Object.entries strings them, and a stringified key turns the next key + 1 into concatenation). Record/struct-keyed dictionaries keep their valueMap lowering — the conformance suite caught the wrap swallowing those, and only primitive keys qualify.
• Generic item annotations. new List<KeyValuePair<int,float>>(…) annotated its let with the bare C# name (KeyValuePair[]), which names nothing in TS; generic items now leave the annotation to inference.