rip-lang 3.13.129 → 3.13.130

package/docs/ui/hljs-rip.js

@@ -163,6 +163,12 @@ export default function(hljs) {
     ],
   };
 
+  const MAP_LITERAL = {
+    className: 'operator',
+    begin: /\*(?=\{)/,
+    relevance: 5,
+  };
+
   const OPERATORS = {
     className: 'operator',
     begin: /\|>|::|:=|~=|~>|<=>|\.=|=!|!\?|\?!|=~|\?\?=|\?\?|\?\.|\.\.\.|\.\.|=>|->|\*\*|\/\/|%%|===|!==|==|!=|<=|>=|&&|\|\||[+\-*\/%&|^~<>=!?]/,
@@ -199,6 +205,7 @@ export default function(hljs) {
       INSTANCE_VAR,
       SIGIL_ATTR,
       TYPE_KEYWORDS,
+      MAP_LITERAL,
       OPERATORS,
       { // inline JS (backtick)
         className: 'string',

package/package.json

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

package/src/AGENTS.md

@@ -53,6 +53,7 @@ Complete node reference:
 // Data Structures
 ['array', ...elements]
 ['object', ...pairs]            // pairs: [key, value]
+['map-literal', ...pairs]       // *{ } → new Map([[key, value], ...])
 ['...', expr]                   // Spread (prefix only)
 
 // Operators

package/src/compiler.js

@@ -40,6 +40,8 @@ let STMT_ONLY = new Set([
   'while', 'until', 'loop', 'switch', 'try', 'throw',
 ]);
 
+let MAP_LITERAL_KEYS = new Set(['true', 'false', 'null', 'undefined', 'Infinity', 'NaN']);
+
 function isInline(arr) {
   if (!Array.isArray(arr) || arr.length === 0) return false;
   let head = arr[0]?.valueOf?.() ?? arr[0];
@@ -183,6 +185,7 @@ export class CodeGenerator {
     // Data structures
     'array': 'generateArray',
     'object': 'generateObject',
+    'map-literal': 'generateMap',
     'block': 'generateBlock',
 
     // Property access
@@ -711,10 +714,19 @@ export class CodeGenerator {
     }
 
     if (this.programVars.size > 0) {
-      let vars = Array.from(this.programVars).sort().join(', ');
-      if (needsBlank) code += '\n';
-      code += `let ${vars};\n`;
-      needsBlank = true;
+      let hasUnderscore = this.programVars.has('_');
+      if (hasUnderscore) this.programVars.delete('_');
+      if (this.programVars.size > 0) {
+        let vars = Array.from(this.programVars).sort().join(', ');
+        if (needsBlank) code += '\n';
+        code += `let ${vars};\n`;
+        needsBlank = true;
+      }
+      if (hasUnderscore) {
+        if (needsBlank) code += '\n';
+        code += `var _;\n`;
+        needsBlank = true;
+      }
     }
 
     let skip = this.options.skipPreamble;
@@ -1679,6 +1691,26 @@ export class CodeGenerator {
     return `{${codes}}`;
   }
 
+  generateMap(head, pairs, context) {
+    if (pairs.length === 0) return 'new Map()';
+    let entries = pairs.map(pair => {
+      if (this.is(pair, '...')) return `...${this.generate(pair[1], 'value')}`;
+      let [, key, value] = pair;
+      let keyCode;
+      if (Array.isArray(key)) {
+        keyCode = this.generate(key, 'value');
+      } else {
+        let k = str(key) ?? key;
+        let isIdentifier = !k.startsWith('"') && !k.startsWith("'") && !k.startsWith('/') &&
+          !CodeGenerator.NUMBER_START_RE.test(k) && !MAP_LITERAL_KEYS.has(k);
+        keyCode = isIdentifier ? `"${k}"` : this.generate(key, 'value');
+      }
+      let valCode = this.generate(value, 'value');
+      return `[${keyCode}, ${valCode}]`;
+    }).join(', ');
+    return `new Map([${entries}])`;
+  }
+
   generateBlock(head, statements, context) {
     if (context === 'statement') {
       let stmts = this.withIndent(() => this.formatStatements(statements));

package/src/components.js

@@ -193,7 +193,9 @@ export function installComponentSupport(CodeGenerator, Lexer) {
         }
         j--;
       }
-      return tokens[j] && tokens[j][0] === 'IDENTIFIER' && isTemplateTag(tokens[j][1]);
+      return tokens[j] && tokens[j][0] === 'IDENTIFIER' &&
+        (isTemplateTag(tokens[j][1]) ||
+         (j === 0 || tokens[j - 1][0] === 'INDENT' || tokens[j - 1][0] === 'TERMINATOR' || tokens[j - 1][0] === 'RENDER'));
     };
 
     this.scanTokens(function(token, i, tokens) {
@@ -621,8 +623,11 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     }
 
     // Object literals: transform values but leave bare string keys untouched
-    if (sexpr[0] === 'object') {
-      return ['object', ...sexpr.slice(1).map(pair => {
+    if (sexpr[0] === 'object' || sexpr[0] === 'map-literal') {
+      return [sexpr[0], ...sexpr.slice(1).map(pair => {
+        if (Array.isArray(pair) && pair[0] === '...') {
+          return ['...', this.transformComponentMembers(pair[1], localScope)];
+        }
         if (Array.isArray(pair) && pair.length >= 2) {
           let key = pair[1];
           let newKey = Array.isArray(key) ? this.transformComponentMembers(key, localScope) : key;
@@ -800,7 +805,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       const sl = [];
       sl.push('class {');
       sl.push('  declare _root: Element | null;');
-      sl.push('  emit(name: string, detail?: any): void {}');
+      sl.push('  emit(_name: string, _detail?: any): void {}');
 
       // Constructor — typed props for public state/readonly (matches DTS)
       const propEntries = [];
@@ -822,7 +827,7 @@ export function installComponentSupport(CodeGenerator, Lexer) {
         const propsOpt = hasRequired ? '' : '?';
         let propsType = propEntries.length > 0 ? `{${propEntries.join('; ')}}` : '{}';
         if (inheritsTag) propsType += ` & __RipProps<'${inheritsTag}'>`;
-        sl.push(`  constructor(props${propsOpt}: ${propsType}) {}`);
+        sl.push(`  constructor(_props${propsOpt}: ${propsType}) {}`);
       }
 
       // Infer type from literal initializer when no explicit annotation
@@ -931,7 +936,11 @@ export function installComponentSupport(CodeGenerator, Lexer) {
         if (Array.isArray(func) && (func[0] === '->' || func[0] === '=>')) {
           let [, params, methodBody] = func;
           if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(methodBody)) params = ['it'];
-          let paramStr = Array.isArray(params) ? params.map(p => this.formatParam(p)).join(', ') : '';
+          let paramStr = Array.isArray(params) ? params.map(p => {
+            let base = this.formatParam(p);
+            if (p?.type) base += `: ${p.type}`;
+            return base;
+          }).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) {
@@ -1064,8 +1073,8 @@ export function installComponentSupport(CodeGenerator, Lexer) {
                 constructions.push(`    };`);
               }
             }
-          } else if (typeof head === 'string' && head !== 'object' && head !== 'switch' && (TEMPLATE_TAGS.has(head.split(/[.#]/)[0]) ||
-                     (/^[a-z]/.test(head) && node.length > 1 && Array.isArray(node[1]) && (node[1][0] === '->' || node[1][0] === '=>')))) {
+          } else if (typeof head === 'string' && !CodeGenerator.GENERATORS[head] && (TEMPLATE_TAGS.has(head.split(/[.#]/)[0]) ||
+                     (/^[a-z][\w-]*$/.test(head) && node.length > 1))) {
             const tagName = head.split(/[.#]/)[0];
             const iProps = extractIntrinsicProps(node.slice(1));
             const tagLine = node.loc?.r;

package/src/grammar/grammar.rip

@@ -110,6 +110,7 @@ grammar =
     o 'This'
     o 'Super'
     o 'MetaProperty'
+    o 'MapLiteral'
   ]
 
   # Immediate values — numbers, strings, booleans, etc.
@@ -328,6 +329,45 @@ grammar =
     o 'ObjSpreadExpr INDEX_START INDENT Expression OUTDENT INDEX_END', '["[]", 1, 4]'
   ]
 
+  # ============================================================================
+  # Map Literals — *{ key: value } → new Map([[key, value]])
+  # ============================================================================
+
+  MapLiteral: [
+    o 'MAP_START MAP_END'                        , '["map-literal"]'
+    o 'MAP_START MapAssignList OptComma MAP_END' , '["map-literal", ...2]'
+  ]
+
+  MapAssignList: [
+    o ''                                                              , '[]'
+    o 'MapAssignObj'                                                  , '[1]'
+    o 'MapAssignList , MapAssignObj'                                  , '[...1, 3]'
+    o 'MapAssignList OptComma TERMINATOR MapAssignObj'                , '[...1, 4]'
+    o 'MapAssignList OptComma INDENT MapAssignList OptComma OUTDENT'  , '[...1, ...4]'
+  ]
+
+  MapAssignObj: [
+    o 'MapAssignable : Expression'                , '[":", 1, 3]'
+    o 'MapAssignable : INDENT Expression OUTDENT' , '[":", 1, 4]'
+    o '... Expression'                            , '["...", 2]'
+  ]
+
+  MapAssignable: [
+    o 'Identifier'
+    o 'Property'
+    o 'ThisProperty'
+    o 'AlphaNumeric'
+    o 'Regex'
+    o 'BOOL'
+    o 'NULL'       , '"null"'
+    o 'UNDEFINED'  , '"undefined"'
+    o 'INFINITY'
+    o 'NAN'
+    o 'Array'
+    o 'Object'
+    o 'Parenthetical'
+  ]
+
   # ============================================================================
   # Array Literals
   # ============================================================================

package/src/lexer.js

@@ -106,7 +106,7 @@ let CALLABLE = new Set([
 let INDEXABLE = new Set([
   ...CALLABLE,
   'NUMBER', 'INFINITY', 'NAN', 'STRING', 'STRING_END',
-  'REGEX', 'REGEX_END', 'BOOL', 'NULL', 'UNDEFINED', '}',
+  'REGEX', 'REGEX_END', 'BOOL', 'NULL', 'UNDEFINED', '}', 'MAP_END',
 ]);
 
 // Tokens that can follow IMPLICIT_FUNC to start an implicit call
@@ -117,7 +117,7 @@ let IMPLICIT_CALL = new Set([
   'THIS', 'DYNAMIC_IMPORT', 'IMPORT_META', 'NEW_TARGET',
   'UNDEFINED', 'NULL', 'BOOL', 'UNARY', 'DO', 'DO_IIFE',
   'YIELD', 'AWAIT', 'UNARY_MATH', 'SUPER', 'THROW',
-  '@', '->', '=>', '[', '(', '{', '--', '++',
+  '@', '->', '=>', '[', '(', '{', 'MAP_START', '--', '++',
 ]);
 
 // Tokens that can start an implicit call (unspaced, like +/-)
@@ -132,12 +132,12 @@ let IMPLICIT_END = new Set([
 // Tokens that trigger implicit comma insertion before arrows
 let IMPLICIT_COMMA_BEFORE_ARROW = new Set([
   'STRING', 'STRING_END', 'REGEX', 'REGEX_END', 'NUMBER',
-  'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', ']', '}',
+  'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', ']', '}', 'MAP_END',
 ]);
 
 // Tokens that start/end balanced pairs
-let EXPRESSION_START = new Set(['(', '[', '{', 'INDENT', 'CALL_START', 'PARAM_START', 'INDEX_START', 'STRING_START', 'INTERPOLATION_START', 'REGEX_START']);
-let EXPRESSION_END   = new Set([')', ']', '}', 'OUTDENT', 'CALL_END', 'PARAM_END', 'INDEX_END', 'STRING_END', 'INTERPOLATION_END', 'REGEX_END']);
+let EXPRESSION_START = new Set(['(', '[', '{', 'MAP_START', 'INDENT', 'CALL_START', 'PARAM_START', 'INDEX_START', 'STRING_START', 'INTERPOLATION_START', 'REGEX_START']);
+let EXPRESSION_END   = new Set([')', ']', '}', 'MAP_END', 'OUTDENT', 'CALL_END', 'PARAM_END', 'INDEX_END', 'STRING_END', 'INTERPOLATION_END', 'REGEX_END']);
 
 // Balanced pair inverses
 let INVERSES = {
@@ -151,6 +151,7 @@ let INVERSES = {
   'STRING_START': 'STRING_END', 'STRING_END': 'STRING_START',
   'INTERPOLATION_START': 'INTERPOLATION_END', 'INTERPOLATION_END': 'INTERPOLATION_START',
   'REGEX_START': 'REGEX_END', 'REGEX_END': 'REGEX_START',
+  'MAP_START': 'MAP_END', 'MAP_END': 'MAP_START',
 };
 
 // Tokens that close a clause (for normalizeLines)
@@ -1369,6 +1370,7 @@ export class Lexer {
   rewrite(tokens) {
     this.tokens = tokens;
     this.removeLeadingNewlines();
+    this.rewriteMapLiterals();
     this.closeMergeAssignments();
     this.closeOpenCalls();
     this.closeOpenIndexes();
@@ -1390,6 +1392,26 @@ export class Lexer {
     if (i > 0) this.tokens.splice(0, i);
   }
 
+  rewriteMapLiterals() {
+    let tokens = this.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i][0] !== 'MATH' || tokens[i][1] !== '*') continue;
+      let next = tokens[i + 1];
+      if (!next || next[0] !== '{') continue;
+      if (tokens[i].spaced || tokens[i].newLine) continue;
+      let prev = tokens[i - 1];
+      if (prev && INDEXABLE.has(prev[0])) continue;
+      tokens.splice(i, 1);
+      tokens[i][0] = 'MAP_START';
+      let depth = 1;
+      for (let j = i + 1; j < tokens.length && depth > 0; j++) {
+        let tag = tokens[j][0];
+        if (tag === '{' || tag === 'MAP_START') depth++;
+        if (tag === '}') { depth--; if (depth === 0) tokens[j][0] = 'MAP_END'; }
+      }
+    }
+  }
+
   closeOpenCalls() {
     this.scanTokens((token, i) => {
       if (token[0] === 'CALL_START') {
@@ -1694,12 +1716,13 @@ export class Lexer {
 
         let startsLine = s <= 0 || LINE_BREAK.has(this.tokens[s - 1]?.[0]) || this.tokens[s - 1]?.newLine;
 
-        // Check if we're continuing an existing object
+        // Check if we're continuing an existing object or map literal
         if (stackTop()) {
           let [stackTag, stackIdx] = stackTop();
           let stackNext = stack[stack.length - 2];
-          if ((stackTag === '{' || (stackTag === 'INDENT' && stackNext?.[0] === '{' && !isImplicit(stackNext))) &&
-              (startsLine || this.tokens[s - 1]?.[0] === ',' || this.tokens[s - 1]?.[0] === '{' || this.tokens[s]?.[0] === '{')) {
+          let isBrace = (t) => t === '{' || t === 'MAP_START';
+          if ((isBrace(stackTag) || (stackTag === 'INDENT' && isBrace(stackNext?.[0]) && !isImplicit(stackNext))) &&
+              (startsLine || this.tokens[s - 1]?.[0] === ',' || isBrace(this.tokens[s - 1]?.[0]) || isBrace(this.tokens[s]?.[0]))) {
             return forward(1);
           }
         }