rip-lang 3.13.77 → 3.13.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.77",
+  "version": "3.13.79",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
@@ -66,5 +66,8 @@
   },
   "homepage": "https://github.com/shreeve/rip-lang#readme",
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "5.9.3"
+  }
 }

package/src/compiler.js

@@ -671,26 +671,32 @@ export class CodeGenerator {
       }
     }
 
-    if (this.usesReactivity && !skip) {
-      if (skipRT) {
-        code += 'var { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
-      } else if (typeof globalThis !== 'undefined' && globalThis.__rip) {
-        code += 'const { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
-      } else {
-        code += this.getReactiveRuntime();
-      }
+    if (this.options.lspMode && (this.usesReactivity || this.usesTemplates)) {
+      if (needsBlank) code += '\n';
+      code += getLspRuntimeDeclarations();
       needsBlank = true;
-    }
+    } else {
+      if (this.usesReactivity && !skip) {
+        if (skipRT) {
+          code += 'var { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
+        } else if (typeof globalThis !== 'undefined' && globalThis.__rip) {
+          code += 'const { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
+        } else {
+          code += this.getReactiveRuntime();
+        }
+        needsBlank = true;
+      }
 
-    if (this.usesTemplates && !skip) {
-      if (skipRT) {
-        code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
-      } else if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
-        code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
-      } else {
-        code += this.getComponentRuntime();
+      if (this.usesTemplates && !skip) {
+        if (skipRT) {
+          code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+        } else if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
+          code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+        } else {
+          code += this.getComponentRuntime();
+        }
+        needsBlank = true;
       }
-      needsBlank = true;
     }
 
     if (this.dataSection !== null && this.dataSection !== undefined && !skip) {
@@ -3289,12 +3295,15 @@ export class Compiler {
       sourceMap = new SourceMapGenerator(file, sourceFile, source);
     }
 
+    let lspMode = this.options.mode === 'lsp';
+
     let generator = new CodeGenerator({
       dataSection,
-      skipPreamble: this.options.skipPreamble,
+      skipPreamble: lspMode || this.options.skipPreamble,
       skipRuntimes: this.options.skipRuntimes,
       skipExports: this.options.skipExports,
       reactiveVars: this.options.reactiveVars,
+      lspMode,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -3313,6 +3322,11 @@ export class Compiler {
       dts = emitTypes(typeTokens, sexpr);
     }
 
+    // LSP mode: prepend DTS to code for a single combined output
+    if (lspMode && dts) {
+      code = dts.trimEnd() + '\n\n' + code;
+    }
+
     return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
   }
 
@@ -3374,4 +3388,20 @@ export function getComponentRuntime() {
   return new CodeGenerator({}).getComponentRuntime();
 }
 
+export function getLspRuntimeDeclarations() {
+  return `\
+interface Signal<T> { value: T; read(): T; }
+interface Computed<T> { readonly value: T; read(): T; }
+declare function __state<T>(v: T): Signal<T>;
+declare function __computed<T>(fn: () => T): Computed<T>;
+declare function __effect(fn: () => void | (() => void)): () => void;
+declare function __batch<T>(fn: () => T): T;
+declare function __readonly<T>(v: T): Readonly<{ value: T }>;
+declare function setContext(key: string, value: any): void;
+declare function getContext(key: string): any;
+declare function hasContext(key: string): boolean;
+declare class __Component { constructor(props?: any); [key: string]: any; }
+`;
+}
+
 export { formatSExpr };

package/src/components.js

@@ -91,9 +91,10 @@ function extractInputType(pairs) {
  * Handles both [".", "this", name] (@property) and plain string.
  */
 function getMemberName(target) {
-  if (typeof target === 'string') return target;
-  if (Array.isArray(target) && target[0] === '.' && target[1] === 'this' && typeof target[2] === 'string') {
-    return target[2];
+  if (typeof target === 'string' || target instanceof String) return target.valueOf();
+  if (Array.isArray(target) && target[0] === '.' && target[1] === 'this' &&
+      (typeof target[2] === 'string' || target[2] instanceof String)) {
+    return target[2].valueOf();
   }
   return null;
 }
@@ -106,6 +107,16 @@ function isPublicProp(target) {
   return Array.isArray(target) && target[0] === '.' && target[1] === 'this';
 }
 
+/**
+ * Extract type annotation from s-expression target node.
+ * Type annotations are stored as .type on String objects by the type rewriter.
+ */
+function getMemberType(target) {
+  if (target instanceof String && target.type) return target.type;
+  if (Array.isArray(target) && target[2] instanceof String && target[2].type) return target[2].type;
+  return null;
+}
+
 // ============================================================================
 // Prototype Installation
 // ============================================================================
@@ -702,7 +713,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       } else if (op === 'state') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          stateVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]) });
+          stateVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]) });
           memberNames.add(varName);
           reactiveMembers.add(varName);
         }
@@ -716,7 +727,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       } else if (op === 'readonly') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          readonlyVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]) });
+          readonlyVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]) });
           memberNames.add(varName);
         }
       } else if (op === '=') {
@@ -777,7 +788,22 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     lines.push('class extends __Component {');
 
     // --- Init (called by __Component constructor) ---
-    lines.push('  _init(props) {');
+    if (this.options.lspMode) {
+      const typedProps = [];
+      for (const v of [...readonlyVars, ...stateVars]) {
+        if (v.isPublic) {
+          const t = v.type || 'any';
+          typedProps.push(`${v.name}?: ${t}`);
+          typedProps.push(`__bind_${v.name}__?: ${t}`);
+        }
+      }
+      const propsType = typedProps.length > 0
+        ? `{ ${typedProps.join(', ')}, [key: string]: any }`
+        : 'any';
+      lines.push(`  _init(props: ${propsType}) {`);
+    } else {
+      lines.push('  _init(props) {');
+    }
 
     // Constants (readonly)
     for (const { name, value, isPublic } of readonlyVars) {
@@ -858,7 +884,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     }
 
     // --- Render block (fine-grained) ---
-    if (renderBlock) {
+    if (renderBlock && !this.options.lspMode) {
       const renderBody = renderBlock[1];
       const result = this.buildRender(renderBody);
 

package/src/typecheck.js

@@ -36,8 +36,11 @@ export function fromVirtual(p) { return p.endsWith('.rip.ts') ? p.slice(0, -3) :
 // TS error codes to skip — Rip resolves modules differently and
 // treats async return types transparently.
 export const SKIP_CODES = new Set([
-  2307, // Cannot find module
+  2300, // Duplicate identifier (DTS declarations coexist with compiled class bodies)
   2304, // Cannot find name
+  2307, // Cannot find module
+  2393, // Duplicate function implementation
+  2451, // Cannot redeclare block-scoped variable
   1064, // Return type of async function must be Promise
   2582, // Cannot find name 'test' (test runner globals)
   2593, // Cannot find name 'describe' (test runner globals)
@@ -61,100 +64,12 @@ export function createTypeCheckSettings(ts, overrides = {}) {
 
 // ── Shared compilation pipeline ────────────────────────────────────
 
-// Compile a .rip file for type-checking. Merges .d.ts declarations into
-// the compiled JS, detects type annotations, and builds bidirectional
-// source maps. Returns everything both the CLI and LSP need.
+// Compile a .rip file for type-checking. Uses mode: 'lsp' which emits
+// DTS + typed runtime declarations + compiled code in a single output.
+// Builds bidirectional source maps for the LSP and CLI checker.
 export function compileForCheck(filePath, source, compiler) {
-  const result = compiler.compile(source, { sourceMap: true, types: true, skipPreamble: true });
+  const result = compiler.compile(source, { sourceMap: true, types: 'emit', mode: 'lsp' });
   let code = result.code || '';
-  let dts = result.dts ? result.dts.trimEnd() + '\n' : '';
-
-  // Strip .d.ts imports — compiled JS already has them
-  dts = dts.replace(/^import\s.*;\s*\n/gm, '');
-
-  // Extract well-formed function signatures and merge into JS.
-  // Leaving them as bare declarations causes TypeScript to treat
-  // them as overload signatures that conflict with the implementations.
-  const funcSigs = new Map();
-  dts = dts.replace(
-    /^(?:export|declare)\s+function\s+(\w+)\(([^)]*)\):\s*(.+);\s*$/gm,
-    (_m, name, params, ret) => { funcSigs.set(name, { params, ret }); return ''; },
-  );
-  dts = dts.replace(/^\s*\n/gm, '');
-
-  // Strip remaining malformed multi-line declarations
-  dts = dts.replace(/(?:export|declare)\s+function\s+\w+\([\s\S]*?\);\s*/g, '');
-  dts = dts.replace(/^\s*\n/gm, '');
-
-  for (const [name, { params, ret }] of funcSigs) {
-    const paramTypes = new Map();
-    if (params.trim()) {
-      for (const p of params.split(',')) {
-        const colon = p.indexOf(':');
-        if (colon !== -1) paramTypes.set(p.slice(0, colon).trim(), p.slice(colon + 1).trim());
-      }
-    }
-    const funcRe = new RegExp(
-      `((?:export\\s+)?(?:async\\s+)?function\\s+${name})\\(([^)]*)\\)(\\s*\\{)`,
-    );
-    code = code.replace(funcRe, (_match, prefix, codeParams, brace) => {
-      const typed = codeParams.split(',').map(p => {
-        const n = p.trim();
-        const t = paramTypes.get(n);
-        return t ? `${n}: ${t}` : n;
-      }).join(', ');
-      return `${prefix}(${typed}): ${ret}${brace}`;
-    });
-  }
-
-  // Extract reactive const declarations (state, computed, readonly, effect)
-  // from DTS and merge their types into the code — same pattern as functions.
-  // DTS: `declare const clicks: Signal<number>;`  →  removed
-  // Code: `const clicks = __state(0);`  →  `const clicks: Signal<number> = __state(0);`
-  const reactiveConsts = new Map();
-  dts = dts.replace(
-    /^(?:export\s+)?(?:declare\s+)?const\s+(\w+)\s*:\s*(.+?);\s*$/gm,
-    (_m, name, type) => { reactiveConsts.set(name, type); return ''; },
-  );
-  dts = dts.replace(/^\s*\n/gm, '');
-
-  for (const [name, type] of reactiveConsts) {
-    code = code.replace(
-      new RegExp(`(const\\s+${name})\\s*=`),
-      (_, prefix) => `${prefix}: ${type} =`,
-    );
-  }
-
-  // Remove component class implementations when the DTS already has
-  // typed class declarations — avoids "Duplicate identifier" conflicts.
-  for (const m of dts.matchAll(/^(?:export\s+)?declare\s+class\s+(\w+)\b/gm)) {
-    const name = m[1];
-    const re = new RegExp(`^export\\s+const\\s+${name}\\s*=\\s*class\\s+extends\\s+\\w+`);
-    const lines = code.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      if (!re.test(lines[i])) continue;
-      let depth = 0, start = i;
-      for (; i < lines.length; i++) {
-        for (const ch of lines[i]) { if (ch === '{') depth++; else if (ch === '}') depth--; }
-        if (depth <= 0) break;
-      }
-      lines.splice(start, i - start + 1);
-      break;
-    }
-    code = lines.join('\n');
-  }
-
-  // Remove bare `let x;` declarations when the DTS already declares
-  // `let x: Type;` — avoids "Cannot redeclare" conflicts. Handles
-  // both single (`let x;`) and comma-separated (`let x, y;`) forms.
-  const dtsVars = new Set();
-  for (const m of dts.matchAll(/^(?:let|var)\s+(\w+)\s*:/gm)) dtsVars.add(m[1]);
-  if (dtsVars.size) {
-    code = code.replace(/^(let|var)\s+([\w\s,]+);[ \t]*$/gm, (_m, kw, vars) => {
-      const kept = vars.split(',').map(v => v.trim()).filter(v => !dtsVars.has(v));
-      return kept.length ? `${kw} ${kept.join(', ')};` : '';
-    });
-  }
 
   // Determine if this file should be type-checked
   const hasOwnTypes = hasTypeAnnotations(source);
@@ -175,8 +90,9 @@ export function compileForCheck(filePath, source, compiler) {
   // Ensure every file is treated as a module (not a global script)
   if (!/\bexport\b/.test(code) && !/\bimport\b/.test(code)) code += '\nexport {};\n';
 
-  const tsContent = (hasTypes ? dts + '\n' : '') + code;
-  const headerLines = hasTypes ? countLines(dts + '\n') : 1;
+  const dts = result.dts ? result.dts.trimEnd() + '\n' : '';
+  const tsContent = code;
+  const headerLines = hasTypes && dts ? countLines(dts + '\n') : 1;
 
   // Build bidirectional line maps
   const { srcToGen, genToSrc } = buildLineMap(result.reverseMap, result.map, headerLines);