mimo-lang 1.1.1 → 2.0.6

package/interpreter/stdlib/array/searchFunctions.js

@@ -0,0 +1,77 @@
+import { BuiltinFunction } from "../../BuiltinFunction.js";
+import { expectArray, expectNumber } from "./arrayUtils.js";
+
+// --- Search and Query Functions ---
+
+export const arrayIncludes = new BuiltinFunction(
+  "includes",
+  (args, interpreter, callNode) => {
+    const [arr, valueToFind, fromIndexArg] = args;
+    expectArray(arr, "includes", interpreter, callNode, 1);
+    // valueToFind can be any Mimo value
+
+    let fromIndex = 0;
+    if (fromIndexArg !== undefined) {
+      if (typeof fromIndexArg !== "number") {
+        throw interpreter.errorHandler.createRuntimeError(
+          `includes() fromIndex (arg 3) must be a number.`,
+          callNode,
+          'ARG001',
+          `Provide a number for the fromIndex parameter.`
+        );
+      }
+      fromIndex = fromIndexArg;
+    }
+
+    // Handle negative fromIndex
+    if (fromIndex < 0) {
+      fromIndex = Math.max(0, arr.length + fromIndex);
+    }
+
+    for (let i = fromIndex; i < arr.length; i++) {
+      const currentValue = arr[i];
+      if (Number.isNaN(valueToFind) && Number.isNaN(currentValue)) {
+        return true;
+      }
+      if (currentValue === valueToFind) {
+        return true;
+      }
+    }
+    return false;
+  },
+  [2, 3], // array, valueToFind, [fromIndex]
+);
+
+export const arrayIndexOf = new BuiltinFunction(
+  "index_of",
+  (args, interpreter, callNode) => {
+    const [arr, valueToFind, fromIndexArg] = args;
+    expectArray(arr, "index_of", interpreter, callNode, 1);
+    // valueToFind can be any Mimo value
+
+    let fromIndex = 0;
+    if (fromIndexArg !== undefined) {
+      expectNumber(fromIndexArg, "index_of", interpreter, callNode, 3);
+      fromIndex = fromIndexArg;
+    }
+
+    return arr.indexOf(valueToFind, fromIndex);
+  },
+  [2, 3], // array, valueToFind, [fromIndex]
+);
+
+export const arrayLastIndexOf = new BuiltinFunction(
+  "last_index_of",
+  (args, interpreter, callNode) => {
+    const [arr, valueToFind, fromIndexArg] = args;
+    expectArray(arr, "last_index_of", interpreter, callNode, 1);
+
+    let fromIndex = arr.length - 1;
+    if (fromIndexArg !== undefined) {
+      expectNumber(fromIndexArg, "last_index_of", interpreter, callNode, 3);
+      fromIndex = fromIndexArg;
+    }
+    return arr.lastIndexOf(valueToFind, fromIndex);
+  },
+  [2, 3], // array, valueToFind, [fromIndex]
+);

package/interpreter/stdlib/array/setFunctions.js

@@ -0,0 +1,49 @@
+import { BuiltinFunction } from '../../BuiltinFunction.js';
+import { expectArray } from './arrayUtils.js';
+
+export const arrayUnique = new BuiltinFunction("unique",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "unique", interpreter, callNode, 1);
+
+        // Use a Set to get unique values, then convert back to array
+        // Note: This works for primitives. For objects/arrays, it checks reference equality.
+        return [...new Set(arr)];
+    },
+    1
+);
+
+export const arrayIntersection = new BuiltinFunction("intersection",
+    (args, interpreter, callNode) => {
+        const [arr1, arr2] = args;
+        expectArray(arr1, "intersection", interpreter, callNode, 1);
+        expectArray(arr2, "intersection", interpreter, callNode, 2);
+
+        const set2 = new Set(arr2);
+        return arr1.filter(item => set2.has(item));
+    },
+    2
+);
+
+export const arrayUnion = new BuiltinFunction("union",
+    (args, interpreter, callNode) => {
+        const [arr1, arr2] = args;
+        expectArray(arr1, "union", interpreter, callNode, 1);
+        expectArray(arr2, "union", interpreter, callNode, 2);
+
+        return [...new Set([...arr1, ...arr2])];
+    },
+    2
+);
+
+export const arrayDifference = new BuiltinFunction("difference",
+    (args, interpreter, callNode) => {
+        const [arr1, arr2] = args;
+        expectArray(arr1, "difference", interpreter, callNode, 1);
+        expectArray(arr2, "difference", interpreter, callNode, 2);
+
+        const set2 = new Set(arr2);
+        return arr1.filter(item => !set2.has(item));
+    },
+    2
+);

package/interpreter/stdlib/array/transformationFunctions.js

@@ -0,0 +1,68 @@
+import { BuiltinFunction } from '../../BuiltinFunction.js';
+import { expectArray } from './arrayUtils.js';
+
+// --- Transformation Functions ---
+
+export const arraySort = new BuiltinFunction("sort",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "sort", interpreter, callNode, 1);
+
+        const newArray = [...arr];
+        const allNumbers = newArray.every(item => typeof item === 'number');
+        const allStrings = newArray.every(item => typeof item === 'string');
+
+        if (allNumbers) {
+            newArray.sort((a, b) => a - b);
+        } else if (allStrings) {
+            newArray.sort();
+        } else {
+            // Mixed types: convert to strings for comparison
+            newArray.sort((a, b) => String(a).localeCompare(String(b)));
+        }
+
+        return newArray;
+    },
+    1
+);
+
+export const arrayReverse = new BuiltinFunction("reverse",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "reverse", interpreter, callNode, 1);
+        const newArray = [...arr];
+        return newArray.reverse();
+    },
+    1
+);
+
+export const arrayShuffle = new BuiltinFunction("shuffle",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "shuffle", interpreter, callNode, 1);
+        const newArray = [...arr];
+        for (let i = newArray.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [newArray[i], newArray[j]] = [newArray[j], newArray[i]];
+        }
+        return newArray;
+    },
+    1
+);
+
+export const arrayConcat = new BuiltinFunction("concat",
+
+    (args, interpreter, callNode) => {
+        if (args.length === 0) {
+            return [];
+        }
+        let resultArray = [];
+        for (let i = 0; i < args.length; i++) {
+            const currentArg = args[i];
+            expectArray(currentArg, "concat", interpreter, callNode, i + 1);
+            resultArray = resultArray.concat(currentArg);
+        }
+        return resultArray;
+    },
+    [1, Infinity] // At least 1 array, but can concatenate many
+);

package/interpreter/stdlib/array.js

@@ -0,0 +1,85 @@
+import { BuiltinFunction } from '../BuiltinFunction.js';
+
+// Import all categorized array functions
+import {
+    arrayMap,
+    arrayFilter,
+    arrayReduce,
+    arrayForEach,
+    arrayFind,
+    arrayFindIndex,
+    arrayFlat,
+    arrayFlatMap,
+    arrayGroupBy,
+    arrayZip,
+    arrayChunk,
+    arrayCount
+} from './array/higherOrderFunctions.js';
+
+import {
+    arrayIncludes,
+    arrayIndexOf,
+    arrayLastIndexOf
+} from './array/searchFunctions.js';
+
+import {
+    arraySlice,
+    arrayFirst,
+    arrayLast,
+    arrayIsEmpty
+} from './array/accessFunctions.js';
+
+import {
+    arraySort,
+    arrayReverse,
+    arrayShuffle,
+    arrayConcat
+} from './array/transformationFunctions.js';
+
+import {
+    arrayUnique,
+    arrayIntersection,
+    arrayUnion,
+    arrayDifference
+} from './array/setFunctions.js';
+
+// --- Module Definition ---
+export const arrayModule = {
+    map: arrayMap,
+    filter: arrayFilter,
+    reduce: arrayReduce,
+    flat: arrayFlat,
+    flat_map: arrayFlatMap,
+    group_by: arrayGroupBy,
+    zip: arrayZip,
+    chunk: arrayChunk,
+    count: arrayCount,
+    for_each: arrayForEach,
+    find: arrayFind,
+    find_index: arrayFindIndex,
+    includes: arrayIncludes,
+    index_of: arrayIndexOf,
+    last_index_of: arrayLastIndexOf,
+    slice: arraySlice,
+    first: arrayFirst,
+    last: arrayLast,
+    is_empty: arrayIsEmpty,
+    sort: arraySort,
+    reverse: arrayReverse,
+    shuffle: arrayShuffle,
+    concat: arrayConcat,
+    unique: arrayUnique,
+    intersection: arrayIntersection,
+    union: arrayUnion,
+    difference: arrayDifference,
+};
+
+
+// --- Initialize Function ---
+export function initializeArrayModule(environment) {
+    const arrayModuleObject = {};
+    for (const [name, func] of Object.entries(arrayModule)) {
+        arrayModuleObject[name] = func;
+    }
+    environment.define('Array', arrayModuleObject);
+}

package/interpreter/stdlib/assert.js

@@ -0,0 +1,143 @@
+import { BuiltinFunction } from "../BuiltinFunction.js";
+import { stringify } from "../Utils.js";
+
+// --- Helper: Deep Equality ---
+function isDeepEqual(a, b) {
+  if (a === b) return true;
+
+  if (
+    typeof a !== "object" ||
+    a === null ||
+    typeof b !== "object" ||
+    b === null
+  ) {
+    return false;
+  }
+
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  if (keysA.length !== keysB.length) return false;
+
+  for (const key of keysA) {
+    if (!keysB.includes(key) || !isDeepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// --- Builtin Functions ---
+
+const assertEq = new BuiltinFunction(
+  "eq",
+  (args, interpreter, callNode) => {
+    const [actual, expected, message] = args;
+    if (!isDeepEqual(actual, expected)) {
+      const msg = message ? `: ${message}` : "";
+      throw interpreter.errorHandler.createRuntimeError(
+        `Assertion Failed${msg}.\n   Expected: ${stringify(expected)}\n   Actual:   ${stringify(actual)}`,
+        callNode,
+        "ASSERT_FAIL",
+      );
+    }
+    return true;
+  },
+  [2, 3], // actual, expected, [message]
+);
+
+const assertNeq = new BuiltinFunction(
+  "neq",
+  (args, interpreter, callNode) => {
+    const [actual, expected, message] = args;
+    if (isDeepEqual(actual, expected)) {
+      const msg = message ? `: ${message}` : "";
+      throw interpreter.errorHandler.createRuntimeError(
+        `Assertion Failed${msg}. Expected values to be different.`,
+        callNode,
+        "ASSERT_FAIL",
+      );
+    }
+    return true;
+  },
+  [2, 3],
+);
+
+const assertTrue = new BuiltinFunction(
+  "true",
+  (args, interpreter, callNode) => {
+    const [condition, message] = args;
+    if (condition !== true) {
+      const msg = message ? `: ${message}` : "";
+      throw interpreter.errorHandler.createRuntimeError(
+        `Assertion Failed${msg}. Expected true, got ${stringify(condition)}`,
+        callNode,
+        "ASSERT_FAIL",
+      );
+    }
+    return true;
+  },
+  [1, 2],
+);
+
+const assertFalse = new BuiltinFunction(
+  "false",
+  (args, interpreter, callNode) => {
+    const [condition, message] = args;
+    if (condition !== false) {
+      const msg = message ? `: ${message}` : "";
+      throw interpreter.errorHandler.createRuntimeError(
+        `Assertion Failed${msg}. Expected false, got ${stringify(condition)}`,
+        callNode,
+        "ASSERT_FAIL",
+      );
+    }
+    return true;
+  },
+  [1, 2],
+);
+
+// Check if a function throws an error
+const assertThrows = new BuiltinFunction(
+  "throws",
+  (args, interpreter, callNode) => {
+    const [fn, message] = args;
+
+    // The argument must be a callable Mimo function
+    if (!fn || typeof fn.call !== "function") {
+      throw interpreter.errorHandler.createRuntimeError(
+        `assert.throws expects a function as the first argument.`,
+        callNode,
+        "TYPE001",
+      );
+    }
+
+    try {
+      // Attempt to execute the function with no arguments
+      fn.call(interpreter, [], callNode);
+    } catch (error) {
+      // It threw an error, which is what we wanted!
+      return true;
+    }
+
+    // If we get here, it didn't throw
+    const msg = message ? `: ${message}` : "";
+    throw interpreter.errorHandler.createRuntimeError(
+      `Assertion Failed${msg}. Expected function to throw an error, but it did not.`,
+      callNode,
+      "ASSERT_FAIL",
+    );
+  },
+  [1, 2],
+);
+
+export const assertModule = {
+  eq: assertEq,
+  neq: assertNeq,
+  true: assertTrue,
+  false: assertFalse,
+  throws: assertThrows,
+};

package/interpreter/stdlib/datetime.js

@@ -0,0 +1,170 @@
+import { BuiltinFunction } from '../BuiltinFunction.js';
+
+// --- Helper for Type Checking ---
+function expectDate(arg, funcName, interpreter, callNode) {
+    if (!(arg instanceof Date)) {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects a datetime object as its first argument.`,
+            callNode, 'TYPE001', 'Use a value returned from datetime.now() or datetime.from_timestamp().'
+        );
+    }
+}
+
+// --- BuiltinFunction Definitions ---
+
+const dtNow = new BuiltinFunction("now",
+    () => {
+        // Returns a new JavaScript Date object representing the current moment.
+        return new Date();
+    },
+    0
+);
+
+const dtGetTimestamp = new BuiltinFunction("get_timestamp",
+    (args, interpreter, callNode) => {
+        const [dateObj] = args;
+        expectDate(dateObj, "datetime.get_timestamp", interpreter, callNode);
+        // Returns the number of milliseconds since the ECMAScript epoch.
+        return dateObj.getTime();
+    },
+    1
+);
+
+const dtFromTimestamp = new BuiltinFunction("from_timestamp",
+    ([timestamp], interpreter, callNode) => {
+        if (typeof timestamp !== 'number') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `datetime.from_timestamp() expects a number (milliseconds). Got '${typeof timestamp}'.`,
+                callNode, 'TYPE001', 'Provide a numeric timestamp.'
+            );
+        }
+        // Returns a new Date object from the timestamp.
+        return new Date(timestamp);
+    },
+    1
+);
+
+const dtToISOString = new BuiltinFunction("to_iso_string",
+    ([dateObj], interpreter, callNode) => {
+        expectDate(dateObj, "datetime.to_iso_string", interpreter, callNode);
+        // Returns a string in simplified extended ISO format (ISO 8601), which is always 24 or 27 characters long.
+        return dateObj.toISOString();
+    },
+    1
+);
+
+const dtFormat = new BuiltinFunction("format",
+    (args, interpreter, callNode) => {
+        const [dateObj, formatStr] = args;
+        expectDate(dateObj, "datetime.format", interpreter, callNode);
+        if (typeof formatStr !== 'string') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `datetime.format() expects a format string as its second argument. Got '${typeof formatStr}'.`,
+                callNode, 'TYPE001', 'Provide a format string (e.g., "YYYY-MM-DD").'
+            );
+        }
+
+        const year = dateObj.getFullYear();
+        const month = String(dateObj.getMonth() + 1).padStart(2, '0'); // Month is 0-indexed
+        const day = String(dateObj.getDate()).padStart(2, '0');
+        const hours = String(dateObj.getHours()).padStart(2, '0');
+        const minutes = String(dateObj.getMinutes()).padStart(2, '0');
+        const seconds = String(dateObj.getSeconds()).padStart(2, '0');
+
+        let formatted = formatStr;
+        formatted = formatted.replace(/YYYY/g, year);
+        formatted = formatted.replace(/MM/g, month);
+        formatted = formatted.replace(/DD/g, day);
+        formatted = formatted.replace(/hh/g, hours);
+        formatted = formatted.replace(/mm/g, minutes);
+        formatted = formatted.replace(/ss/g, seconds);
+
+        return formatted;
+    },
+    2
+);
+
+const dtAdd = new BuiltinFunction("add",
+    (args, interpreter, callNode) => {
+        const [dateObj, amount, unit] = args;
+        expectDate(dateObj, "datetime.add", interpreter, callNode);
+        if (typeof amount !== 'number') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `datetime.add() expects a numeric amount. Got '${typeof amount}'.`,
+                callNode, 'TYPE001', 'Provide a numeric amount to add.'
+            );
+        }
+        if (typeof unit !== 'string') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `datetime.add() expects a string unit. Got '${typeof unit}'.`,
+                callNode, 'TYPE001', 'Provide a string unit (e.g., "days").'
+            );
+        }
+
+        const newDate = new Date(dateObj.getTime());
+        switch (unit.toLowerCase()) {
+            case 'years': newDate.setFullYear(newDate.getFullYear() + amount); break;
+            case 'months': newDate.setMonth(newDate.getMonth() + amount); break;
+            case 'days': newDate.setDate(newDate.getDate() + amount); break;
+            case 'hours': newDate.setHours(newDate.getHours() + amount); break;
+            case 'minutes': newDate.setMinutes(newDate.getMinutes() + amount); break;
+            case 'seconds': newDate.setSeconds(newDate.getSeconds() + amount); break;
+            default:
+                throw interpreter.errorHandler.createRuntimeError(
+                    `Unknown unit '${unit}' for datetime.add().`,
+                    callNode, 'ARG001', 'Supported units: years, months, days, hours, minutes, seconds.'
+                );
+        }
+        return newDate;
+    },
+    3
+);
+
+const dtSubtract = new BuiltinFunction("subtract",
+    (args, interpreter, callNode) => {
+        const [dateObj, amount, unit] = args;
+        expectDate(dateObj, "datetime.subtract", interpreter, callNode);
+        if (typeof amount !== 'number') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `datetime.subtract() expects a numeric amount. Got '${typeof amount}'.`,
+                callNode, 'TYPE001', 'Provide a numeric amount to subtract.'
+            );
+        }
+        if (typeof unit !== 'string') {
+            throw interpreter.errorHandler.createRuntimeError(
+                `datetime.subtract() expects a string unit. Got '${typeof unit}'.`,
+                callNode, 'TYPE001', 'Provide a string unit (e.g., "days").'
+            );
+        }
+
+        const newDate = new Date(dateObj.getTime());
+        switch (unit.toLowerCase()) {
+            case 'years': newDate.setFullYear(newDate.getFullYear() - amount); break;
+            case 'months': newDate.setMonth(newDate.getMonth() - amount); break;
+            case 'days': newDate.setDate(newDate.getDate() - amount); break;
+            case 'hours': newDate.setHours(newDate.getHours() - amount); break;
+            case 'minutes': newDate.setMinutes(newDate.getMinutes() - amount); break;
+            case 'seconds': newDate.setSeconds(newDate.getSeconds() - amount); break;
+            default:
+                throw interpreter.errorHandler.createRuntimeError(
+                    `Unknown unit '${unit}' for datetime.subtract().`,
+                    callNode, 'ARG001', 'Supported units: years, months, days, hours, minutes, seconds.'
+                );
+        }
+        return newDate;
+    },
+    3
+);
+
+
+
+// --- Module Export ---
+export const datetimeModule = {
+    now: dtNow,
+    get_timestamp: dtGetTimestamp,
+    from_timestamp: dtFromTimestamp,
+    to_iso_string: dtToISOString,
+    format: dtFormat,
+    add: dtAdd,
+    subtract: dtSubtract,
+};

package/interpreter/stdlib/env.js

@@ -0,0 +1,54 @@
+import { BuiltinFunction } from "../BuiltinFunction.js";
+
+function expectString(arg, funcName, interpreter, callNode, argPosition = 1) {
+  if (typeof arg !== "string") {
+    throw interpreter.errorHandler.createRuntimeError(
+      `${funcName}() expects a string as argument ${argPosition}. Got '${typeof arg}'.`,
+      callNode,
+      "TYPE001",
+      "Provide an environment variable name as a string."
+    );
+  }
+}
+
+const envGet = new BuiltinFunction(
+  "get",
+  ([name, fallback], interpreter, callNode) => {
+    expectString(name, "env.get", interpreter, callNode, 1);
+    const value = interpreter.adapter.getEnvVariable(name);
+    if (value === undefined || value === null) {
+      return fallback === undefined ? null : fallback;
+    }
+    return value;
+  },
+  [1, 2]
+);
+
+const envHas = new BuiltinFunction(
+  "has",
+  ([name], interpreter, callNode) => {
+    expectString(name, "env.has", interpreter, callNode, 1);
+    const value = interpreter.adapter.getEnvVariable(name);
+    return value !== undefined && value !== null;
+  },
+  1
+);
+
+const envAll = new BuiltinFunction(
+  "all",
+  (args, interpreter) => {
+    const adapterAll = interpreter.adapter.getEnvAll;
+    if (typeof adapterAll === "function") {
+      return adapterAll();
+    }
+    return {};
+  },
+  0
+);
+
+export const envModule = {
+  get: envGet,
+  has: envHas,
+  all: envAll,
+};
+