rip-lang 3.13.111 → 3.13.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.111",
+  "version": "3.13.112",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/components.js

@@ -117,29 +117,6 @@ function getMemberType(target) {
   return null;
 }
 
-function findInheritedTagNearLine(source, line, componentName = null) {
-  if (typeof source !== 'string') return null;
-  const lines = source.split('\n');
-  if (Number.isInteger(line)) {
-    const start = Math.max(0, line - 2);
-    const end = Math.min(lines.length - 1, line + 2);
-    for (let i = start; i <= end; i++) {
-      const m = lines[i]?.match(/#\s*@inherits\s+([A-Za-z][\w-]*)/);
-      if (m) return m[1];
-    }
-  }
-  if (componentName) {
-    const escaped = componentName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const declRe = new RegExp(`\\b${escaped}\\b\\s*=\\s*component\\b`);
-    for (const lineText of lines) {
-      if (!declRe.test(lineText)) continue;
-      const m = lineText.match(/#\s*@inherits\s+([A-Za-z][\w-]*)/);
-      if (m) return m[1];
-    }
-  }
-  return null;
-}
-
 // ============================================================================
 // Prototype Installation
 // ============================================================================
@@ -802,7 +779,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       }
     }
 
-    const inheritsTag = findInheritedTagNearLine(this.options.source, sexpr?.loc?.r, this._componentName);
+    const inheritsTag = rest[0]?.valueOf?.() ?? null;
     const publicPropNames = new Set();
     for (const { name, isPublic } of stateVars) if (isPublic) publicPropNames.add(name);
     for (const { name, isPublic } of readonlyVars) if (isPublic) publicPropNames.add(name);
@@ -913,11 +890,57 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       }
       sl.push('  }');
 
+      // Pre-scan render block for @event: @method bindings to type method params
+      const eventMethodTypes = new Map();
+      if (renderBlock) {
+        const scanEvents = (node) => {
+          if (!Array.isArray(node)) return;
+          const head = node[0]?.valueOf?.() ?? node[0];
+          if (typeof head === 'string' && head !== 'object' && head !== 'switch' && TEMPLATE_TAGS.has(head.split(/[.#]/)[0])) {
+            for (let i = 1; i < node.length; i++) {
+              const arg = node[i];
+              let obj = this.is(arg, 'object') ? arg : null;
+              if (!obj && Array.isArray(arg) && (arg[0] === '->' || arg[0] === '=>') && this.is(arg[2], 'block')) {
+                for (let k = 1; k < arg[2].length; k++) {
+                  if (this.is(arg[2][k], 'object')) { obj = arg[2][k]; break; }
+                }
+              }
+              if (!obj) continue;
+              for (let j = 1; j < obj.length; j++) {
+                const pair = obj[j];
+                if (!Array.isArray(pair) || pair.length < 2) continue;
+                const [key, value] = pair;
+                if (Array.isArray(key) && key[0] === '.' && key[1] === 'this' &&
+                    Array.isArray(value) && value[0] === '.' && value[1] === 'this') {
+                  const eventName = typeof key[2] === 'string' ? key[2] : key[2]?.valueOf?.();
+                  const methodName = typeof value[2] === 'string' ? value[2] : value[2]?.valueOf?.();
+                  if (eventName && methodName && !eventMethodTypes.has(methodName)) {
+                    eventMethodTypes.set(methodName, eventName);
+                  }
+                }
+              }
+            }
+          }
+          for (let i = 1; i < node.length; i++) scanEvents(node[i]);
+        };
+        scanEvents(renderBlock);
+      }
+
       // Methods
       for (const { name, func } of methods) {
         if (Array.isArray(func) && (func[0] === '->' || func[0] === '=>')) {
           const [, params, methodBody] = func;
-          const paramStr = Array.isArray(params) ? params.map(p => this.formatParam(p)).join(', ') : '';
+          let paramStr = Array.isArray(params) ? params.map(p => this.formatParam(p)).join(', ') : '';
+          // Inject event type on untyped first param when method is bound to an event
+          const boundEvent = eventMethodTypes.get(name);
+          if (boundEvent && Array.isArray(params) && params.length > 0) {
+            const firstParam = params[0];
+            const hasType = firstParam?.type || (firstParam instanceof String && firstParam.type);
+            if (!hasType && typeof (firstParam?.valueOf?.() ?? firstParam) === 'string') {
+              const paramName = firstParam?.valueOf?.() ?? firstParam;
+              paramStr = paramStr.replace(paramName, `${paramName}: HTMLElementEventMap['${boundEvent}']`);
+            }
+          }
           const transformed = this.reactiveMembers ? this.transformComponentMembers(methodBody) : methodBody;
           const isAsync = this.containsAwait(methodBody);
           const bodyCode = this.generateFunctionBody(transformed, params || []);

package/src/grammar/grammar.rip

@@ -736,7 +736,8 @@ grammar =
   #          render
   #            div "Count: {@count}"
   Component: [
-    o 'COMPONENT INDENT ComponentBody OUTDENT', '["component", null, ["block", ...3]]'
+    o 'COMPONENT INDENT ComponentBody OUTDENT'                    , '["component", null, ["block", ...3]]'
+    o 'COMPONENT EXTENDS Expression INDENT ComponentBody OUTDENT' , '["component", 3, ["block", ...5]]'
   ]
 
   ComponentBody: [