starlight-cli 1.1.3 → 1.1.4

package/README.md

@@ -2,52 +2,64 @@
 
 Starlight is a lightweight, developer-oriented programming language designed for **server-side scripting, automation, and general-purpose programming**. It combines a clean, readable syntax inspired by JavaScript and Python with powerful runtime features such as async/await, modules, and interactive I/O.
 
-**Official Reference:** [https://starlight-learn-lang.pages.dev/](https://starlight-learn-lang.pages.dev/)
+**Official Reference:** [
 
 ---
 
 ## Key Features
 
-* **Modern, Simple Syntax** – Familiar to JavaScript and Python developers
-* **Async / Await** – Native support for asynchronous operations
-* **Modules & Imports** – Import JavaScript packages or other `.sl` files
-* **Server-side Ready** – Built on Node.js, ideal for backend logic
-* **Interactive I/O** – Built-in `ask` and `sldeploy`
-* **Built-in Utilities** – `sleep`, `len`, `keys`, `values`, `fetch`, `get`, `post`
+
+  - **Modern, Simple Syntax** – Familiar to JavaScript and Python developers
+  - **Async / Await** – Native support for asynchronous operations
+  - **Modules & Imports** – Import JavaScript packages or other `.sl` files
+  - **Server-side Ready** – Built on Node.js, ideal for backend logic
+  - **Interactive I/O** – Built-in `ask` and `sldeploy`
+  - **Built-in Utilities** – `sleep`, `len`, `keys`, `values`, `fetch`, `get`, `post`
+
 
 ---
 
 ## Installation
 
-1. Install **Node.js** (v18+ recommended)
-2. Install Starlight CLI:
 
-```
+  Install **Node.js** (v18+ recommended)1. $1
+  Install Starlight CLI:1. $1
+
+
+```
+
 npm install -g starlight-cli
+
 ```
 
 ---
 
 ## Your First Program (`hello.sl`)
 
-```
+```
+
 let name = ask("What is your name?")
 sldeploy "Hello, " + name + "!"
+
 ```
 
 Run:
 
-```
+```
+
 starlight hello.sl
+
 ```
 
 ---
 
 ## Output
 
-```
+```
+
 What is your name? Alice
 Hello, Alice!
+
 ```
 
 ---
@@ -56,246 +68,187 @@ Hello, Alice!
 
 ### Variables
 
-```
+```
+
 let x = 10
 let text = "hello"
+
 ```
 
 ---
 
 ### Functions
 
-```
+```
+
 func add(a, b) {
   return a + b
 }
 
 sldeploy add(2, 3)
+
 ```
 
 ### Async Functions
 
-```
+```
+
 async func load() {
   let data = await get("https://example.com/api")
   sldeploy data
 }
 
 load()
+
 ```
 
 ---
 
-## Conditionals
-
-```
-if (x > 5) {
-  sldeploy "Greater than 5"
-} else {
-  sldeploy "5 or less"
-}
-```
-
----
-
-## Loops
+## Arrow Functions
 
-### While Loop
+Arrow functions provide a **concise and expressive** way to define functions. They support expressions, block bodies, conditionals, loops, and `return` statements.
 
-```
-let i = 0
-while (i < 3) {
-  sldeploy i
-  i = i + 1
-}
-```
+### Basic Arrow Function
 
----
-
-### For Loop (C-style)
+```
 
+let square = x => x * x
+sldeploy square(5)
+
 ```
-for (let i = 0; i < 3; i = i + 1) {
-  sldeploy i
-}
-```
-
----
 
-### For-In Loop (Python-style)
+### Multiple Parameters
 
-Iterate over arrays:
+```
 
+let add = (a, b) => a + b
+sldeploy add(10, 20)
+
 ```
-let items = ["apple", "banana", "orange"]
 
-for item in items {
-  sldeploy item
-}
-```
+### Block Body with if / else
 
-With `let` (scoped variable):
+```
 
-```
-for let item in items {
-  sldeploy item
+let label = p => {
+  if (p.price > 1000) {
+    return "Premium"
+  } else {
+    return "Standard"
+  }
 }
+
 ```
 
-Iterate over object keys:
+### Arrow Functions with Objects
 
-```
-let user = { "name": "Alice", "age": 20 }
+```
 
-for key in user {
-  sldeploy key + ": " + user[key]
+let summarize = p => {
+  return {
+    "name": p.name,
+    "value": p.price * p.stock
+  }
 }
+
 ```
 
----
-
-## Objects & Arrays
-
-```
-let product = {
-  "name": "Star Lamp",
-  "price": 50,
-  "tags": ["space", "light"]
-}
-
-sldeploy product
-```
-
----
-
-## sldeploy (Output)
-
-`sldeploy` works like Python's `print` and can display **any type**:
-
-```
-sldeploy 42
-sldeploy "hello"
-sldeploy true
-sldeploy [1, 2, 3]
-sldeploy { "a": 1, "b": 2 }
-```
-
-It automatically formats arrays, objects, functions, and nested values.
-
----
-
-## ask (User Input)
-
-```
-let age = ask("Enter your age:")
-sldeploy "You entered: " + age
-```
+Arrow functions capture their surrounding scope and behave like standard functions while remaining lightweight and readable.
 
 ---
 
-## Modules & Imports
-
-### Import JavaScript Packages
-
-```
-import colors from "starlight-color"
-
-sldeploy colors.blue("Hello Starlight")
-```
+## Conditionals
 
-### Import Local Files
+```
 
-```
-import { add } from "./math.sl"
+if (x > 5) {
+  sldeploy "Greater than 5"
+} else {
+  sldeploy "5 or less"
+}
+
 ```
 
 ---
 
-## Built-in Utilities
-
-* `len(value)` – length of array, string, or object
-* `keys(object)` – object keys
-* `values(object)` – object values
-* `sleep(ms)` – async delay
-* `fetch(url)` – low-level fetch
-* `get(url)` – GET request
-* `post(url, data)` – POST request
-* `num(value)` – convert to number
-* `str(value)` – convert to string
+## Loops
 
----
+### While Loop
 
-## Server-side Example
+```
 
-```
-define server = async () => {
+let i = 0
+while (i  {
   let response = await get("https://jsonplaceholder.typicode.com/todos/1")
   sldeploy response
 }
 
 server()
+
 ```
 
 ---
+
 ## Start & Race Statements
 
-Starlight includes a **`start` / `race`** control structure similar to JavaScript `switch`, with **fall-through behavior**. The `start` statement evaluates a discriminant expression and executes all `race` clauses **starting from the first match** until the end, unless a `break` is used.
+Starlight includes a **start / race** control structure similar to a switch statement, with **fall-through behavior**.
 
 ### Syntax
 
-```
-start (<discriminant>) {
-race (<value>) {
-# body
-}
+```
 
-race (<value>) {
-# body
-}
+start (value) {
+  race (1) {
+    # body
+  }
 
+  race (2) {
+    # body
+  }
+}
+
 ```
 
-
-
-- `start` – evaluates the discriminant expression.
-- `race` – each clause is checked; execution starts at the first matching `race` and continues to subsequent races (fall-through).
-- Optional `break` can stop execution early (if implemented).
-
 ### Example
 
-```
+```
+
 define x = 2;
 
 start (x) {
-race (1) { sldeploy("Race 1 executed"); }
-race (2) { sldeploy("Race 2 executed"); }
-race (3) { sldeploy("Race 3 executed"); }
+  race (1) { sldeploy("Race 1 executed"); }
+  race (2) { sldeploy("Race 2 executed"); }
+  race (3) { sldeploy("Race 3 executed"); }
 }
 
 sldeploy("Done with start statement");
-
+
 ```
 
-**Expected Output:**
+### Expected Output
+
+```
 
-```
 Race 2 executed
 Race 3 executed
 Done with start statement
-
+
 ```
+
+---
+
 ## Why Starlight?
 
-Starlight is designed for developers who want:
 
-* A **simple but powerful** scripting language
-* **Fast server-side automation**
-* Familiar syntax with **less boilerplate**
-* Full access to the **Node.js ecosystem**
+  - A **simple but powerful** scripting language
+  - **Fast server-side automation**
+  - Familiar syntax with **less boilerplate**
+  - Full access to the **Node.js ecosystem**
+
 
 ---
 
 📘 Full documentation and tutorials:
-[https://starlight-learn-lang.pages.dev/](https://starlight-learn-lang.pages.dev/)
+https://starlight-learn-lang.pages.dev/](https://starlight-learn-lang.pages.dev/>https://starlight-learn-lang.pages.dev/</link)
 
-**License:** MIT
+**License:** MIT

package/dist/index.js

@@ -1874,16 +1874,33 @@ evalArrowFunction(node, env) {
   if (!node.body) {
     throw new RuntimeError('Arrow function missing body', node, this.source);
   }
+
   if (!Array.isArray(node.params)) {
     throw new RuntimeError('Invalid arrow function parameters', node, this.source);
   }
 
-  return {
-    params: node.params,
-    body: node.body,
-    env: env,
-    arrow: true,
-    async: node.async || false
+  const evaluator = this;
+
+  return async function (...args) {
+    const localEnv = new Environment(env);
+
+    node.params.forEach((p, i) => {
+      localEnv.define(p.name, args[i]);
+    });
+
+    try {
+      if (node.isBlock) {
+        const result = await evaluator.evaluate(node.body, localEnv);
+        return result ?? null;
+      } else {
+        return await evaluator.evaluate(node.body, localEnv);
+      }
+    } catch (err) {
+      if (err instanceof ReturnValue) {
+        return err.value; 
+      }
+      throw err;
+    }
   };
 }
 
@@ -3175,15 +3192,26 @@ postfix() {
 
 arrowFunction(params) {
   const t = this.current;
-  if (t.type === 'ARROW') this.eat('ARROW');
-  const body = this.expression();
+  this.eat('ARROW');
+
+  let body;
+  let isBlock = false;
+
+  if (this.current.type === 'LBRACE') {
+    body = this.block();      
+    isBlock = true;
+  } else {
+    body = this.expression(); 
+  }
+
   const startLine = params.length > 0 ? params[0].line : t.line;
-  const startCol = params.length > 0 ? params[0].column : t.column;
+  const startCol  = params.length > 0 ? params[0].column : t.column;
 
   return {
     type: 'ArrowFunctionExpression',
     params,
     body,
+    isBlock,
     line: startLine,
     column: startCol
   };
@@ -3512,7 +3540,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.3';
+const VERSION = '1.1.4';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

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

package/src/evaluator.js

@@ -531,16 +531,33 @@ evalArrowFunction(node, env) {
   if (!node.body) {
     throw new RuntimeError('Arrow function missing body', node, this.source);
   }
+
   if (!Array.isArray(node.params)) {
     throw new RuntimeError('Invalid arrow function parameters', node, this.source);
   }
 
-  return {
-    params: node.params,
-    body: node.body,
-    env: env,
-    arrow: true,
-    async: node.async || false
+  const evaluator = this;
+
+  return async function (...args) {
+    const localEnv = new Environment(env);
+
+    node.params.forEach((p, i) => {
+      localEnv.define(p.name, args[i]);
+    });
+
+    try {
+      if (node.isBlock) {
+        const result = await evaluator.evaluate(node.body, localEnv);
+        return result ?? null;
+      } else {
+        return await evaluator.evaluate(node.body, localEnv);
+      }
+    } catch (err) {
+      if (err instanceof ReturnValue) {
+        return err.value; 
+      }
+      throw err;
+    }
   };
 }
 

package/src/parser.js

@@ -700,15 +700,26 @@ postfix() {
 
 arrowFunction(params) {
   const t = this.current;
-  if (t.type === 'ARROW') this.eat('ARROW');
-  const body = this.expression();
+  this.eat('ARROW');
+
+  let body;
+  let isBlock = false;
+
+  if (this.current.type === 'LBRACE') {
+    body = this.block();      
+    isBlock = true;
+  } else {
+    body = this.expression(); 
+  }
+
   const startLine = params.length > 0 ? params[0].line : t.line;
-  const startCol = params.length > 0 ? params[0].column : t.column;
+  const startCol  = params.length > 0 ? params[0].column : t.column;
 
   return {
     type: 'ArrowFunctionExpression',
     params,
     body,
+    isBlock,
     line: startLine,
     column: startCol
   };

package/src/starlight.js

@@ -9,7 +9,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const Evaluator = require('./evaluator');
 
-const VERSION = '1.1.3';
+const VERSION = '1.1.4';
 
 const COLOR = {
     reset: '\x1b[0m',