@ugo-studio/jspp 0.1.3 → 0.1.5

package/src/prelude/utils/access.hpp

@@ -0,0 +1,345 @@
+#pragma once
+
+#include "types.hpp"
+#include "well_known_symbols.hpp"
+#include "values/function.hpp"
+#include "values/symbol.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+#include <ranges>
+
+namespace jspp
+{
+    namespace Access
+    {
+        // Helper function to check for TDZ and deref heap-allocated variables
+        inline const AnyValue &deref_ptr(const std::shared_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline AnyValue &deref_ptr(std::shared_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline const AnyValue &deref_ptr(const std::unique_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline AnyValue &deref_ptr(std::unique_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+
+        // Helper function to check for TDZ on stack-allocated variables
+        inline const AnyValue &deref_stack(const AnyValue &var, const std::string &name)
+        {
+            if (var.is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return var;
+        }
+        inline AnyValue &deref_stack(AnyValue &var, const std::string &name)
+        {
+            if (var.is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return var;
+        }
+
+        inline const AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
+        {
+            if (!val.has_value())
+                return AnyValue::make_string("undefined");
+
+            switch (val.value().get_type())
+            {
+            case JsType::Undefined:
+                return AnyValue::make_string("undefined");
+            case JsType::Null:
+                return AnyValue::make_string("object");
+            case JsType::Boolean:
+                return AnyValue::make_string("boolean");
+            case JsType::Number:
+                return AnyValue::make_string("number");
+            case JsType::String:
+                return AnyValue::make_string("string");
+            case JsType::Symbol:
+                return AnyValue::make_string("symbol");
+            case JsType::Function:
+                return AnyValue::make_string("function");
+            case JsType::Object:
+                return AnyValue::make_string("object");
+            case JsType::Array:
+                return AnyValue::make_string("object");
+            case JsType::Iterator:
+                return AnyValue::make_string("object");
+            default:
+                return AnyValue::make_string("undefined");
+            }
+        }
+
+        // Helper function to get enumerable own property keys/values of an object
+        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();
+                // Use shape's property_names for stable iteration order
+                for (const auto &key : ptr->shape->property_names)
+                {
+                    if (ptr->deleted_keys.count(key))
+                        continue;
+
+                    if (JsSymbol::is_internal_key(key))
+                        continue;
+
+                    auto offset_opt = ptr->shape->get_offset(key);
+                    if (!offset_opt.has_value())
+                        continue;
+
+                    const auto &val = ptr->storage[offset_opt.value()];
+
+                    if (val.is_data_descriptor())
+                    {
+                        if (val.as_data_descriptor()->enumerable)
+                            keys.push_back(key);
+                    }
+                    else if (val.is_accessor_descriptor())
+                    {
+                        if (val.as_accessor_descriptor()->enumerable)
+                            keys.push_back(key);
+                    }
+                    else
+                    {
+                        keys.push_back(key);
+                    }
+                }
+            }
+            if (obj.is_function())
+            {
+                auto ptr = obj.as_function();
+                for (const auto &pair : ptr->props)
+                {
+                    if (!JsSymbol::is_internal_key(pair.first))
+                    {
+                        if (!pair.second.is_data_descriptor() && !pair.second.is_accessor_descriptor())
+                            keys.push_back(pair.first);
+                        else if ((pair.second.is_data_descriptor() && pair.second.as_data_descriptor()->enumerable) ||
+                                 (pair.second.is_accessor_descriptor() && pair.second.as_accessor_descriptor()->enumerable))
+                            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;
+        }
+        inline AnyValue get_object_value_iterator(const AnyValue &obj, const std::string &name)
+        {
+            if (obj.is_iterator())
+            {
+                return obj;
+            }
+
+            auto gen_fn = obj.get_own_property(WellKnownSymbols::iterator->key);
+            if (gen_fn.is_function())
+            {
+                auto iter = gen_fn.call(obj, {}, WellKnownSymbols::iterator->key);
+                if (iter.is_iterator())
+                {
+                    return iter;
+                }
+                if (iter.is_object())
+                {
+                    auto next_fn = iter.get_own_property("next");
+                    if (next_fn.is_function())
+                    {
+                        return iter;
+                    }
+                }
+            }
+
+            throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
+        }
+
+        inline AnyValue in(const AnyValue &lhs, const AnyValue &rhs)
+        {
+            if (!rhs.is_object() && !rhs.is_array() && !rhs.is_function() && !rhs.is_promise() && !rhs.is_iterator())
+            {
+                throw jspp::Exception::make_exception("Cannot use 'in' operator to search for '" + lhs.to_std_string() + "' in " + rhs.to_std_string(), "TypeError");
+            }
+            return AnyValue::make_boolean(rhs.has_property(lhs.to_std_string()));
+        }
+
+        inline AnyValue instance_of(const AnyValue &lhs, const AnyValue &rhs)
+        {
+            if (!rhs.is_function())
+            {
+                throw jspp::Exception::make_exception("Right-hand side of 'instanceof' is not callable", "TypeError");
+            }
+            if (!lhs.is_object() && !lhs.is_array() && !lhs.is_function() && !lhs.is_promise() && !lhs.is_iterator())
+            {
+                return Constants::FALSE;
+            }
+            AnyValue targetProto = rhs.get_own_property("prototype");
+            if (!targetProto.is_object() && !targetProto.is_array() && !targetProto.is_function())
+            {
+                throw jspp::Exception::make_exception("Function has non-object prototype in instanceof check", "TypeError");
+            }
+            // Walk prototype chain of lhs
+            AnyValue current = lhs;
+
+            while (true)
+            {
+                AnyValue proto;
+                if (current.is_object())
+                {
+                    auto p = current.as_object()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_array())
+                {
+                    auto p = current.as_array()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_function())
+                {
+                    auto p = current.as_function()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_promise())
+                {
+                    // Promises don't store explicit proto yet in our impl
+                    break;
+                }
+                else
+                {
+                    break;
+                }
+                if (proto.is_null() || proto.is_undefined())
+                    break;
+                if (is_strictly_equal_to_primitive(proto, targetProto))
+                    return Constants::TRUE;
+                current = proto;
+            }
+            return Constants::FALSE;
+        }
+
+        inline AnyValue delete_property(const AnyValue &obj, const AnyValue &key)
+        {
+            if (obj.is_object())
+            {
+                auto ptr = obj.as_object();
+                std::string key_str = key.to_std_string();
+                if (ptr->shape->get_offset(key_str).has_value())
+                {
+                    ptr->deleted_keys.insert(key_str);
+                }
+                return Constants::TRUE;
+            }
+            if (obj.is_array())
+            {
+                auto ptr = obj.as_array();
+                std::string key_str = key.to_std_string();
+                if (JsArray::is_array_index(key_str))
+                {
+                    uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+                    if (idx < ptr->dense.size())
+                    {
+                        ptr->dense[idx] = Constants::UNINITIALIZED;
+                    }
+                    else
+                    {
+                        ptr->sparse.erase(idx);
+                    }
+                }
+                else
+                {
+                    ptr->props.erase(key_str);
+                }
+                return Constants::TRUE;
+            }
+            if (obj.is_function())
+            {
+                auto ptr = obj.as_function();
+                ptr->props.erase(key.to_std_string());
+                return Constants::TRUE;
+            }
+            return Constants::TRUE;
+        }
+
+        inline AnyValue optional_get_property(const AnyValue &obj, const std::string &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key);
+        }
+
+        inline AnyValue optional_get_element(const AnyValue &obj, const AnyValue &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key);
+        }
+
+        inline AnyValue optional_get_element(const AnyValue &obj, const double &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(static_cast<uint32_t>(key));
+        }
+
+        inline AnyValue optional_call(const AnyValue &fn, const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt)
+        {
+            if (fn.is_null() || fn.is_undefined())
+                return Constants::UNDEFINED;
+            return fn.call(thisVal, args, name);
+        }
+
+    }
+
+}

package/src/prelude/utils/assignment_operators.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp {
+
+    // --- FRIEND IMPLEMENTATIONS ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs + rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs - rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs * rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs / rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs % rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator++(AnyValue &val) {
+        val = val + 1.0;
+        return val;
+    }
+
+    inline AnyValue operator++(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = val + 1.0;
+        return temp;
+    }
+
+    inline AnyValue &operator--(AnyValue &val) {
+        val = val - 1.0;
+        return val;
+    }
+
+    inline AnyValue operator--(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = val - 1.0;
+        return temp;
+    }
+
+    // --- OVERLOADS FOR PRIMITIVES ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs + rhs;
+        return lhs;
+    }
+    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
+        return lhs += static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs - rhs;
+        return lhs;
+    }
+    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
+        return lhs -= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs * rhs;
+        return lhs;
+    }
+    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
+        return lhs *= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs / rhs;
+        return lhs;
+    }
+    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
+        return lhs /= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs % rhs;
+        return lhs;
+    }
+    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {
+        return lhs %= static_cast<double>(rhs);
+    }
+}

package/src/prelude/utils/log_any_value/array.hpp

@@ -0,0 +1,245 @@
+#pragma once
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include "utils/log_any_value/helpers.hpp"
+#include "utils/log_any_value/fwd.hpp"
+#include <string>
+#include <sstream>
+#include <unordered_set>
+#include <algorithm>
+#include <optional>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::string format_array(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
+        {
+            auto arr = val.as_array();
+            size_t item_count = static_cast<size_t>(arr->length);
+            size_t prop_count = arr->props.size();
+
+            // // If custom toString exists on the object, prefer it
+            // auto itToString = arr->props.find("toString");
+            // if (depth > 0 && itToString != arr->props.end() && itToString->second.is_function())
+            // {
+            //     try
+            //     {
+            //         auto result = itToString->second.as_function()->call(itToString->second, {});
+            //         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)
+                {
+                    AnyValue itemVal = AnyValue::make_uninitialized();
+                    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.is_uninitialized() && !is_simple_value(itemVal))
+                    {
+                        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)
+                {
+                    AnyValue itemVal = AnyValue::make_uninitialized();
+                    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.is_uninitialized())
+                    {
+                        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, 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;
+                }
+
+                // Print properties
+                if (prop_count > 0)
+                {
+                    ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+
+                    size_t current_prop = 0;
+                    for (const auto &pair : arr->props)
+                    {
+                        if (!is_enumerable_property(pair.second))
+                            continue;
+
+                        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 << " ]";
+                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)
+            {
+                AnyValue itemVal = AnyValue::make_uninitialized();
+                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.is_uninitialized())
+                {
+                    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, 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;
+            }
+            // Print properties
+            else if (prop_count > 0)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+
+                size_t current_prop = 0;
+                for (const auto &pair : arr->props)
+                {
+                    if (current_prop >= MAX_OBJECT_PROPS)
+                        break;
+                    if (!is_enumerable_property(pair.second))
+                        continue;
+
+                    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);
+                    if (++current_prop < prop_count)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                }
+            }
+            ss << "\n";
+            ss << indent << "]";
+            return ss.str();
+        }
+    }
+}