@ugo-studio/jspp 0.1.2 → 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);
+    }
+}

package/src/prelude/any_value_helpers.hpp

@@ -0,0 +1,246 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "values/string.hpp"
+
+namespace jspp
+{
+    const bool AnyValue::is_truthy() const noexcept
+    {
+        switch (storage.type)
+        {
+        case JsType::Boolean:
+            return storage.boolean;
+        case JsType::Number:
+            return storage.number != 0.0;
+        case JsType::String:
+            return !storage.str->value.empty();
+        case JsType::Undefined:
+            return false;
+        case JsType::Null:
+            return false;
+        case JsType::Uninitialized:
+            return false;
+        default:
+            return true;
+        }
+    }
+
+    const bool AnyValue::is_strictly_equal_to_primitive(const AnyValue &other) const noexcept
+    {
+        if (storage.type == other.storage.type)
+        {
+            switch (storage.type)
+            {
+            case JsType::Boolean:
+                return storage.boolean == other.storage.boolean;
+            case JsType::Number:
+                return storage.number == other.storage.number;
+            case JsType::String:
+                return (storage.str->value == other.storage.str->value);
+            case JsType::Array:
+                return (storage.array == other.storage.array);
+            case JsType::Object:
+                return (storage.object == other.storage.object);
+            case JsType::Function:
+                return (storage.function == other.storage.function);
+            case JsType::Iterator:
+                return (storage.iterator == other.storage.iterator);
+            case JsType::Promise:
+                return (storage.promise == other.storage.promise);
+            case JsType::Symbol:
+                // Symbols are unique by reference/pointer identity
+                return (storage.symbol == other.storage.symbol);
+            case JsType::DataDescriptor:
+                return storage.data_desc == other.storage.data_desc;
+            case JsType::AccessorDescriptor:
+                return storage.accessor_desc == other.storage.accessor_desc;
+            default:
+                return true;
+            }
+        }
+        return false;
+    }
+    const bool AnyValue::is_equal_to_primitive(const AnyValue &other) const noexcept
+    {
+        // Implements JavaScript's Abstract Equality Comparison Algorithm (==)
+        // Step 1: If types are the same, use strict equality (===)
+        if (storage.type == other.storage.type)
+        {
+            return is_strictly_equal_to_primitive(other);
+        }
+        // Steps 2 & 3: null == undefined
+        if ((is_null() && other.is_undefined()) || (is_undefined() && other.is_null()))
+        {
+            return true;
+        }
+        // Step 4 & 5: number == string
+        if (is_number() && other.is_string())
+        {
+            double num_this = this->as_double();
+            double num_other;
+            try
+            {
+                const std::string &s = other.as_string()->value;
+                // JS considers empty string or whitespace-only string to be 0
+                if (s.empty() || std::all_of(s.begin(), s.end(), [](unsigned char c)
+                                             { return std::isspace(c); }))
+                {
+                    num_other = 0.0;
+                }
+                else
+                {
+                    size_t pos;
+                    num_other = std::stod(s, &pos);
+                    // Check if the entire string was consumed, allowing for trailing whitespace
+                    while (pos < s.length() && std::isspace(static_cast<unsigned char>(s[pos])))
+                    {
+                        pos++;
+                    }
+                    if (pos != s.length())
+                    {
+                        num_other = std::numeric_limits<double>::quiet_NaN();
+                    }
+                }
+            }
+            catch (...)
+            {
+                num_other = std::numeric_limits<double>::quiet_NaN();
+            }
+            return num_this == num_other;
+        }
+        if (is_string() && other.is_number())
+        {
+            // Delegate to the other operand to avoid code duplication
+            return other.is_equal_to_primitive(*this);
+        }
+        // Step 6 & 7: boolean == any
+        if (is_boolean())
+        {
+            // Convert boolean to number and re-compare
+            return AnyValue::make_number(as_boolean() ? 1.0 : 0.0).is_equal_to_primitive(other);
+        }
+        if (other.is_boolean())
+        {
+            // Convert boolean to number and re-compare
+            return is_equal_to_primitive(AnyValue::make_number(other.as_boolean() ? 1.0 : 0.0));
+        }
+        // Step 8 & 9: object == (string or number or symbol)
+        // Simplified: Objects convert to primitives.
+        if ((is_object() || is_array() || is_function() || is_promise() || is_iterator()) && (other.is_string() || other.is_number() || other.is_symbol()))
+        {
+            // Convert object to primitive (string) and re-compare.
+            // This is a simplification of JS's ToPrimitive.
+            return AnyValue::make_string(to_std_string()).is_equal_to_primitive(other);
+        }
+        if ((other.is_object() || other.is_array() || other.is_function() || other.is_promise() || other.is_iterator()) && (is_string() || is_number() || is_symbol()))
+        {
+            return other.is_equal_to_primitive(*this);
+        }
+        // Step 10: Datacriptor or accessor descriptor
+        if (is_data_descriptor() || is_accessor_descriptor())
+        {
+            return (*this).is_strictly_equal_to_primitive(other);
+        }
+        // Step 11: All other cases (e.g., object == null) are false.
+        return false;
+    }
+
+    const AnyValue AnyValue::is_strictly_equal_to(const AnyValue &other) const noexcept
+    {
+        return AnyValue::make_boolean(is_strictly_equal_to_primitive(other));
+    }
+    const AnyValue AnyValue::is_equal_to(const AnyValue &other) const noexcept
+    {
+        return AnyValue::make_boolean(is_equal_to_primitive(other));
+    }
+
+    const AnyValue AnyValue::not_strictly_equal_to(const AnyValue &other) const noexcept
+    {
+        return AnyValue::make_boolean(!is_strictly_equal_to_primitive(other));
+    }
+    const AnyValue AnyValue::not_equal_to(const AnyValue &other) const noexcept
+    {
+        return AnyValue::make_boolean(!is_equal_to_primitive(other));
+    }
+
+    const std::string AnyValue::to_std_string() const noexcept
+    {
+        switch (storage.type)
+        {
+        case JsType::Undefined:
+            return "undefined";
+        case JsType::Null:
+            return "null";
+        case JsType::Boolean:
+            return storage.boolean ? "true" : "false";
+        case JsType::String:
+            return storage.str->to_std_string();
+        case JsType::Object:
+            return storage.object->to_std_string();
+        case JsType::Array:
+            return storage.array->to_std_string();
+        case JsType::Function:
+            return storage.function->to_std_string();
+        case JsType::Iterator:
+            return storage.iterator->to_std_string();
+        case JsType::Promise:
+            return storage.promise->to_std_string();
+        case JsType::Symbol:
+            return storage.symbol->to_std_string();
+        case JsType::DataDescriptor:
+            return storage.data_desc->value->to_std_string();
+        case JsType::AccessorDescriptor:
+        {
+            if (storage.accessor_desc->get.has_value())
+                return storage.accessor_desc->get.value()(*this, {}).to_std_string();
+            else
+                return "undefined";
+        }
+        case JsType::Number:
+        {
+            if (std::isnan(storage.number))
+            {
+                return "NaN";
+            }
+            if (std::abs(storage.number) >= 1e21 || (std::abs(storage.number) > 0 && std::abs(storage.number) < 1e-6))
+            {
+                std::ostringstream oss;
+                oss << std::scientific << std::setprecision(4) << storage.number;
+                return oss.str();
+            }
+            else
+            {
+                std::ostringstream oss;
+                oss << std::setprecision(6) << std::fixed << storage.number;
+                std::string s = oss.str();
+                s.erase(s.find_last_not_of('0') + 1, std::string::npos);
+                if (!s.empty() && s.back() == '.')
+                {
+                    s.pop_back();
+                }
+                return s;
+            }
+        }
+        // Uninitialized and default should not be reached under normal circumstances
+        case JsType::Uninitialized:
+            return "<uninitialized>";
+        default:
+            return "";
+        }
+    }
+
+    void AnyValue::set_prototype(const AnyValue &proto)
+    {
+        if (is_object())
+        {
+            storage.object->proto = std::make_shared<AnyValue>(proto);
+        }
+        else if (is_function())
+        {
+            storage.function->proto = std::make_shared<AnyValue>(proto);
+        }
+    }
+
+}

package/src/prelude/exception.hpp

@@ -0,0 +1,31 @@
+
+#pragma once
+
+#include "types.hpp"
+
+namespace jspp
+{
+    class AnyValue;
+
+    struct Exception : std::exception
+    {
+        std::shared_ptr<AnyValue> data;
+
+        explicit Exception(std::shared_ptr<AnyValue> d)
+            : data(std::move(d)) {}
+        explicit Exception(const AnyValue &value)
+            : data(std::make_shared<AnyValue>(value)) {}
+        explicit Exception(AnyValue &&value)
+            : data(std::make_shared<AnyValue>(std::move(value))) {}
+
+        const char *what() const noexcept override;
+        static Exception make_exception(const std::string &message, const std::string &name);
+        static AnyValue exception_to_any_value(const std::exception &ex);
+
+        // --- THROWERS
+        static AnyValue throw_unresolved_reference(const std::string &var_name);
+        static AnyValue throw_uninitialized_reference(const std::string &var_name);
+        static AnyValue throw_immutable_assignment();
+        static AnyValue throw_invalid_return_statement();
+    };
+}

package/src/prelude/exception_helpers.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "types.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+
+const char *jspp::Exception::what() const noexcept
+{
+    return data->to_std_string().c_str();
+}
+
+jspp::Exception jspp::Exception::make_exception(const std::string &message, const std::string &name = "Error")
+{
+    // Use the global Error object to construct the exception
+    std::vector<AnyValue> args = { AnyValue::make_string(message) };
+    AnyValue errorObj = ::Error.construct(args);
+    errorObj.define_data_property("name", AnyValue::make_string(name));
+    
+    return Exception(errorObj);
+}
+jspp::AnyValue jspp::Exception::exception_to_any_value(const std::exception &ex)
+{
+    if (const jspp::Exception *err = dynamic_cast<const jspp::Exception *>(&ex))
+    {
+        return (*err->data);
+    }
+    else
+    {
+        return AnyValue::make_string(ex.what());
+    }
+}
+
+// --- THROWERS
+jspp::AnyValue jspp::Exception::throw_unresolved_reference(const std::string &var_name)
+{
+    throw Exception::make_exception(var_name + " is not defined", "ReferenceError");
+}
+jspp::AnyValue jspp::Exception::throw_uninitialized_reference(const std::string &var_name)
+{
+    throw Exception::make_exception("Cannot access '" + var_name + "' before initialization", "ReferenceError");
+}
+jspp::AnyValue jspp::Exception::throw_immutable_assignment()
+{
+    throw Exception::make_exception("Assignment to constant variable.", "TypeError");
+}
+jspp::AnyValue jspp::Exception::throw_invalid_return_statement()
+{
+    throw Exception::make_exception("Return statements are only valid inside functions.", "SyntaxError");
+}

package/src/prelude/index.hpp

@@ -1,29 +1,52 @@
 #pragma once
 
 #include "types.hpp"
-#include "well_known_symbols.hpp"
+#include "utils/well_known_symbols.hpp"
 
 // values
+#include "values/symbol.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #include "values/array.hpp"
 #include "values/function.hpp"
-#include "error.hpp"
-#include "descriptors.hpp"
+#include "values/iterator.hpp"
+#include "values/promise.hpp"
+#include "values/string.hpp"
+
+#include "exception.hpp"
+#include "values/descriptors.hpp"
 #include "any_value.hpp"
-#include "error_helpers.hpp"
-#include "values/prototypes/string.hpp"
+#include "any_value_helpers.hpp"
+#include "any_value_access.hpp"
+#include "any_value_defines.hpp"
+#include "library/error.hpp"
+#include "exception_helpers.hpp"
+#include "scheduler.hpp"
+
+#include "values/prototypes/symbol.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"
+#include "values/prototypes/iterator.hpp"
+#include "values/prototypes/promise.hpp"
+#include "values/prototypes/string.hpp"
+
+#include "values/helpers/symbol.hpp"
+#include "values/helpers/object.hpp"
+#include "values/helpers/array.hpp"
+#include "values/helpers/function.hpp"
+#include "values/helpers/iterator.hpp"
+#include "values/helpers/promise.hpp"
+#include "values/helpers/string.hpp"
 
-// helpers
-#include "operators.hpp"
-#include "access.hpp"
-#include "log_string.hpp"
+// utilities
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+#include "utils/log_any_value/log_any_value.hpp"
 
 // js standard libraries
+#include "library/symbol.hpp"
 #include "library/console.hpp"
+#include "library/performance.hpp"
+#include "library/promise.hpp"
+#include "library/global.hpp"