@ugo-studio/jspp 0.1.0

package/src/prelude/descriptors.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "types.hpp"
+#include <optional>
+
+namespace jspp
+{
+    class AnyValue;
+
+    struct DataDescriptor
+    {
+        std::shared_ptr<AnyValue> value;
+        bool writable = true;
+        bool enumerable = false;
+        bool configurable = true;
+    };
+
+    struct AccessorDescriptor
+    {
+        std::optional<std::function<AnyValue(const std::vector<AnyValue> &)>> get; // getter = function or undefined
+        std::optional<std::function<AnyValue(const std::vector<AnyValue> &)>> set; // setter = function or undefined
+        bool enumerable = false;
+        bool configurable = true;
+    };
+}

package/src/prelude/error.hpp

@@ -0,0 +1,31 @@
+
+#pragma once
+
+#include "types.hpp"
+
+namespace jspp
+{
+    class AnyValue;
+
+    struct RuntimeError : std::exception
+    {
+        std::shared_ptr<AnyValue> data;
+
+        explicit RuntimeError(std::shared_ptr<AnyValue> d)
+            : data(std::move(d)) {}
+        explicit RuntimeError(const AnyValue &value)
+            : data(std::make_shared<AnyValue>(value)) {}
+        explicit RuntimeError(AnyValue &&value)
+            : data(std::make_shared<AnyValue>(std::move(value))) {}
+
+        const char *what() const noexcept override;
+        static RuntimeError make_error(const std::string &message, const std::string &name);
+        static AnyValue error_to_value(const std::exception &ex);
+
+        // --- THROWERS
+        static AnyValue throw_unresolved_reference_error(const std::string &var_name);
+        static AnyValue throw_uninitialized_reference_error(const std::string &var_name);
+        static AnyValue throw_immutable_assignment_error();
+        static AnyValue throw_invalid_return_statement_error();
+    };
+}

package/src/prelude/error_helpers.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "types.hpp"
+#include "error.hpp"
+#include "any_value.hpp"
+
+const char *jspp::RuntimeError::what() const noexcept
+{
+    return data->to_std_string().c_str();
+}
+
+jspp::RuntimeError jspp::RuntimeError::make_error(const std::string &message, const std::string &name = "Error")
+{
+    auto errorObj = std::make_shared<AnyValue>(AnyValue::make_object({{"message", AnyValue::make_string(message)}, {"name", AnyValue::make_string(name)}}));
+    (*errorObj).set_own_property(WellKnownSymbols::toString, AnyValue::make_function([errorObj](const std::vector<AnyValue> &) -> AnyValue
+                                                                                     {
+                                                                                  AnyValue name = (*errorObj).get_own_property("name");
+                                                                                  AnyValue message = (*errorObj).get_own_property("message");
+                                                                                  std::string str = "";
+                                                                                  if (name.is_string())
+                                                                                      str = name.to_std_string();
+                                                                                  else
+                                                                                      str = "Error";
+                                                                                  str += ": ";
+                                                                                  if (message.is_string())
+                                                                                      str += message.to_std_string();
+                                                                                  return AnyValue::make_string(str); },
+                                                                                     WellKnownSymbols::toString));
+    return RuntimeError(errorObj);
+}
+jspp::AnyValue jspp::RuntimeError::error_to_value(const std::exception &ex)
+{
+    if (const jspp::RuntimeError *err = dynamic_cast<const jspp::RuntimeError *>(&ex))
+    {
+        return (*err->data);
+    }
+    else
+    {
+        return AnyValue::make_string(ex.what());
+    }
+}
+
+// --- THROWERS
+jspp::AnyValue jspp::RuntimeError::throw_unresolved_reference_error(const std::string &var_name)
+{
+    throw RuntimeError::make_error(var_name + " is not defined", "ReferenceError");
+}
+jspp::AnyValue jspp::RuntimeError::throw_uninitialized_reference_error(const std::string &var_name)
+{
+    throw RuntimeError::make_error("Cannot access '" + var_name + "' before initialization", "ReferenceError");
+}
+jspp::AnyValue jspp::RuntimeError::throw_immutable_assignment_error()
+{
+    throw RuntimeError::make_error("Assignment to constant variable.", "TypeError");
+}
+jspp::AnyValue jspp::RuntimeError::throw_invalid_return_statement_error()
+{
+    throw RuntimeError::make_error("Return statements are only valid inside functions.", "SyntaxError");
+}

package/src/prelude/index.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "types.hpp"
+#include "well_known_symbols.hpp"
+
+// values
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/array.hpp"
+#include "values/function.hpp"
+#include "error.hpp"
+#include "descriptors.hpp"
+#include "any_value.hpp"
+#include "error_helpers.hpp"
+#include "values/prototypes/string.hpp"
+#include "values/prototypes/object.hpp"
+#include "values/prototypes/array.hpp"
+#include "values/prototypes/function.hpp"
+#include "values/operators/object.hpp"
+#include "values/operators/array.hpp"
+#include "values/operators/function.hpp"
+
+// helpers
+#include "operators.hpp"
+#include "access.hpp"
+#include "log_string.hpp"
+
+// js standard libraries
+#include "library/console.hpp"

package/src/prelude/library/console.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "chrono"
+#include "types.hpp"
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/function.hpp"
+#include "operators.hpp"
+#include "log_string.hpp"
+
+#include <cmath>
+#include <sstream>
+#include <iomanip>
+
+static std::unordered_map<std::string, std::chrono::steady_clock::time_point> timers = {};
+
+auto logFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                           {
+                                               for (size_t i = 0; i < args.size(); ++i)
+                                               {
+                                                   std::cout << jspp::LogString::to_log_string(args[i]);
+                                                   if (i < args.size() - 1)
+                                                       std::cout << " ";
+                                               }
+                                               std::cout << "\n";
+                                               return jspp::AnyValue::make_undefined(); }, "");
+auto warnFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                            {
+                                                std::cerr << "\033[33m";
+                                                for (size_t i = 0; i < args.size(); ++i)
+                                                {
+                                                    std::cout << jspp::LogString::to_log_string(args[i]);
+                                                    if (i < args.size() - 1)
+                                                        std::cout << " ";
+                                                }
+                                                std::cerr << "\033[0m" << "\n"; // reset
+                                                return jspp::AnyValue::make_undefined(); }, "");
+auto errorFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                             {
+                                                 std::cerr << "\033[31m";
+                                                 for (size_t i = 0; i < args.size(); ++i)
+                                                 {
+                                                     std::cout << jspp::LogString::to_log_string(args[i]);
+                                                     if (i < args.size() - 1)
+                                                         std::cout << " ";
+                                                 }
+                                                 std::cerr << "\033[0m" << "\n"; // reset
+                                                 return jspp::AnyValue::make_undefined(); }, "");
+auto timeFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                            {
+                                                auto start = std::chrono::steady_clock::now(); // capture immediately
+                                                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                                                timers[key_str] = start;
+                                                return jspp::AnyValue::make_undefined(); }, "");
+
+// helper to format duration in ms -> ms/s/m/h with nice precision
+static auto format_duration = [](double ms) -> std::string
+{
+    std::ostringstream ss;
+    if (ms < 1000.0)
+    {
+        ss << std::fixed << std::setprecision(4) << ms << "ms";
+        return ss.str();
+    }
+    double total_s = ms / 1000.0;
+    if (ms < 60000.0)
+    { // less than a minute -> show seconds
+        ss << std::fixed << std::setprecision(4) << total_s << "s";
+        return ss.str();
+    }
+    if (ms < 3600000.0)
+    { // less than an hour -> show minutes + seconds
+        int minutes = static_cast<int>(ms / 60000.0);
+        double seconds = (ms - minutes * 60000.0) / 1000.0;
+        ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+        return ss.str();
+    }
+    // hours, minutes, seconds
+    int hours = static_cast<int>(ms / 3600000.0);
+    int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
+    double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
+    ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+    return ss.str();
+};
+
+auto timeEndFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                               {
+                                                   auto end = std::chrono::steady_clock::now(); // capture immediately
+                                                   auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                                                   auto it = timers.find(key_str);
+                                                   if (it != timers.end())
+                                                   {
+                                                       std::chrono::duration<double, std::milli> duration = end - it->second;
+                                                       double ms = duration.count();
+                                                       std::string formatted = format_duration(ms);
+                                                       std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
+                                                       timers.erase(it); // remove the timer after ending it
+                                                   }
+                                                   else
+                                                   {
+                                                       std::cout << "Timer '" << key_str << "' does not exist." << "\n";
+                                                   }
+                                                   return jspp::AnyValue::make_undefined(); }, "");
+
+inline auto console = jspp::AnyValue::make_object({
+    {"log", logFn},
+    {"warn", warnFn},
+    {"error", errorFn},
+    {"time", timeFn},
+    {"timeEnd", timeEndFn},
+});

package/src/prelude/library/global.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "types.hpp"
+#include "object.hpp"
+#include "console.hpp"
+
+inline auto global = jspp::Object::make_object({
+    {"console", console},
+});
+inline auto globalThis = global;

package/src/prelude/library/symbol.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "types.hpp"
+#include "object.hpp"
+#include "well_known_symbols.hpp"
+
+inline auto Symbol = jspp::Object::make_object({{"iterator", jspp::Object::make_string(jspp::WellKnownSymbols::iterator)},
+                                                {"toString", jspp::Object::make_string(jspp::WellKnownSymbols::toString)}});

package/src/prelude/log_string.hpp

@@ -0,0 +1,403 @@
+#pragma once
+
+#include "types.hpp"
+#include "well_known_symbols.hpp"
+#include "any_value.hpp"
+#include <sstream>
+#include <unordered_set>
+#include <algorithm>
+
+namespace jspp
+{
+    namespace LogString
+    {
+        // --- Configuration for Logging Verbosity ---
+        const int MAX_DEPTH = 5;
+        const size_t MAX_STRING_LENGTH = 100;
+        const size_t MAX_ARRAY_ITEMS = 50;
+        const size_t MAX_OBJECT_PROPS = 30;
+        // --- Configuration for Horizontal Layout ---
+        const size_t HORIZONTAL_ARRAY_MAX_ITEMS = 10;
+        const size_t HORIZONTAL_OBJECT_MAX_PROPS = 5;
+
+        // ANSI Color Codes for terminal output
+        namespace Color
+        {
+            const std::string RESET = "\033[0m";
+            const std::string GREEN = "\033[32m";
+            const std::string YELLOW = "\033[33m";
+            const std::string CYAN = "\033[36m";
+            const std::string MAGENTA = "\033[35m";
+            const std::string BRIGHT_BLACK = "\033[90m"; // Grey
+        }
+
+        // Forward declarations
+        inline std::string to_log_string(const AnyValue &val);
+        inline std::string to_log_string(const AnyValue &val, std::unordered_set<const void *> &visited, int depth);
+        inline bool is_simple_value(const AnyValue &val);
+
+        inline bool is_valid_js_identifier(const std::string &s)
+        {
+            if (s.empty())
+            {
+                return false;
+            }
+            if (!std::isalpha(s[0]) && s[0] != '_' && s[0] != '$')
+            {
+                return false;
+            }
+            for (size_t i = 1; i < s.length(); ++i)
+            {
+                if (!std::isalnum(s[i]) && s[i] != '_' && s[i] != '$')
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        inline bool is_simple_value(const AnyValue &val)
+        {
+            return val.is_undefined() || val.is_null() || val.is_uninitialized() ||
+                   val.is_boolean() || val.is_number() || val.is_string();
+        }
+
+        inline std::string truncate_string(const std::string &str)
+        {
+            if (str.length() > MAX_STRING_LENGTH)
+            {
+                return str.substr(0, MAX_STRING_LENGTH) + "...";
+            }
+            return str;
+        }
+
+        inline std::string to_log_string(const AnyValue &val)
+        {
+            std::unordered_set<const void *> visited;
+            return to_log_string(val, visited, 0);
+        }
+
+        inline std::string to_log_string(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
+        {
+            // Primitives and simple wrapped values
+            if (val.is_uninitialized())
+                return Color::BRIGHT_BLACK + std::string("<uninitialized>") + Color::RESET;
+            if (val.is_undefined())
+                return Color::BRIGHT_BLACK + std::string("undefined") + Color::RESET;
+            if (val.is_null())
+                return Color::MAGENTA + std::string("null") + Color::RESET;
+            if (val.is_boolean())
+                return Color::YELLOW + std::string(val.as_boolean() ? "true" : "false") + Color::RESET;
+            if (val.is_number())
+                return Color::YELLOW + val.to_std_string() + Color::RESET;
+            if (val.is_string())
+            {
+                const std::string &s = *val.as_string();
+                if (depth == 0)
+                    return truncate_string(s);
+                return Color::GREEN + std::string("\"") + truncate_string(s) + "\"" + Color::RESET;
+            }
+            if (val.is_function())
+            {
+                auto fn = val.as_function();
+                auto name_part = fn->name.size() > 0 ? ": " + fn->name : "";
+                return Color::CYAN + std::string("[Function") + name_part + "]" + Color::RESET;
+            }
+
+            // Depth limit
+            if (depth > MAX_DEPTH)
+            {
+                if (val.is_object())
+                    return Color::CYAN + std::string("[Object]") + Color::RESET;
+                if (val.is_array())
+                    return Color::CYAN + std::string("[Array]") + Color::RESET;
+            }
+
+            // Circular reference detection
+            const void *ptr_address = nullptr;
+            if (val.is_object())
+                ptr_address = val.as_object();
+            else if (val.is_array())
+                ptr_address = val.as_array();
+
+            if (ptr_address)
+            {
+                if (visited.count(ptr_address))
+                    return Color::CYAN + std::string("[Circular]") + Color::RESET;
+                visited.insert(ptr_address);
+            }
+
+            std::string indent(depth * 2, ' ');
+            std::string next_indent((depth + 1) * 2, ' ');
+            std::stringstream ss;
+
+            // Objects
+            if (val.is_object())
+            {
+                auto obj = val.as_object();
+
+                // If custom toString exists on the object, prefer it
+                auto itToString = obj->props.find(jspp::WellKnownSymbols::toString);
+                if (itToString != obj->props.end() && itToString->second.is_function())
+                {
+                    try
+                    {
+                        auto result = itToString->second.as_function("toString")->call({});
+                        return to_log_string(result, visited, depth);
+                    }
+                    catch (...)
+                    {
+                        // ignore and fallback to manual formatting
+                    }
+                }
+
+                size_t prop_count = obj->props.size();
+
+                bool use_horizontal_layout = prop_count > 0 && prop_count <= HORIZONTAL_OBJECT_MAX_PROPS;
+                if (use_horizontal_layout)
+                {
+                    for (const auto &pair : obj->props)
+                    {
+                        if (!is_simple_value(pair.second))
+                        {
+                            use_horizontal_layout = false;
+                            break;
+                        }
+                    }
+                }
+
+                if (use_horizontal_layout)
+                {
+                    ss << "{ ";
+                    size_t current_prop = 0;
+                    for (const auto &pair : obj->props)
+                    {
+                        if (is_valid_js_identifier(pair.first))
+                        {
+                            ss << pair.first;
+                        }
+                        else
+                        {
+                            ss << "\"" << pair.first << "\"";
+                        }
+                        ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                        if (++current_prop < prop_count)
+                            ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                    }
+                    ss << " }";
+                }
+                else
+                {
+                    ss << "{";
+                    if (prop_count > 0)
+                    {
+                        ss << "\n";
+                        size_t props_shown = 0;
+                        for (const auto &pair : obj->props)
+                        {
+                            if (props_shown >= MAX_OBJECT_PROPS)
+                                break;
+                            if (props_shown > 0)
+                                ss << ",\n";
+
+                            ss << next_indent;
+                            if (is_valid_js_identifier(pair.first))
+                            {
+                                ss << pair.first;
+                            }
+                            else
+                            {
+                                ss << "\"" << pair.first << "\"";
+                            }
+                            ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                            props_shown++;
+                        }
+                        if (prop_count > MAX_OBJECT_PROPS)
+                            ss << ",\n"
+                               << next_indent << Color::BRIGHT_BLACK << "... " << (prop_count - MAX_OBJECT_PROPS) << " more properties" << Color::RESET;
+                        ss << "\n"
+                           << indent;
+                    }
+                    ss << "}";
+                }
+                return ss.str();
+            }
+
+            // Arrays
+            if (val.is_array())
+            {
+                auto arr = val.as_array();
+                size_t item_count = static_cast<size_t>(arr->length);
+
+                // If custom toString exists on the object, prefer it
+                auto itToString = arr->props.find(jspp::WellKnownSymbols::toString);
+                if (depth > 0 && itToString != arr->props.end() && itToString->second.is_function())
+                {
+                    try
+                    {
+                        auto result = itToString->second.as_function("toString")->call({});
+                        return to_log_string(result, visited, depth);
+                    }
+                    catch (...)
+                    {
+                        // ignore and fallback to manual formatting
+                    }
+                }
+
+                std::string indent(depth * 2, ' ');
+                std::string next_indent((depth + 1) * 2, ' ');
+                std::stringstream ss;
+
+                // Horizontal layout for small and simple arrays
+                bool use_horizontal_layout = item_count <= HORIZONTAL_ARRAY_MAX_ITEMS;
+                if (use_horizontal_layout)
+                {
+                    for (size_t i = 0; i < item_count; ++i)
+                    {
+                        std::optional<AnyValue> itemVal;
+                        if (i < arr->dense.size())
+                        {
+                            itemVal = arr->dense[i];
+                        }
+                        else
+                        {
+                            auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                            if (it != arr->sparse.end())
+                            {
+                                itemVal = it->second;
+                            }
+                        }
+                        if (itemVal.has_value() && !is_simple_value(itemVal.value()))
+                        {
+                            use_horizontal_layout = false;
+                            break;
+                        }
+                    }
+                }
+
+                if (use_horizontal_layout)
+                {
+                    ss << "[ ";
+                    size_t empty_count = 0;
+                    bool needs_comma = false;
+
+                    for (size_t i = 0; i < item_count; ++i)
+                    {
+                        std::optional<AnyValue> itemVal;
+                        if (i < arr->dense.size())
+                        {
+                            itemVal = arr->dense[i];
+                        }
+                        else
+                        {
+                            auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                            if (it != arr->sparse.end())
+                            {
+                                itemVal = it->second;
+                            }
+                        }
+
+                        if (itemVal.has_value())
+                        {
+                            if (empty_count > 0)
+                            {
+                                if (needs_comma)
+                                    ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                                ss << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                                needs_comma = true;
+                                empty_count = 0;
+                            }
+                            if (needs_comma)
+                                ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                            ss << to_log_string(itemVal.value(), visited, depth + 1);
+                            needs_comma = true;
+                        }
+                        else
+                        {
+                            empty_count++;
+                        }
+                    }
+
+                    if (empty_count > 0)
+                    {
+                        if (needs_comma)
+                            ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                        ss << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                    }
+
+                    ss << " ]";
+                    return ss.str();
+                }
+
+                // Bun-like multi-line layout
+                ss << "[\n";
+
+                const size_t items_to_show = std::min(item_count, MAX_ARRAY_ITEMS);
+                size_t empty_count = 0;
+                bool first_item_printed = false;
+
+                for (size_t i = 0; i < items_to_show; ++i)
+                {
+                    std::optional<AnyValue> itemVal;
+                    if (i < arr->dense.size())
+                    {
+                        itemVal = arr->dense[i];
+                    }
+                    else
+                    {
+                        auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                        if (it != arr->sparse.end())
+                        {
+                            itemVal = it->second;
+                        }
+                    }
+
+                    if (itemVal.has_value())
+                    {
+                        if (empty_count > 0)
+                        {
+                            if (first_item_printed)
+                                ss << Color::BRIGHT_BLACK << ",\n"
+                                   << Color::RESET;
+                            ss << next_indent << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                            first_item_printed = true;
+                            empty_count = 0;
+                        }
+                        if (first_item_printed)
+                            ss << Color::BRIGHT_BLACK << ",\n"
+                               << Color::RESET;
+                        ss << next_indent << to_log_string(itemVal.value(), visited, depth + 1);
+                        first_item_printed = true;
+                    }
+                    else
+                    {
+                        empty_count++;
+                    }
+                }
+
+                if (empty_count > 0)
+                {
+                    if (first_item_printed)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                    ss << next_indent << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                    first_item_printed = true;
+                }
+
+                if (item_count > items_to_show)
+                {
+                    if (first_item_printed)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                    ss << next_indent << Color::BRIGHT_BLACK << "... " << (item_count - items_to_show) << " more items" << Color::RESET;
+                }
+                ss << "\n";
+                ss << indent << "]";
+                return ss.str();
+            }
+
+            // Fallback
+            return val.to_std_string();
+        }
+    }
+}