@ugo-studio/jspp 0.1.3 → 0.1.4

package/src/prelude/any_value_access.hpp

@@ -0,0 +1,103 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+jspp::AnyValue jspp::AnyValue::get_own_property(const std::string &key) const
+{
+    return get_property_with_receiver(key, *this);
+}
+jspp::AnyValue jspp::AnyValue::get_own_property(uint32_t idx) const noexcept
+{
+    switch (storage.type)
+    {
+    case JsType::Array:
+        return storage.array->get_property(idx);
+    case JsType::String:
+        return storage.str->get_property(idx);
+    default:
+        return get_own_property(std::to_string(idx));
+    }
+}
+jspp::AnyValue jspp::AnyValue::get_own_property(const AnyValue &key) const noexcept
+{
+    if (key.storage.type == JsType::Number && storage.type == JsType::Array)
+        return storage.array->get_property(key.storage.number);
+    if (key.storage.type == JsType::Number && storage.type == JsType::String)
+        return storage.str->get_property(key.storage.number);
+
+    // If the key is a Symbol, use its internal key string
+    if (key.storage.type == JsType::Symbol)
+        return get_own_property(key.storage.symbol->key);
+
+    return get_own_property(key.to_std_string());
+}
+
+jspp::AnyValue jspp::AnyValue::get_property_with_receiver(const std::string &key, const AnyValue &receiver) const
+{
+    switch (storage.type)
+    {
+    case JsType::Object:
+        return storage.object->get_property(key, receiver);
+    case JsType::Array:
+        return storage.array->get_property(key, receiver);
+    case JsType::Function:
+        return storage.function->get_property(key, receiver);
+    case JsType::Promise:
+        return storage.promise->get_property(key, receiver);
+    case JsType::Iterator:
+        return storage.iterator->get_property(key, receiver);
+    case JsType::Symbol:
+        return storage.symbol->get_property(key, receiver);
+    case JsType::String:
+        return storage.str->get_property(key, receiver);
+    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");
+    default:
+        return AnyValue::make_undefined();
+    }
+}
+
+jspp::AnyValue jspp::AnyValue::set_own_property(const std::string &key, const AnyValue &value) const
+{
+    switch (storage.type)
+    {
+    case JsType::Object:
+        return storage.object->set_property(key, value, *this);
+    case JsType::Array:
+        return storage.array->set_property(key, value, *this);
+    case JsType::Function:
+        return storage.function->set_property(key, value, *this);
+    case JsType::Promise:
+        return storage.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;
+    }
+}
+jspp::AnyValue jspp::AnyValue::set_own_property(uint32_t idx, const AnyValue &value) const
+{
+    if (storage.type == JsType::Array)
+    {
+        return storage.array->set_property(idx, value);
+    }
+    return set_own_property(std::to_string(idx), value);
+}
+jspp::AnyValue jspp::AnyValue::set_own_property(const AnyValue &key, const AnyValue &value) const
+{
+    if (key.storage.type == JsType::Number && storage.type == JsType::Array)
+    {
+        return storage.array->set_property(key.storage.number, value);
+    }
+
+    // If the key is a Symbol, use its internal key string
+    if (key.storage.type == JsType::Symbol)
+        return set_own_property(key.storage.symbol->key, value);
+
+    return set_own_property(key.to_std_string(), value);
+}

package/src/prelude/any_value_defines.hpp

@@ -0,0 +1,151 @@
+#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, const AnyValue &value)
+    {
+        if (is_object())
+        {
+            storage.object->props[key] = value;
+        }
+        else if (is_function())
+        {
+            storage.function->props[key] = value;
+        }
+    }
+
+    inline void AnyValue::define_data_property(const AnyValue &key, const 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, const 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, const AnyValue &getter)
+    {
+        if (is_object())
+        {
+            auto &props = storage.object->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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    return getter.as_function()->call(thisVal, args);
+                };
+            }
+            else
+            {
+                auto getFunc = [getter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    return getter.as_function()->call(thisVal, args);
+                };
+                props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+            }
+        }
+        else if (is_function())
+        {
+            auto &props = storage.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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    return getter.as_function()->call(thisVal, args);
+                };
+            }
+            else
+            {
+                auto getFunc = [getter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    return getter.as_function()->call(thisVal, args);
+                };
+                props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+            }
+        }
+    }
+
+    inline void AnyValue::define_getter(const AnyValue &key, const 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, const AnyValue &setter)
+    {
+        if (is_object())
+        {
+            auto &props = storage.object->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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    if (args.empty())
+                        return AnyValue::make_undefined();
+                    return setter.as_function()->call(thisVal, args);
+                };
+            }
+            else
+            {
+                auto setFunc = [setter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    if (args.empty())
+                        return AnyValue::make_undefined();
+                    return setter.as_function()->call(thisVal, args);
+                };
+                props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+            }
+        }
+        else if (is_function())
+        {
+            auto &props = storage.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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    if (args.empty())
+                        return AnyValue::make_undefined();
+                    return setter.as_function()->call(thisVal, args);
+                };
+            }
+            else
+            {
+                auto setFunc = [setter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    if (args.empty())
+                        return AnyValue::make_undefined();
+                    return setter.as_function()->call(thisVal, args);
+                };
+                props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+            }
+        }
+    }
+
+    inline void AnyValue::define_setter(const AnyValue &key, const AnyValue &setter)
+    {
+        if (key.is_symbol())
+            define_setter(key.as_symbol()->key, setter);
+        else
+            define_setter(key.to_std_string(), setter);
+    }
+}