@ugo-studio/jspp 0.1.3 → 0.1.4

package/src/prelude/values/prototypes/symbol.hpp

@@ -11,9 +11,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsSymbol *self)
         {
             // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            if (key == "toString" )
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
@@ -22,10 +22,12 @@ namespace jspp
             if (key == "description")
             {
                 return AnyValue::make_accessor_descriptor(
-                    [self](const std::vector<AnyValue> &) -> AnyValue
+                    [self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
                     {
                         if (self->description.empty())
+                        {
                             return AnyValue::make_undefined();
+                        }
                         return AnyValue::make_string(self->description);
                     },
                     std::nullopt,

package/src/prelude/values/string.hpp

@@ -19,7 +19,7 @@ namespace jspp
         std::string to_std_string() const;
         JsIterator<AnyValue> get_iterator();
 
-        AnyValue get_property(const std::string &key);
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue get_property(uint32_t idx);
     };
 }

package/src/prelude/values/symbol.hpp

@@ -97,6 +97,6 @@ namespace jspp
 
         // --- Methods ---
         std::string to_std_string() const;
-        AnyValue get_property(const std::string &key);
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
     };
 }

package/src/prelude/access.hpp

@@ -1,91 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "well_known_symbols.hpp"
-#include "values/function.hpp"
-#include "values/symbol.hpp"
-#include "error.hpp"
-#include "any_value.hpp"
-#include <ranges>
-
-namespace jspp
-{
-    namespace Access
-    {
-        // Helper function to check for TDZ and deref variables
-        inline const AnyValue &deref(const std::shared_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-        inline AnyValue &deref(std::shared_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-        inline const AnyValue &deref(const std::unique_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-        inline AnyValue &deref(std::unique_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-
-        inline std::vector<std::string> get_object_keys(const AnyValue &obj)
-        {
-            std::vector<std::string> keys;
-
-            if (obj.is_object())
-            {
-                auto ptr = obj.as_object();
-                for (const auto &pair : ptr->props)
-                {
-                    if (!JsSymbol::is_internal_key(pair.first))
-                        keys.push_back(pair.first);
-                }
-            }
-            if (obj.is_function())
-            {
-                auto ptr = obj.as_function();
-                for (const auto &pair : ptr->props)
-                {
-                    if (!JsSymbol::is_internal_key(pair.first))
-                        keys.push_back(pair.first);
-                }
-            }
-            if (obj.is_array())
-            {
-                auto len = obj.as_array()->length;
-                for (auto i = 0; i < len; ++i)
-                {
-                    keys.push_back(std::to_string(i));
-                }
-            }
-            if (obj.is_string())
-            {
-                auto len = obj.as_string()->value.length();
-                for (auto i = 0; i < len; ++i)
-                {
-                    keys.push_back(std::to_string(i));
-                }
-            }
-
-            return keys;
-        }
-    }
-}

package/src/prelude/error.hpp

@@ -1,31 +0,0 @@
-
-#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

@@ -1,59 +0,0 @@
-#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->key, 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->key));
-    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/log_string.hpp

@@ -1,407 +0,0 @@
-#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 BLUE = "\033[94m";
-            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_symbol())
-                return Color::BLUE + val.to_std_string() + Color::RESET;
-            if (val.is_string())
-            {
-                const std::string &s = val.as_string()->value;
-                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 type_part = fn->is_generator ? "GeneratorFunction" : "Function";
-                auto name_part = fn->name.size() > 0 ? ": " + fn->name : "";
-                return Color::CYAN + "[" + type_part + 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->key);
-                if (itToString != obj->props.end() && itToString->second.is_function())
-                {
-                    try
-                    {
-                        auto result = itToString->second.as_function()->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->key);
-                if (depth > 0 && itToString != arr->props.end() && itToString->second.is_function())
-                {
-                    try
-                    {
-                        auto result = itToString->second.as_function()->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();
-        }
-    }
-}