@xnoxs/flux-lang 3.1.1 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/codegen.js

@@ -93,7 +93,7 @@ class CodeGenerator {
     this.level     = 0;
     this._needsFmt = false;
 
-    this.emit('// Generated by Flux Transpiler v3.1.0');
+    this.emit('// Generated by Flux Transpiler v3.2.0');
     this.emit('"use strict";');
     this.blank();
 
@@ -189,6 +189,16 @@ class CodeGenerator {
       this.out();
       this.emit('}');
     }
+    // Apply decorators: @log fn foo() → foo = log(foo);
+    if (node.name && node.decorators && node.decorators.length > 0) {
+      for (let i = node.decorators.length - 1; i >= 0; i--) {
+        const dec = node.decorators[i];
+        const decArgs = dec.args.length > 0
+          ? `(${dec.args.map(a => this.genExpr(a)).join(', ')})(${node.name})`
+          : `(${node.name})`;
+        this.emit(`${node.name} = ${dec.name}${decArgs};`);
+      }
+    }
   }
 
   // ── class ──────────────────────────────────────────────────────
@@ -197,22 +207,47 @@ class CodeGenerator {
     this.emit(`class ${node.name}${ext} {`);
     this.in();
 
+    // Determine which fields are private (use JS #field syntax)
+    const isPrivate = f => f.modifiers && f.modifiers.has('private');
+    const fieldName = f => isPrivate(f) ? `#${f.name}` : f.name;
+    const fieldRef  = f => isPrivate(f) ? `this.#${f.name}` : `this.${f.name}`;
+
+    // Declare private fields at the top of the class body
+    const privateFields = node.fields.filter(isPrivate);
+    for (const f of privateFields) this.emit(`#${f.name};`);
+    if (privateFields.length > 0) this.blank();
+
     // Constructor
-    const allFields = getAllFields(node.name, this.clsReg);
-    if (allFields.length > 0) {
-      const params = allFields.map(f => f.name).join(', ');
+    // Fields split into:
+    //   paramFields  — no default init (become constructor params)
+    //   initFields   — have a default init expression (assigned in body, not params)
+    const allFields   = getAllFields(node.name, this.clsReg);
+    const paramFields = allFields.filter(f => f.init == null && !isPrivate(f));
+    const initFields  = allFields.filter(f => f.init != null);
+    const ownInitFields = node.fields.filter(f => f.init != null);
+
+    const needsCtor = paramFields.length > 0 || initFields.length > 0 || privateFields.length > 0;
+    if (needsCtor) {
+      const params = paramFields.map(f => f.name).join(', ');
       this.emit(`constructor(${params}) {`);
       this.in();
 
-      // super(...parentFields) if extending
+      // super(...parentParamFields) if extending
       if (node.superClass && this.clsReg[node.superClass]) {
         const parentFields = getAllFields(node.superClass, this.clsReg);
-        if (parentFields.length > 0)
-          this.emit(`super(${parentFields.map(f => f.name).join(', ')});`);
+        const parentParams = parentFields.filter(f => f.init == null);
+        if (parentParams.length > 0)
+          this.emit(`super(${parentParams.map(f => f.name).join(', ')});`);
       }
 
-      // Assign own fields only
-      for (const f of node.fields) this.emit(`this.${f.name} = ${f.name};`);
+      // Assign own non-private param-fields
+      for (const f of node.fields.filter(f => f.init == null && !isPrivate(f)))
+        this.emit(`${fieldRef(f)} = ${f.name};`);
+
+      // Assign own init-fields (including private ones with defaults)
+      for (const f of ownInitFields)
+        this.emit(`${fieldRef(f)} = ${this.genExpr(f.init)};`);
+
       this.out();
       this.emit('}');
       this.blank();
@@ -242,6 +277,18 @@ class CodeGenerator {
 
     this.out();
     this.emit('}');
+
+    // Apply class decorators: @injectable class Foo → Foo = injectable(Foo);
+    if (node.decorators && node.decorators.length > 0) {
+      for (let i = node.decorators.length - 1; i >= 0; i--) {
+        const dec = node.decorators[i];
+        const decArgs = dec.args.length > 0
+          ? `(${dec.args.map(a => this.genExpr(a)).join(', ')})(${node.name})`
+          : `(${node.name})`;
+        this.emit(`${node.name} = ${dec.name}${decArgs};`);
+      }
+    }
+
     this.blank();
   }
 

package/src/linter.js

@@ -75,9 +75,35 @@ const BUILTIN_NAMES = new Set([
   'WeakMap', 'WeakSet', 'Proxy', 'Reflect', 'undefined', 'null', 'true', 'false',
   'NaN', 'Infinity', 'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'setTimeout',
   'clearTimeout', 'setInterval', 'clearInterval', 'fetch', 'globalThis',
-  // Flux stdlib names
-  'print', 'truncate', 'range', 'sum', 'first', 'last', 'zip', 'flatten',
-  'groupBy', 'unique', 'sortBy', 'chunk',
+  // Flux stdlib — sequences
+  'range', 'zip', 'enumerate', 'flatten', 'chunk', 'unique', 'groupBy', 'sortBy',
+  // Flux stdlib — array pipe helpers
+  'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex',
+  'some', 'every', 'join', 'sort', 'flat', 'flatMap', 'includes',
+  // Flux stdlib — array extras
+  'first', 'last', 'take', 'drop', 'takeWhile', 'dropWhile',
+  'compact', 'intersection', 'difference', 'arrayUnion', 'unzip',
+  'countBy', 'minBy', 'maxBy', 'toPairs', 'partition', 'count',
+  'head', 'tail', 'nth', 'rotate', 'sliding',
+  // Flux stdlib — math
+  'clamp', 'sum', 'product', 'min', 'max', 'abs', 'floor', 'ceil', 'round',
+  'mean', 'median', 'stdDev', 'lerp', 'randInt', 'sample', 'shuffle',
+  // Flux stdlib — objects
+  'pick', 'omit', 'mapValues', 'filterValues', 'fromEntries',
+  'keys', 'values', 'entries', 'merge', 'invert', 'defaults',
+  'deepEqual', 'deepClone',
+  // Flux stdlib — strings
+  'capitalize', 'camelCase', 'snakeCase', 'kebabCase', 'truncate', 'pad',
+  'padStart', 'padEnd', 'trim', 'trimStart', 'trimEnd',
+  'words', 'lines', 'startsWith', 'endsWith', 'repeat', 'replaceAll', 'reverseStr',
+  // Flux stdlib — type checks
+  'isNil', 'isString', 'isNumber', 'isArray', 'isObject', 'isFunction', 'isBool',
+  // Flux stdlib — async
+  'sleep', 'retry', 'memoize', 'timeout', 'debounce', 'throttle', 'allSettled',
+  // Flux stdlib — functional
+  'pipe', 'compose', 'partial', 'curry', 'identity', 'noop', 'once', 'flip', 'complement',
+  // Flux builtins
+  'print',
 ]);
 
 function isIgnoredName(name) {

package/src/parser.js

@@ -226,14 +226,38 @@ class Parser {
     return stmts;
   }
 
+  // ── Decorator parsing: @name or @name(args) ───────────────────
+  parseDecorators() {
+    const decorators = [];
+    while (this.check(T.AT)) {
+      const loc = this.skip(); // consume @
+      const name = this.eat(T.IDENT).value;
+      let args = [];
+      if (this.check(T.LPAREN)) {
+        this.pos++; // consume (
+        while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
+          args.push(this.parseExpr());
+          if (!this.maybe(T.COMMA)) break;
+        }
+        this.eat(T.RPAREN);
+      }
+      decorators.push({ name, args, loc });
+      this.skipNewlines();
+    }
+    return decorators;
+  }
+
   parseOneStmt() {
+    // Collect decorators (@decorator) before any declaration
+    const decorators = this.check(T.AT) ? this.parseDecorators() : [];
+
     const tok = this.peek();
     switch (tok.type) {
       case T.VAR:
       case T.VAL:      return this.parseVarDecl();
-      case T.FN:       return this.parseFnDecl();
-      case T.ASYNC:    return this.parseAsyncFn();
-      case T.CLASS:    return this.parseClassDecl();
+      case T.FN:       { const n = this.parseFnDecl();       if (decorators.length) n.decorators = decorators; return n; }
+      case T.ASYNC:    { const n = this.parseAsyncFn();      if (decorators.length) n.decorators = decorators; return n; }
+      case T.CLASS:    { const n = this.parseClassDecl();    if (decorators.length) n.decorators = decorators; return n; }
       case T.IF:       return this.parseIf();
       case T.FOR:      return this.parseFor();
       case T.WHILE:    return this.parseWhile();
@@ -854,14 +878,27 @@ class Parser {
         const m = this.check(T.ASYNC) ? this.parseAsyncFn() : this.parseFnDecl();
         m.modifiers = mods; m.modifiers.add('static');
         methods.push(m);
+      } else if (this.check(T.VAR) || this.check(T.VAL)) {
+        // `var fieldName: Type = init` or `var fieldName = init` in class body
+        const fieldKind = this.skip().type === T.VAR ? 'var' : 'val';
+        const fname = this.eat(T.IDENT).value;
+        let optional = false;
+        let ftype = null;
+        if (this.check(T.QUESTION)) { this.pos++; optional = true; }
+        if (this.check(T.COLON)) { this.pos++; ftype = this.parseTypeAnn(); }
+        let init = null;
+        if (this.check(T.EQ)) { this.pos++; init = this.parseExpr(); }
+        this.skipNewlines();
+        fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods, init, fieldKind });
       } else if (this.check(T.IDENT)) {
+        // Bare `fieldName: Type` without var/val keyword (interface-style field in class)
         const fname = this.eat(T.IDENT).value;
         let optional = false;
         if (this.check(T.QUESTION)) { this.pos++; optional = true; }
         this.eat(T.COLON);
         const ftype = this.parseTypeAnn();
         this.skipNewlines();
-        fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods });
+        fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods, init: null });
       } else {
         this.skip();
       }