rip-lang 3.13.134 → 3.13.136

package/src/types.js

@@ -13,6 +13,52 @@
 //   emitEnum() — the one CodeEmitter method for runtime enum output.
 //     Enums cross into the grammar because they emit runtime JavaScript.
 
+// ============================================================================
+// Shared type declaration constants — single source of truth
+// ============================================================================
+// Used by emitTypes() for .d.ts emission and by compileForCheck() in
+// typecheck.js for virtual .ts injection. Keeping them here eliminates
+// divergence between what gets written to disk and what TS analyzes.
+
+export const INTRINSIC_TYPE_DECLS = [
+  'type __RipElementMap = HTMLElementTagNameMap & Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>;',
+  'type __RipTag = keyof __RipElementMap;',
+  "type __RipBrowserElement = Omit<HTMLElement, 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & { hidden: boolean | 'until-found'; setAttribute(qualifiedName: string, value: any): void; querySelector(selectors: string): __RipBrowserElement | null; querySelectorAll(selectors: string): NodeListOf<__RipBrowserElement>; closest(selectors: string): __RipBrowserElement | null; };",
+  "type __RipDomEl<K extends __RipTag> = Omit<__RipElementMap[K], 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & __RipBrowserElement;",
+  "type __RipAttrKeys<T> = { [K in keyof T]-?: K extends 'style' | 'classList' | 'className' | 'nodeValue' | 'textContent' | 'innerHTML' | 'innerText' | 'outerHTML' | 'outerText' | 'scrollLeft' | 'scrollTop' ? never : K extends `on${string}` | `aria${string}Element` | `aria${string}Elements` ? never : T[K] extends (...args: any[]) => any ? never : (<V>() => V extends Pick<T, K> ? 1 : 2) extends (<V>() => V extends { -readonly [P in K]: T[P] } ? 1 : 2) ? K : never }[keyof T] & string;",
+  'type __RipEvents = { [K in keyof HTMLElementEventMap as `@${K}`]?: ((event: HTMLElementEventMap[K]) => void) | null };',
+  'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean> | __RipClassValue[];',
+  'type __RipProps<K extends __RipTag> = { [P in __RipAttrKeys<__RipElementMap[K]>]?: __RipElementMap[K][P] } & __RipEvents & { ref?: string; class?: __RipClassValue | __RipClassValue[]; style?: string; [k: `data-${string}`]: any; [k: `aria-${string}`]: any };',
+];
+
+export const INTRINSIC_FN_DECL = 'declare function __ripEl<K extends __RipTag>(tag: K, props?: __RipProps<K>): void;';
+
+export const ARIA_TYPE_DECLS = [
+  'type __RipAriaNavHandlers = { next?: () => void; prev?: () => void; first?: () => void; last?: () => void; select?: () => void; dismiss?: () => void; tab?: () => void; char?: () => void; };',
+  "declare const ARIA: {",
+  "  bindPopover(open: boolean, popover: () => Element | null | undefined, setOpen: (isOpen: boolean) => void, source?: (() => Element | null | undefined) | null): void;",
+  "  bindDialog(open: boolean, dialog: () => Element | null | undefined, setOpen: (isOpen: boolean) => void, dismissable?: boolean): void;",
+  "  popupDismiss(open: boolean, popup: () => Element | null | undefined, close: () => void, els?: Array<() => Element | null | undefined>, repos?: (() => void) | null): void;",
+  "  popupGuard(delay?: number): any;",
+  "  listNav(event: KeyboardEvent, handlers: __RipAriaNavHandlers): void;",
+  "  rovingNav(event: KeyboardEvent, handlers: __RipAriaNavHandlers, orientation?: 'vertical' | 'horizontal' | 'both'): void;",
+  "  positionBelow(trigger: Element | null | undefined, popup: Element | null | undefined, gap?: number, setVisible?: boolean): void;",
+  "  position(trigger: Element | null | undefined, floating: Element | null | undefined, opts?: any): void;",
+  "  trapFocus(panel: Element | null | undefined): void;",
+  "  wireAria(panel: Element, id: string): void;",
+  "  lockScroll(instance: any): void;",
+  "  unlockScroll(instance: any): void;",
+  "  hasAnchor: boolean;",
+  "  [key: string]: any;",
+  "};",
+];
+
+export const SIGNAL_INTERFACE = 'interface Signal<T> { value: T; read(): T; lock(): Signal<T>; free(): Signal<T>; kill(): T; }';
+export const SIGNAL_FN = 'declare function __state<T>(value: T | Signal<T>): Signal<T>;';
+export const COMPUTED_INTERFACE = 'interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }';
+export const COMPUTED_FN = 'declare function __computed<T>(fn: () => T): Computed<T>;';
+export const EFFECT_FN = 'declare function __effect(fn: () => void | (() => void)): () => void;';
+
 // ============================================================================
 // installTypeSupport — adds rewriteTypes() to Lexer.prototype
 // ============================================================================
@@ -35,6 +81,7 @@ export function installTypeSupport(Lexer) {
 
   proto.rewriteTypes = function() {
     let tokens = this.tokens;
+    let typeRefNames = this.typeRefNames = new Set();
     let gen = (tag, val, origin) => {
       let t = [tag, val];
       t.pre = 0;
@@ -50,27 +97,33 @@ export function installTypeSupport(Lexer) {
     this.scanTokens((token, i, tokens) => {
       let tag = token[0];
 
-      // ── Generic type parameters: DEF name<T>(...) ──────────────────────
+      // ── Generic type parameters: DEF name<T>(...) or Name<T> = component ──
       // (Generic params on type aliases are handled by the `type` keyword handler below)
       if (tag === 'IDENTIFIER') {
         let next = tokens[i + 1];
         if (next && next[0] === 'COMPARE' && next[1] === '<' && !next.spaced) {
           let isDef = tokens[i - 1]?.[0] === 'DEF';
           let genTokens = collectBalancedAngles(tokens, i + 1);
-          if (genTokens && isDef) {
-            if (!token.data) token.data = {};
-            token.data.typeParams = buildTypeString(genTokens);
-            tokens.splice(i + 1, genTokens.length);
-            // After removing <T>, retag ( as CALL_START if it follows DEF IDENTIFIER
-            if (tokens[i + 1]?.[0] === '(') {
-              tokens[i + 1][0] = 'CALL_START';
-              // Find matching ) and retag as CALL_END
-              let d = 1, m = i + 2;
-              while (m < tokens.length && d > 0) {
-                if (tokens[m][0] === '(' || tokens[m][0] === 'CALL_START') d++;
-                if (tokens[m][0] === ')' || tokens[m][0] === 'CALL_END') d--;
-                if (d === 0) tokens[m][0] = 'CALL_END';
-                m++;
+          if (genTokens) {
+            // Check for component pattern: Name<T> = component
+            let afterAngles = i + 1 + genTokens.length;
+            let isComponent = !isDef && tokens[afterAngles]?.[0] === '=' &&
+                              tokens[afterAngles + 1]?.[0] === 'COMPONENT';
+            if (isDef || isComponent) {
+              if (!token.data) token.data = {};
+              token.data.typeParams = buildTypeString(genTokens);
+              tokens.splice(i + 1, genTokens.length);
+              // After removing <T>, retag ( as CALL_START if it follows DEF IDENTIFIER
+              if (isDef && tokens[i + 1]?.[0] === '(') {
+                tokens[i + 1][0] = 'CALL_START';
+                // Find matching ) and retag as CALL_END
+                let d = 1, m = i + 2;
+                while (m < tokens.length && d > 0) {
+                  if (tokens[m][0] === '(' || tokens[m][0] === 'CALL_START') d++;
+                  if (tokens[m][0] === ')' || tokens[m][0] === 'CALL_END') d--;
+                  if (d === 0) tokens[m][0] = 'CALL_END';
+                  m++;
+                }
               }
             }
           }
@@ -102,7 +155,7 @@ export function installTypeSupport(Lexer) {
           propName = 'returnType';
         } else if (prevToken[0] === 'PARAM_END') {
           // Return type on arrow function — scan forward to -> token
-          let arrowIdx = i + 1 + typeTokens.length;
+          let arrowIdx = i + 1 + typeTokens.consumed;
           let arrowToken = tokens[arrowIdx];
           if (arrowToken && (arrowToken[0] === '->' || arrowToken[0] === '=>')) {
             target = arrowToken;
@@ -117,8 +170,13 @@ export function installTypeSupport(Lexer) {
         if (!target.data) target.data = {};
         target.data[propName] = typeStr;
 
+        // Track identifiers used in type annotations for import elision
+        for (let tt of typeTokens) {
+          if (tt[0] === 'IDENTIFIER') typeRefNames.add(tt[1]);
+        }
+
         // Remove :: and type tokens from stream
-        let removeCount = 1 + typeTokens.length;
+        let removeCount = 1 + typeTokens.consumed;
         tokens.splice(i, removeCount);
         return 0;
       }
@@ -180,7 +238,7 @@ export function installTypeSupport(Lexer) {
 
         // Simple alias: type Name = type-expression
         let typeTokens = collectTypeExpression(tokens, afterEq);
-        tokens.splice(removeFrom, afterEq + typeTokens.length - removeFrom, makeDecl(buildTypeString(typeTokens)));
+        tokens.splice(removeFrom, afterEq + typeTokens.consumed - removeFrom, makeDecl(buildTypeString(typeTokens)));
         return 0;
       }
 
@@ -225,6 +283,61 @@ export function installTypeSupport(Lexer) {
 
       return 1;
     });
+
+    // ── Second pass: detect bodiless typed DEF (overload signatures) ──────
+    // Pattern: DEF IDENTIFIER CALL_START ... CALL_END TERMINATOR (no INDENT body)
+    // These are type-only overload declarations — remove from token stream
+    // and emit as TYPE_DECL markers so emitTypes() can generate DTS lines.
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      if (tokens[i][0] !== 'DEF') continue;
+      let nameToken = tokens[i + 1];
+      if (!nameToken || nameToken[0] !== 'IDENTIFIER') continue;
+
+      // Find CALL_END
+      let j = i + 2;
+      if (tokens[j]?.[0] !== 'CALL_START') continue;
+      let depth = 1;
+      j++;
+      while (j < tokens.length && depth > 0) {
+        if (tokens[j][0] === 'CALL_START') depth++;
+        if (tokens[j][0] === 'CALL_END') depth--;
+        j++;
+      }
+      // j is now past CALL_END
+      let callEndIdx = j - 1;
+
+      // Bodiless = next is TERMINATOR or EOF (not INDENT)
+      let next = tokens[j];
+      if (next && next[0] !== 'TERMINATOR') continue;
+
+      // Must have type annotations to qualify as an overload signature
+      let hasTypes = nameToken.data?.returnType;
+      if (!hasTypes) {
+        for (let k = i + 2; k <= callEndIdx; k++) {
+          if (tokens[k].data?.type) { hasTypes = true; break; }
+        }
+      }
+      if (!hasTypes) continue;
+
+      // Save the overload tokens for emitTypes' collectParams
+      let overloadTokens = tokens.slice(i, j + 1); // DEF through TERMINATOR
+
+      // Check for export before DEF
+      let exported = i >= 1 && tokens[i - 1]?.[0] === 'EXPORT';
+      let spliceFrom = exported ? i - 1 : i;
+      let spliceCount = (j + 1) - spliceFrom; // include TERMINATOR
+
+      let marker = gen('TYPE_DECL', nameToken[1], nameToken);
+      marker.data = {
+        name: nameToken[1],
+        kind: 'overload',
+        overloadTokens,
+        exported,
+      };
+      if (nameToken.data?.typeParams) marker.data.typeParams = nameToken.data.typeParams;
+
+      tokens.splice(spliceFrom, spliceCount, marker);
+    }
   };
 }
 
@@ -236,6 +349,7 @@ export function installTypeSupport(Lexer) {
 function collectTypeExpression(tokens, j) {
   let typeTokens = [];
   let depth = 0;
+  let startJ = j;
 
   while (j < tokens.length) {
     let t = tokens[j];
@@ -275,6 +389,17 @@ function collectTypeExpression(tokens, j) {
 
     // Delimiters that end the type at depth 0
     if (depth === 0) {
+      // After =>, INDENT wraps the return type body — collect through OUTDENT
+      if (tTag === 'INDENT' && typeTokens.length > 0 && typeTokens[typeTokens.length - 1][0] === '=>') {
+        j++; // skip INDENT
+        let nest = 1;
+        while (j < tokens.length && nest > 0) {
+          if (tokens[j][0] === 'INDENT') { nest++; j++; }
+          else if (tokens[j][0] === 'OUTDENT') { nest--; j++; }
+          else { typeTokens.push(tokens[j]); j++; }
+        }
+        continue;
+      }
       if (tTag === '=' || tTag === 'REACTIVE_ASSIGN' ||
           tTag === 'COMPUTED_ASSIGN' || tTag === 'READONLY_ASSIGN' ||
           tTag === 'EFFECT' || tTag === 'TERMINATOR' ||
@@ -290,6 +415,8 @@ function collectTypeExpression(tokens, j) {
     j++;
   }
 
+  typeTokens.consumed = j - startJ;
+
   return typeTokens;
 }
 
@@ -306,7 +433,8 @@ function buildTypeString(typeTokens) {
     .replace(/\s*,\s*/g, ', ')
     .replace(/\s*=>\s*/g, ' => ')
     .replace(/ :: /g, ': ')
-    .replace(/:: /g, ': ');
+    .replace(/:: /g, ': ')
+    .replace(/ : /g, ': ');
   return typeStr;
 }
 
@@ -348,6 +476,32 @@ function collectStructuralType(tokens, indentIdx) {
     }
     if (t[0] === 'TERMINATOR') { j++; continue; }
 
+    // Index signature: [key: Type]: ValueType
+    if (depth === 1 && t[0] === '[') {
+      let sigTokens = [];
+      j++; // skip [
+      // Collect tokens through matching ]
+      while (j < tokens.length && tokens[j][0] !== ']') {
+        sigTokens.push(tokens[j]);
+        j++;
+      }
+      j++; // skip ]
+      // Skip : separator after ]
+      if (tokens[j]?.[1] === ':' || tokens[j]?.[0] === 'TYPE_ANNOTATION') j++;
+      // Collect value type
+      let valTypeTokens = [];
+      while (j < tokens.length) {
+        let pt = tokens[j];
+        if (pt[0] === 'TERMINATOR' || pt[0] === 'OUTDENT') break;
+        valTypeTokens.push(pt);
+        j++;
+      }
+      let sigStr = buildTypeString(sigTokens);
+      let valStr = buildTypeString(valTypeTokens);
+      props.push(`[${sigStr}]: ${valStr}`);
+      continue;
+    }
+
     // Collect a property line: name (? optional) : type
     // Property tokens can be PROPERTY, IDENTIFIER, or keyword tags whose
     // value is a valid identifier (e.g. RENDER "render" in interfaces).
@@ -385,6 +539,20 @@ function collectStructuralType(tokens, indentIdx) {
       let typeDepth = 0;
       while (j < tokens.length) {
         let pt = tokens[j];
+        // Nested structural type: `prop: type` followed by INDENT block
+        if (pt[0] === 'IDENTIFIER' && pt[1] === 'type' && tokens[j + 1]?.[0] === 'INDENT') {
+          j++; // skip 'type'
+          let nestedType = collectStructuralType(tokens, j);
+          propTypeTokens.push(['', nestedType]);
+          // Skip past the INDENT...OUTDENT block
+          let nd = 1; j++;
+          while (j < tokens.length && nd > 0) {
+            if (tokens[j][0] === 'INDENT') nd++;
+            if (tokens[j][0] === 'OUTDENT') nd--;
+            j++;
+          }
+          continue;
+        }
         if (pt[0] === 'INDENT') { typeDepth++; j++; continue; }
         if (pt[0] === 'OUTDENT') {
           if (typeDepth > 0) { typeDepth--; j++; continue; }
@@ -514,7 +682,19 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         else if (body[c] === '}') { depth--; if (depth === 0) { firstTopClose = c; break; } }
       }
       if (firstTopClose === body.length - 1) {
-        let props = body.slice(2, -2).split('; ').filter(p => p.trim());
+        // Depth-aware split on '; ' at top level only
+        let inner = body.slice(2, -2);
+        let props = [], start = 0, d = 0;
+        for (let c = 0; c < inner.length; c++) {
+          if (inner[c] === '{') d++;
+          else if (inner[c] === '}') d--;
+          else if (d === 0 && inner[c] === ';' && inner[c + 1] === ' ') {
+            props.push(inner.slice(start, c));
+            start = c + 2;
+          }
+        }
+        if (start < inner.length) props.push(inner.slice(start));
+        props = props.filter(p => p.trim());
         if (props.length > 0) {
           lines.push(`${indent()}${prefix}{`);
           indentLevel++;
@@ -839,7 +1019,21 @@ export function emitTypes(tokens, sexpr = null, source = '') {
       let exp = (exported || data.exported) ? 'export ' : '';
       let params = data.typeParams || '';
 
-      if (data.kind === 'interface') {
+      if (data.kind === 'overload') {
+        // Emit function overload signature from saved tokens
+        let ot = data.overloadTokens;
+        let nameToken = ot[1]; // DEF is [0], name is [1]
+        let { params: paramList } = collectParams(ot, 2);
+        let returnType = nameToken.data?.returnType;
+        let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+        let declare = inClass ? '' : (exp ? '' : 'declare ');
+        let typeParams = data.typeParams || '';
+        if (inClass) {
+          lines.push(`${indent()}${data.name}${typeParams}(${paramList.join(', ')})${ret};`);
+        } else {
+          lines.push(`${indent()}${exp}${declare}function ${data.name}${typeParams}(${paramList.join(', ')})${ret};`);
+        }
+      } else if (data.kind === 'interface') {
         let ext = data.extends ? ` extends ${data.extends}` : '';
         emitBlock(`${exp}interface ${data.name}${params}${ext} `, data.typeText || '{}', '');
       } else {
@@ -1143,43 +1337,21 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   // Prepend reactive type definitions if used
   let preamble = [];
   if (usesRipIntrinsicProps) {
-    preamble.push('type __RipElementMap = HTMLElementTagNameMap & Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>;');
-    preamble.push('type __RipTag = keyof __RipElementMap;');
-    preamble.push("type __RipBrowserElement = Omit<HTMLElement, 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & { hidden: boolean | 'until-found'; setAttribute(qualifiedName: string, value: any): void; querySelector(selectors: string): __RipBrowserElement | null; querySelectorAll(selectors: string): NodeListOf<__RipBrowserElement>; closest(selectors: string): __RipBrowserElement | null; };");
-    preamble.push("type __RipDomEl<K extends __RipTag> = Omit<__RipElementMap[K], 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & __RipBrowserElement;");
-    preamble.push("type __RipAttrKeys<T> = { [K in keyof T]-?: K extends 'style' ? never : T[K] extends (...args: any[]) => any ? never : K }[keyof T] & string;");
-    preamble.push('type __RipEvents = { [K in keyof HTMLElementEventMap as `@${K}`]?: ((event: HTMLElementEventMap[K]) => void) | null };');
-    preamble.push('type __RipClassValue = string | boolean | null | undefined | Record<string, boolean> | __RipClassValue[]'); preamble.push('type __RipProps<K extends __RipTag> = { [P in __RipAttrKeys<__RipElementMap[K]>]?: __RipElementMap[K][P] } & __RipEvents & { ref?: string; class?: __RipClassValue | __RipClassValue[]; style?: string; [k: `data-${string}`]: any; [k: `aria-${string}`]: any };');
+    preamble.push(...INTRINSIC_TYPE_DECLS);
   }
   if (/\bARIA\./.test(source)) {
-    preamble.push("type __RipAriaNavHandlers = { next?: () => void; prev?: () => void; first?: () => void; last?: () => void; select?: () => void; dismiss?: () => void; tab?: () => void; char?: () => void; };");
-    preamble.push("declare const ARIA: {");
-    preamble.push("  bindPopover(open: boolean, popover: () => Element | null | undefined, setOpen: (isOpen: boolean) => void, source?: (() => Element | null | undefined) | null): void;");
-    preamble.push("  bindDialog(open: boolean, dialog: () => Element | null | undefined, setOpen: (isOpen: boolean) => void, dismissable?: boolean): void;");
-    preamble.push("  popupDismiss(open: boolean, popup: () => Element | null | undefined, close: () => void, els?: Array<() => Element | null | undefined>, repos?: (() => void) | null): void;");
-    preamble.push("  popupGuard(delay?: number): any;");
-    preamble.push("  listNav(event: KeyboardEvent, handlers: __RipAriaNavHandlers): void;");
-    preamble.push("  rovingNav(event: KeyboardEvent, handlers: __RipAriaNavHandlers, orientation?: 'vertical' | 'horizontal' | 'both'): void;");
-    preamble.push("  positionBelow(trigger: Element | null | undefined, popup: Element | null | undefined, gap?: number, setVisible?: boolean): void;");
-    preamble.push("  position(trigger: Element | null | undefined, floating: Element | null | undefined, opts?: any): void;");
-    preamble.push("  trapFocus(panel: Element | null | undefined): void;");
-    preamble.push("  wireAria(panel: Element, id: string): void;");
-    preamble.push("  lockScroll(instance: any): void;");
-    preamble.push("  unlockScroll(instance: any): void;");
-    preamble.push("  hasAnchor: boolean;");
-    preamble.push("  [key: string]: any;");
-    preamble.push("};");
+    preamble.push(...ARIA_TYPE_DECLS);
   }
   if (usesSignal) {
-    preamble.push('interface Signal<T> { value: T; read(): T; lock(): Signal<T>; free(): Signal<T>; kill(): T; }');
-    preamble.push('declare function __state<T>(value: T | Signal<T>): Signal<T>;');
+    preamble.push(SIGNAL_INTERFACE);
+    preamble.push(SIGNAL_FN);
   }
   if (usesComputed) {
-    preamble.push('interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }');
-    preamble.push('declare function __computed<T>(fn: () => T): Computed<T>;');
+    preamble.push(COMPUTED_INTERFACE);
+    preamble.push(COMPUTED_FN);
   }
   if (usesSignal || usesComputed) {
-    preamble.push('declare function __effect(fn: () => void | (() => void)): () => void;');
+    preamble.push(EFFECT_FN);
   }
   if (preamble.length > 0) {
     preamble.push('');
@@ -1253,6 +1425,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
   let exported = false;
   let name = null;
   let compNode = null;
+  let typeParams = '';
 
   if (head === 'export' && Array.isArray(sexpr[1])) {
     exported = true;
@@ -1260,11 +1433,13 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
     let innerHead = inner[0]?.valueOf?.() ?? inner[0];
     if (innerHead === '=' && Array.isArray(inner[2]) &&
         (inner[2][0]?.valueOf?.() ?? inner[2][0]) === 'component') {
+      typeParams = inner[1]?.typeParams || '';
       name = inner[1]?.valueOf?.() ?? inner[1];
       compNode = inner[2];
     }
   } else if (head === '=' && Array.isArray(sexpr[2]) &&
              (sexpr[2][0]?.valueOf?.() ?? sexpr[2][0]) === 'component') {
+    typeParams = sexpr[1]?.typeParams || '';
     name = sexpr[1]?.valueOf?.() ?? sexpr[1];
     compNode = sexpr[2];
   }
@@ -1361,7 +1536,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
       }
     }
 
-    lines.push(`${exp}declare class ${name} {`);
+    lines.push(`${exp}declare class ${name}${typeParams} {`);
     if (publicProps.length > 0 || inheritedPropsType) {
       let propsOpt = hasRequired ? '' : '?';
       if (publicProps.length > 0) {

package/src/ui.rip

@@ -798,6 +798,10 @@ export createRenderer = (opts = {}) ->
         mp.appendChild cached._target
         currentComponent = cached
         currentRoute = route.file
+        cached.params = params if params
+        cached.query = query if query
+        cached.mounted() if cached.mounted
+        cached.load!(params, query) if cached.load
       else
         pageWrapper = document.createElement('div')
         pageWrapper.setAttribute 'data-component', route.file