starlight-cli 1.1.20 → 1.1.21

package/dist/index.js

@@ -10356,9 +10356,42 @@ async callFunction(fn, args, env, node = null) {
 
   throw new RuntimeError('Value is not callable', node, this.source);
 }
+createBaseProxy(instance, parentEntity) {
+  const evaluator = this;
+
+  return new Proxy({}, {
+    get(_, prop) {
+      const method = parentEntity.methods[prop];
+
+      if (!method) {
+        throw new RuntimeError(
+          `Base method '${prop}' not found`,
+          null,
+          evaluator.source
+        );
+      }
+
+      return async (...args) => {
+        const methodEnv = new Environment(parentEntity.env);
 
+        methodEnv.define('self', instance);
 
+        if (parentEntity.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, parentEntity.parent)
+          );
+        }
 
+        for (let i = 0; i < method.params.length; i++) {
+          methodEnv.define(method.params[i], args[i]);
+        }
+
+        return await evaluator.evaluate(method.body, methodEnv);
+      };
+    }
+  });
+}
 formatValue(value, seen = new Set()) {
   const color = __nccwpck_require__(55);
 
@@ -11028,6 +11061,19 @@ case 'SliceExpression':
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
+    case 'EntityDeclaration':
+  return await this.evalEntity(node, env);
+
+case 'EntityInstantiation':
+  return await this.evalEntityNew(node, env);
+
+case 'SelfExpression':
+  return env.get('self', node, this.source);
+
+case 'InitMethod':
+  return node;
+case 'InheritsClause':
+  return await this.evalInherits(node, env);
     case 'ForStatement':
 case 'ForInStatement':
   return await this.evalFor(node, env);
@@ -11065,6 +11111,70 @@ case 'RaceClause':
     case 'NewExpression': {
   const callee = await this.evaluate(node.callee, env);
 
+  const args = [];
+  for (const a of node.arguments) {
+    args.push(await this.evaluate(a, env));
+  }
+ 
+  if (callee && callee.methods) {
+    const instance = {};
+ 
+     
+
+    const evaluator = this;
+
+    const entityEnv = new Environment(callee.env);
+    entityEnv.define('self', instance);
+ 
+    if (callee.parent) {
+      entityEnv.define(
+        'base',
+        this.createBaseProxy(instance, callee.parent)
+      );
+    }
+ 
+    if (callee.methods.init) {
+      const init = callee.methods.init;
+
+      for (let i = 0; i < init.params.length; i++) {
+        entityEnv.define(init.params[i], args[i]);
+      }
+
+      await evaluator.evaluate(init.body, entityEnv);
+    }
+ 
+    for (const key in callee.methods) {
+      if (key === 'init') continue;
+
+      instance[key] = async (...callArgs) => {
+        const methodEnv = new Environment(callee.env);
+
+        methodEnv.define('self', instance);
+
+        if (callee.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, callee.parent)
+          );
+        }
+
+        for (let i = 0; i < callee.methods[key].params.length; i++) {
+          methodEnv.define(
+            callee.methods[key].params[i],
+            callArgs[i]
+          );
+        }
+
+        return await evaluator.evaluate(
+          callee.methods[key].body,
+          methodEnv
+        );
+      };
+    }
+
+    return instance;
+  }
+ 
   if (typeof callee === 'object' && callee.body) {
     const evaluator = this;
 
@@ -11074,7 +11184,9 @@ case 'RaceClause':
 
       for (let i = 0; i < callee.params.length; i++) {
         const param = callee.params[i];
-        const paramName = typeof param === 'string' ? param : param.name;
+        const paramName =
+          typeof param === 'string' ? param : param.name;
+
         newEnv.define(paramName, args[i]);
       }
 
@@ -11084,18 +11196,17 @@ case 'RaceClause':
       })();
     };
 
-    const args = [];
-    for (const a of node.arguments) args.push(await this.evaluate(a, env));
     return await new Constructor(...args);
   }
-
-  // native JS constructor fallback
+ 
   if (typeof callee !== 'function') {
-    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
+    throw new RuntimeError(
+      'NewExpression callee is not a function',
+      node,
+      this.source
+    );
   }
 
-  const args = [];
-  for (const a of node.arguments) args.push(await this.evaluate(a, env));
   return new callee(...args);
 }
 
@@ -11104,7 +11215,20 @@ case 'RaceClause':
 
   }
 }
+async evalInherits(node, env) {
+  const parent = await this.evaluate(node.parent, env);
 
+  if (!parent || !parent.methods) {
+    throw new RuntimeError(
+      'Invalid parent entity',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  return parent;
+}
 async evalProgram(node, env) {
   let result = null;
   for (const stmt of node.body) {
@@ -11126,6 +11250,29 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalEntity(node, env) {
+  const entity = {
+    name: node.name,
+    methods: {},
+    parent: null,
+    env
+  };
+
+  if (node.inherits) {
+    entity.parent = await this.evaluate(node.inherits, env);
+  }
+
+  for (const method of node.body) {
+    entity.methods[method.name] = {
+      params: method.params,
+      body: method.body,
+      env
+    };
+  }
+
+  env.define(node.name, entity);
+  return entity;
+}
 async evalSlice(node, env) {
   try {
     const arr = await this.evaluate(node.object, env);
@@ -12242,7 +12389,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or', 'entity', 'self', 'inherits', 'init'
     ];
 }
 
@@ -12536,6 +12683,7 @@ class Parser {
       case 'IF': return this.ifStatement();
       case 'WHILE': return this.whileStatement();
       case 'FOR': return this.forStatement();
+      case 'ENTITY': return this.entityDeclaration();
       case 'DO': return this.doTrackStatement();
       case 'START': return this.startStatement();
       case 'BREAK': return this.breakStatement();
@@ -12603,7 +12751,103 @@ varDeclaration() {
     column: t.column 
   };
 }
+entityDeclaration() {
+  const t = this.current;
+  this.eat('ENTITY');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected entity name",
+      this.current,
+      this.source,
+      "Use: entity Car { ... }"
+    );
+  }
+
+  const name = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let parent = null;
+
+  if (this.current.type === 'INHERITS') {
+    this.eat('INHERITS');
+
+    if (this.current.type !== 'IDENTIFIER') {
+      throw new ParseError(
+        "Expected parent entity name",
+        this.current,
+        this.source
+      );
+    }
+
+    parent = {
+      type: 'Identifier',
+      name: this.current.value
+    };
+
+    this.eat('IDENTIFIER');
+  }
+
+  this.eat('LBRACE');
+
+  const body = [];
+
+  while (this.current.type !== 'RBRACE') {
+    body.push(this.methodDefinition());
+  }
+
+  this.eat('RBRACE');
+
+  return {
+    type: 'EntityDeclaration',
+    name,
+    parent,
+    body,
+    line: t.line,
+    column: t.column
+  };
+}
+methodDefinition() {
+  if (this.current.type !== 'IDENTIFIER' && this.current.type !== 'INIT') {
+    throw new ParseError(
+      "Expected method name",
+      this.current,
+      this.source
+    );
+  }
+
+  const isInit = this.current.type === 'INIT';
+  const name = isInit ? 'init' : this.current.value;
+
+  this.eat(this.current.type);
 
+  this.eat('LPAREN');
+
+  const params = [];
+
+  if (this.current.type !== 'RPAREN') {
+    params.push(this.current.value);
+    this.eat('IDENTIFIER');
+
+    while (this.current.type === 'COMMA') {
+      this.eat('COMMA');
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+    }
+  }
+
+  this.eat('RPAREN');
+
+  const body = this.block();
+
+  return {
+    type: 'MethodDefinition',
+    name,
+    params,
+    body,
+    isInit
+  };
+}
 startStatement() {
   const t = this.current; 
   this.eat('START');
@@ -13886,7 +14130,15 @@ arrowFunction(params) {
 
 primary() {
   const t = this.current;
+if (t.type === 'BASE') {
+  this.eat('BASE');
+  return { type: 'Identifier', name: 'base', line: t.line, column: t.column };
+}
 
+if (t.type === 'SELF') {
+  this.eat('SELF');
+  return { type: 'Identifier', name: 'self', line: t.line, column: t.column };
+}
   if (t.type === 'NUMBER') {
     this.eat('NUMBER');
     return { type: 'Literal', value: t.value, line: t.line, column: t.column };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.20",
+  "version": "1.1.21",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"

package/src/evaluator.js

@@ -146,9 +146,42 @@ async callFunction(fn, args, env, node = null) {
 
   throw new RuntimeError('Value is not callable', node, this.source);
 }
+createBaseProxy(instance, parentEntity) {
+  const evaluator = this;
 
+  return new Proxy({}, {
+    get(_, prop) {
+      const method = parentEntity.methods[prop];
 
+      if (!method) {
+        throw new RuntimeError(
+          `Base method '${prop}' not found`,
+          null,
+          evaluator.source
+        );
+      }
+
+      return async (...args) => {
+        const methodEnv = new Environment(parentEntity.env);
 
+        methodEnv.define('self', instance);
+
+        if (parentEntity.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, parentEntity.parent)
+          );
+        }
+
+        for (let i = 0; i < method.params.length; i++) {
+          methodEnv.define(method.params[i], args[i]);
+        }
+
+        return await evaluator.evaluate(method.body, methodEnv);
+      };
+    }
+  });
+}
 formatValue(value, seen = new Set()) {
   const color = require('starlight-color');
 
@@ -818,6 +851,19 @@ case 'SliceExpression':
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
+    case 'EntityDeclaration':
+  return await this.evalEntity(node, env);
+
+case 'EntityInstantiation':
+  return await this.evalEntityNew(node, env);
+
+case 'SelfExpression':
+  return env.get('self', node, this.source);
+
+case 'InitMethod':
+  return node;
+case 'InheritsClause':
+  return await this.evalInherits(node, env);
     case 'ForStatement':
 case 'ForInStatement':
   return await this.evalFor(node, env);
@@ -855,6 +901,70 @@ case 'RaceClause':
     case 'NewExpression': {
   const callee = await this.evaluate(node.callee, env);
 
+  const args = [];
+  for (const a of node.arguments) {
+    args.push(await this.evaluate(a, env));
+  }
+ 
+  if (callee && callee.methods) {
+    const instance = {};
+ 
+     
+
+    const evaluator = this;
+
+    const entityEnv = new Environment(callee.env);
+    entityEnv.define('self', instance);
+ 
+    if (callee.parent) {
+      entityEnv.define(
+        'base',
+        this.createBaseProxy(instance, callee.parent)
+      );
+    }
+ 
+    if (callee.methods.init) {
+      const init = callee.methods.init;
+
+      for (let i = 0; i < init.params.length; i++) {
+        entityEnv.define(init.params[i], args[i]);
+      }
+
+      await evaluator.evaluate(init.body, entityEnv);
+    }
+ 
+    for (const key in callee.methods) {
+      if (key === 'init') continue;
+
+      instance[key] = async (...callArgs) => {
+        const methodEnv = new Environment(callee.env);
+
+        methodEnv.define('self', instance);
+
+        if (callee.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, callee.parent)
+          );
+        }
+
+        for (let i = 0; i < callee.methods[key].params.length; i++) {
+          methodEnv.define(
+            callee.methods[key].params[i],
+            callArgs[i]
+          );
+        }
+
+        return await evaluator.evaluate(
+          callee.methods[key].body,
+          methodEnv
+        );
+      };
+    }
+
+    return instance;
+  }
+ 
   if (typeof callee === 'object' && callee.body) {
     const evaluator = this;
 
@@ -864,7 +974,9 @@ case 'RaceClause':
 
       for (let i = 0; i < callee.params.length; i++) {
         const param = callee.params[i];
-        const paramName = typeof param === 'string' ? param : param.name;
+        const paramName =
+          typeof param === 'string' ? param : param.name;
+
         newEnv.define(paramName, args[i]);
       }
 
@@ -874,18 +986,17 @@ case 'RaceClause':
       })();
     };
 
-    const args = [];
-    for (const a of node.arguments) args.push(await this.evaluate(a, env));
     return await new Constructor(...args);
   }
-
-  // native JS constructor fallback
+ 
   if (typeof callee !== 'function') {
-    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
+    throw new RuntimeError(
+      'NewExpression callee is not a function',
+      node,
+      this.source
+    );
   }
 
-  const args = [];
-  for (const a of node.arguments) args.push(await this.evaluate(a, env));
   return new callee(...args);
 }
 
@@ -894,7 +1005,20 @@ case 'RaceClause':
 
   }
 }
+async evalInherits(node, env) {
+  const parent = await this.evaluate(node.parent, env);
 
+  if (!parent || !parent.methods) {
+    throw new RuntimeError(
+      'Invalid parent entity',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  return parent;
+}
 async evalProgram(node, env) {
   let result = null;
   for (const stmt of node.body) {
@@ -916,6 +1040,29 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalEntity(node, env) {
+  const entity = {
+    name: node.name,
+    methods: {},
+    parent: null,
+    env
+  };
+
+  if (node.inherits) {
+    entity.parent = await this.evaluate(node.inherits, env);
+  }
+
+  for (const method of node.body) {
+    entity.methods[method.name] = {
+      params: method.params,
+      body: method.body,
+      env
+    };
+  }
+
+  env.define(node.name, entity);
+  return entity;
+}
 async evalSlice(node, env) {
   try {
     const arr = await this.evaluate(node.object, env);

package/src/lexer.js

@@ -28,7 +28,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or', 'entity', 'self', 'inherits', 'init'
     ];
 }
 

package/src/parser.js

@@ -90,6 +90,7 @@ class Parser {
       case 'IF': return this.ifStatement();
       case 'WHILE': return this.whileStatement();
       case 'FOR': return this.forStatement();
+      case 'ENTITY': return this.entityDeclaration();
       case 'DO': return this.doTrackStatement();
       case 'START': return this.startStatement();
       case 'BREAK': return this.breakStatement();
@@ -157,7 +158,103 @@ varDeclaration() {
     column: t.column 
   };
 }
+entityDeclaration() {
+  const t = this.current;
+  this.eat('ENTITY');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected entity name",
+      this.current,
+      this.source,
+      "Use: entity Car { ... }"
+    );
+  }
+
+  const name = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let parent = null;
+
+  if (this.current.type === 'INHERITS') {
+    this.eat('INHERITS');
+
+    if (this.current.type !== 'IDENTIFIER') {
+      throw new ParseError(
+        "Expected parent entity name",
+        this.current,
+        this.source
+      );
+    }
+
+    parent = {
+      type: 'Identifier',
+      name: this.current.value
+    };
+
+    this.eat('IDENTIFIER');
+  }
+
+  this.eat('LBRACE');
+
+  const body = [];
+
+  while (this.current.type !== 'RBRACE') {
+    body.push(this.methodDefinition());
+  }
+
+  this.eat('RBRACE');
+
+  return {
+    type: 'EntityDeclaration',
+    name,
+    parent,
+    body,
+    line: t.line,
+    column: t.column
+  };
+}
+methodDefinition() {
+  if (this.current.type !== 'IDENTIFIER' && this.current.type !== 'INIT') {
+    throw new ParseError(
+      "Expected method name",
+      this.current,
+      this.source
+    );
+  }
+
+  const isInit = this.current.type === 'INIT';
+  const name = isInit ? 'init' : this.current.value;
+
+  this.eat(this.current.type);
 
+  this.eat('LPAREN');
+
+  const params = [];
+
+  if (this.current.type !== 'RPAREN') {
+    params.push(this.current.value);
+    this.eat('IDENTIFIER');
+
+    while (this.current.type === 'COMMA') {
+      this.eat('COMMA');
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+    }
+  }
+
+  this.eat('RPAREN');
+
+  const body = this.block();
+
+  return {
+    type: 'MethodDefinition',
+    name,
+    params,
+    body,
+    isInit
+  };
+}
 startStatement() {
   const t = this.current; 
   this.eat('START');
@@ -1440,7 +1537,15 @@ arrowFunction(params) {
 
 primary() {
   const t = this.current;
+if (t.type === 'BASE') {
+  this.eat('BASE');
+  return { type: 'Identifier', name: 'base', line: t.line, column: t.column };
+}
 
+if (t.type === 'SELF') {
+  this.eat('SELF');
+  return { type: 'Identifier', name: 'self', line: t.line, column: t.column };
+}
   if (t.type === 'NUMBER') {
     this.eat('NUMBER');
     return { type: 'Literal', value: t.value, line: t.line, column: t.column };