@ugo-studio/jspp 0.2.9 → 0.3.1

package/src/prelude/values/symbol.hpp

@@ -1,101 +1,101 @@
-#pragma once
-
-#include "types.hpp"
-#include <atomic>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <optional>
-
-namespace jspp
-{
-    // Forward declaration of AnyValue
-    class AnyValue;
-
-    struct JsSymbol : HeapObject
-    {
-        std::string description;
-        std::string key; // Internal unique key used for AnyValue property maps
-
-        JsType get_heap_type() const override { return JsType::Symbol; }
-
-        // --- Registries ---
-
-        // 1. Global Symbol Registry (for Symbol.for/keyFor)
-        static std::unordered_map<std::string, JsSymbol*> &registry()
-        {
-            static std::unordered_map<std::string, JsSymbol*> reg;
-            return reg;
-        }
-
-        // 2. All Internal Keys Registry (for robust Object.keys filtering)
-        static std::unordered_set<std::string> &internal_keys_registry()
-        {
-            static std::unordered_set<std::string> keys;
-            return keys;
-        }
-
-        static bool is_internal_key(const std::string &k)
-        {
-            return internal_keys_registry().count(k) > 0;
-        }
-
-        // --- Constructors ---
-
-        // Standard Constructor (creates unique symbol)
-        JsSymbol(const std::string &desc) : description(desc)
-        {
-            static std::atomic<uint64_t> id_counter{0};
-            // Ensure unique internal key for property storage
-            key = "__Sym" + std::to_string(id_counter++) + "_" + desc;
-
-            // Register this key as a valid symbol key
-            internal_keys_registry().insert(key);
-        }
-
-        // Constructor for Well-Known Symbols (fixed keys)
-        JsSymbol(const std::string &desc, const std::string &fixed_key)
-            : description(desc), key(fixed_key)
-        {
-            // Register this key as a valid symbol key
-            internal_keys_registry().insert(key);
-        }
-
-        // --- Global Registry API ---
-
-        // Implements Symbol.for(key)
-        static JsSymbol* for_global(const std::string &registryKey)
-        {
-            auto &reg = registry();
-            auto it = reg.find(registryKey);
-            if (it != reg.end())
-            {
-                return it->second;
-            }
-
-            // Create new symbol with description = registryKey
-            auto newSym = new JsSymbol(registryKey);
-            newSym->ref(); // Keep it alive in registry
-            reg[registryKey] = newSym;
-            return newSym;
-        }
-
-        // Implements Symbol.keyFor(sym)
-        static std::optional<std::string> key_for(const JsSymbol *sym)
-        {
-            auto &reg = registry();
-            for (const auto &pair : reg)
-            {
-                if (pair.second == sym)
-                {
-                    return pair.first;
-                }
-            }
-            return std::nullopt;
-        }
-
-        // --- Methods ---
-        std::string to_std_string() const;
-        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
-    };
-}
+#pragma once
+
+#include "types.hpp"
+#include <atomic>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <optional>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    struct JsSymbol : HeapObject
+    {
+        std::string description;
+        std::string key; // Internal unique key used for AnyValue property maps
+
+        JsType get_heap_type() const override { return JsType::Symbol; }
+
+        // --- Registries ---
+
+        // 1. Global Symbol Registry (for Symbol.for/keyFor)
+        static std::unordered_map<std::string, JsSymbol*> &registry()
+        {
+            static std::unordered_map<std::string, JsSymbol*> reg;
+            return reg;
+        }
+
+        // 2. All Internal Keys Registry (for robust Object.keys filtering)
+        static std::unordered_set<std::string> &internal_keys_registry()
+        {
+            static std::unordered_set<std::string> keys;
+            return keys;
+        }
+
+        static bool is_internal_key(const std::string &k)
+        {
+            return internal_keys_registry().count(k) > 0;
+        }
+
+        // --- Constructors ---
+
+        // Standard Constructor (creates unique symbol)
+        JsSymbol(const std::string &desc) : description(desc)
+        {
+            static std::atomic<uint64_t> id_counter{0};
+            // Ensure unique internal key for property storage
+            key = "__Sym" + std::to_string(id_counter++) + "_" + desc;
+
+            // Register this key as a valid symbol key
+            internal_keys_registry().insert(key);
+        }
+
+        // Constructor for Well-Known Symbols (fixed keys)
+        JsSymbol(const std::string &desc, const std::string &fixed_key)
+            : description(desc), key(fixed_key)
+        {
+            // Register this key as a valid symbol key
+            internal_keys_registry().insert(key);
+        }
+
+        // --- Global Registry API ---
+
+        // Implements Symbol.for(key)
+        static JsSymbol* for_global(const std::string &registryKey)
+        {
+            auto &reg = registry();
+            auto it = reg.find(registryKey);
+            if (it != reg.end())
+            {
+                return it->second;
+            }
+
+            // Create new symbol with description = registryKey
+            auto newSym = new JsSymbol(registryKey);
+            newSym->ref(); // Keep it alive in registry
+            reg[registryKey] = newSym;
+            return newSym;
+        }
+
+        // Implements Symbol.keyFor(sym)
+        static std::optional<std::string> key_for(const JsSymbol *sym)
+        {
+            auto &reg = registry();
+            for (const auto &pair : reg)
+            {
+                if (pair.second == sym)
+                {
+                    return pair.first;
+                }
+            }
+            return std::nullopt;
+        }
+
+        // --- Methods ---
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+    };
+}

package/src/prelude/any_value_access.hpp

@@ -1,170 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-
-namespace jspp
-{
-    inline AnyValue AnyValue::get_own_property(const std::string &key) const
-    {
-        return get_property_with_receiver(key, *this);
-    }
-    inline bool AnyValue::has_property(const std::string &key) const
-    {
-        switch (get_type())
-        {
-        case JsType::Object:
-            return as_object()->has_property(key);
-        case JsType::Array:
-            return as_array()->has_property(key);
-        case JsType::Function:
-            return as_function()->has_property(key);
-        case JsType::Promise:
-            return false;
-        case JsType::Iterator:
-            return false;
-        case JsType::AsyncIterator:
-            return false;
-        case JsType::Symbol:
-            return SymbolPrototypes::get(key).has_value();
-        case JsType::String:
-            if (key == "length")
-                return true;
-            if (JsArray::is_array_index(key))
-            {
-                uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-                return idx < as_string()->value.length();
-            }
-            return StringPrototypes::get(key).has_value();
-        case JsType::Number:
-            return NumberPrototypes::get(key).has_value();
-        case JsType::Uninitialized:
-            Exception::throw_uninitialized_reference("#<Object>");
-            return false;
-        default:
-            return false;
-        }
-    }
-    inline AnyValue AnyValue::get_own_property(uint32_t idx) const
-    {
-        if (is_array()) return as_array()->get_property(idx);
-        if (is_string()) return as_string()->get_property(idx);
-        return get_own_property(std::to_string(idx));
-    }
-    inline AnyValue AnyValue::get_own_property(const AnyValue &key) const
-    {
-        if (key.is_number() && is_array())
-            return as_array()->get_property(key.as_double());
-        if (key.is_number() && is_string())
-            return as_string()->get_property(key.as_double());
-
-        if (key.is_symbol())
-            return get_own_property(key.as_symbol()->key);
-
-        return get_own_property(key.to_std_string());
-    }
-
-    inline AnyValue AnyValue::get_property_with_receiver(const std::string &key, AnyValue receiver) const
-    {
-        switch (get_type())
-        {
-        case JsType::Object:
-            return as_object()->get_property(key, receiver);
-        case JsType::Array:
-            return as_array()->get_property(key, receiver);
-        case JsType::Function:
-            return as_function()->get_property(key, receiver);
-        case JsType::Promise:
-            return as_promise()->get_property(key, receiver);
-        case JsType::Iterator:
-            return static_cast<JsIterator<AnyValue>*>(get_ptr())->get_property(key, receiver);
-        case JsType::AsyncIterator:
-            return static_cast<JsAsyncIterator<AnyValue>*>(get_ptr())->get_property(key, receiver);
-        case JsType::Symbol:
-            return as_symbol()->get_property(key, receiver);
-        case JsType::String:
-            return as_string()->get_property(key, receiver);
-        case JsType::Number:
-        {
-            auto proto_it = NumberPrototypes::get(key);
-            if (proto_it.has_value())
-            {
-                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
-            }
-            return Constants::UNDEFINED;
-        }
-        case JsType::Undefined:
-            throw Exception::make_exception("Cannot read properties of undefined (reading '" + key + "')", "TypeError");
-        case JsType::Null:
-            throw Exception::make_exception("Cannot read properties of null (reading '" + key + "')", "TypeError");
-        case JsType::Uninitialized:
-            Exception::throw_uninitialized_reference("#<Object>");
-        default:
-            return Constants::UNDEFINED;
-        }
-    }
-
-    inline AnyValue AnyValue::set_own_property(const std::string &key, AnyValue value) const
-    {
-        switch (get_type())
-        {
-        case JsType::Object:
-            return as_object()->set_property(key, value, *this);
-        case JsType::Array:
-            return as_array()->set_property(key, value, *this);
-        case JsType::Function:
-            return as_function()->set_property(key, value, *this);
-        case JsType::Promise:
-            return as_promise()->set_property(key, value, *this);
-        case JsType::Undefined:
-            throw Exception::make_exception("Cannot set properties of undefined (setting '" + key + "')", "TypeError");
-        case JsType::Null:
-            throw Exception::make_exception("Cannot set properties of null (setting '" + key + "')", "TypeError");
-        default:
-            return value;
-        }
-    }
-    inline AnyValue AnyValue::set_own_property(uint32_t idx, AnyValue value) const
-    {
-        if (is_array())
-        {
-            return as_array()->set_property(idx, value);
-        }
-        return set_own_property(std::to_string(idx), value);
-    }
-    inline AnyValue AnyValue::set_own_property(const AnyValue &key, AnyValue value) const
-    {
-        if (key.is_number() && is_array())
-        {
-            return as_array()->set_property(key.as_double(), value);
-        }
-
-        if (key.is_symbol())
-            return set_own_property(key.as_symbol()->key, value);
-
-        return set_own_property(key.to_std_string(), value);
-    }
-
-    inline AnyValue AnyValue::call_own_property(const std::string &key, std::span<const AnyValue> args) const
-    {
-        return get_own_property(key).call((*this), args, key);
-    }
-    inline AnyValue AnyValue::call_own_property(uint32_t idx, std::span<const AnyValue> args) const
-    {
-        if (is_array()) return as_array()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
-        if (is_string()) return as_string()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
-        return call_own_property(std::to_string(idx), args);
-    }
-    inline AnyValue AnyValue::call_own_property(const AnyValue &key, std::span<const AnyValue> args) const
-    {
-        if (key.is_number() && is_array())
-            return as_array()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
-        if (key.is_number() && is_string())
-            return as_string()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
-
-        if (key.is_symbol())
-            return call_own_property(key.as_symbol()->key, args);
-
-        return call_own_property(key.to_std_string(), args);
-    }
-}

package/src/prelude/any_value_defines.hpp

@@ -1,190 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "values/object.hpp"
-#include "values/function.hpp"
-
-namespace jspp
-{
-    inline void AnyValue::define_data_property(const std::string &key, AnyValue value)
-    {
-        if (is_object())
-        {
-            auto obj = as_object();
-            auto offset = obj->shape->get_offset(key);
-            if (offset.has_value())
-            {
-                obj->storage[offset.value()] = value;
-            }
-            else
-            {
-                obj->shape = obj->shape->transition(key);
-                obj->storage.push_back(value);
-            }
-        }
-        else if (is_function())
-        {
-            as_function()->props[key] = value;
-        }
-    }
-
-    inline void AnyValue::define_data_property(const AnyValue &key, AnyValue value)
-    {
-        if (key.is_symbol())
-            define_data_property(key.as_symbol()->key, value);
-        else
-            define_data_property(key.to_std_string(), value);
-    }
-
-    inline void AnyValue::define_data_property(const std::string &key, AnyValue value, bool writable, bool enumerable, bool configurable)
-    {
-        define_data_property(key, AnyValue::make_data_descriptor(value, writable, enumerable, configurable));
-    }
-
-    inline void AnyValue::define_getter(const std::string &key, AnyValue getter)
-    {
-        if (is_object())
-        {
-            auto obj = as_object();
-            auto offset = obj->shape->get_offset(key);
-
-            if (offset.has_value())
-            {
-                auto &val = obj->storage[offset.value()];
-                if (val.is_accessor_descriptor())
-                {
-                    auto desc = val.as_accessor_descriptor();
-                    desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                    {
-                        return getter.call(thisVal, args);
-                    };
-                }
-                else
-                {
-                    auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                    {
-                        return getter.call(thisVal, args);
-                    };
-                    obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
-                }
-            }
-            else
-            {
-                auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                {
-                    return getter.call(thisVal, args);
-                };
-                obj->shape = obj->shape->transition(key);
-                obj->storage.push_back(AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true));
-            }
-        }
-        else if (is_function())
-        {
-            auto &props = as_function()->props;
-            auto it = props.find(key);
-            if (it != props.end() && it->second.is_accessor_descriptor())
-            {
-                auto desc = it->second.as_accessor_descriptor();
-                desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                {
-                    return getter.call(thisVal, args);
-                };
-            }
-            else
-            {
-                auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                {
-                    return getter.call(thisVal, args);
-                };
-                props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
-            }
-        }
-    }
-
-    inline void AnyValue::define_getter(const AnyValue &key, AnyValue getter)
-    {
-        if (key.is_symbol())
-            define_getter(key.as_symbol()->key, getter);
-        else
-            define_getter(key.to_std_string(), getter);
-    }
-
-    inline void AnyValue::define_setter(const std::string &key, AnyValue setter)
-    {
-        if (is_object())
-        {
-            auto obj = as_object();
-            auto offset = obj->shape->get_offset(key);
-
-            if (offset.has_value())
-            {
-                auto &val = obj->storage[offset.value()];
-                if (val.is_accessor_descriptor())
-                {
-                    auto desc = val.as_accessor_descriptor();
-                    desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                    {
-                        if (args.empty())
-                            return Constants::UNDEFINED;
-                        return setter.call(thisVal, args);
-                    };
-                }
-                else
-                {
-                    auto setFunc = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                    {
-                        if (args.empty())
-                            return Constants::UNDEFINED;
-                        return setter.call(thisVal, args);
-                    };
-                    obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
-                }
-            }
-            else
-            {
-                auto setFunc = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                {
-                    if (args.empty())
-                        return Constants::UNDEFINED;
-                    return setter.call(thisVal, args);
-                };
-                obj->shape = obj->shape->transition(key);
-                obj->storage.push_back(AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true));
-            }
-        }
-        else if (is_function())
-        {
-            auto &props = as_function()->props;
-            auto it = props.find(key);
-            if (it != props.end() && it->second.is_accessor_descriptor())
-            {
-                auto desc = it->second.as_accessor_descriptor();
-                desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                {
-                    if (args.empty())
-                        return Constants::UNDEFINED;
-                    return setter.call(thisVal, args);
-                };
-            }
-            else
-            {
-                auto setFunc = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
-                {
-                    if (args.empty())
-                        return Constants::UNDEFINED;
-                    return setter.call(thisVal, args);
-                };
-                props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
-            }
-        }
-    }
-
-    inline void AnyValue::define_setter(const AnyValue &key, AnyValue setter)
-    {
-        if (key.is_symbol())
-            define_setter(key.as_symbol()->key, setter);
-        else
-            define_setter(key.to_std_string(), setter);
-    }
-}