@ugo-studio/jspp 0.1.9 → 0.2.1

package/src/prelude/any_value_helpers.hpp

@@ -3,11 +3,197 @@
 #include "types.hpp"
 #include "any_value.hpp"
 #include "values/string.hpp"
+#include "values/object.hpp"
+#include "values/array.hpp"
+#include "values/function.hpp"
+#include "values/iterator.hpp"
+#include "values/async_iterator.hpp"
+#include "values/promise.hpp"
+#include "values/symbol.hpp"
+#include "values/descriptors.hpp"
 #include "exception.hpp"
 
 namespace jspp
 {
-    std::string AnyValue::to_std_string() const
+    // --- AnyValue GETTERS ---
+    inline JsString* AnyValue::as_string() const noexcept { return static_cast<JsString*>(get_ptr()); }
+    inline JsObject* AnyValue::as_object() const noexcept { return static_cast<JsObject*>(get_ptr()); }
+    inline JsArray* AnyValue::as_array() const noexcept { return static_cast<JsArray*>(get_ptr()); }
+    inline JsFunction* AnyValue::as_function() const noexcept { return static_cast<JsFunction*>(get_ptr()); }
+    inline JsSymbol* AnyValue::as_symbol() const noexcept { return static_cast<JsSymbol*>(get_ptr()); }
+    inline JsPromise* AnyValue::as_promise() const noexcept { return static_cast<JsPromise*>(get_ptr()); }
+    inline JsIterator<AnyValue>* AnyValue::as_iterator() const noexcept { return static_cast<JsIterator<AnyValue>*>(get_ptr()); }
+    inline JsAsyncIterator<AnyValue>* AnyValue::as_async_iterator() const noexcept { return static_cast<JsAsyncIterator<AnyValue>*>(get_ptr()); }
+    inline DataDescriptor* AnyValue::as_data_descriptor() const noexcept { return static_cast<DataDescriptor*>(get_ptr()); }
+    inline AccessorDescriptor* AnyValue::as_accessor_descriptor() const noexcept { return static_cast<AccessorDescriptor*>(get_ptr()); }
+    
+    inline bool AnyValue::is_generator() const noexcept { return is_function() && as_function()->is_generator; }
+
+    // --- AnyValue FACTORIES ---
+    inline AnyValue AnyValue::make_string(const std::string &raw_s) noexcept {
+        return from_ptr(new JsString(raw_s));
+    }
+    inline AnyValue AnyValue::make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept {
+        return from_ptr(new JsObject(props, make_null()));
+    }
+    inline AnyValue AnyValue::make_object(const std::map<std::string, AnyValue> &props) noexcept {
+        return from_ptr(new JsObject(props, make_null()));
+    }
+    inline AnyValue AnyValue::make_object_with_proto(std::initializer_list<std::pair<std::string, AnyValue>> props, AnyValue proto) noexcept {
+        return from_ptr(new JsObject(props, proto));
+    }
+    inline AnyValue AnyValue::make_object_with_proto(const std::map<std::string, AnyValue> &props, AnyValue proto) noexcept {
+        return from_ptr(new JsObject(props, proto));
+    }
+    inline AnyValue AnyValue::make_array(std::span<const AnyValue> dense) noexcept {
+        std::vector<AnyValue> vec;
+        vec.reserve(dense.size());
+        for (const auto &item : dense) vec.push_back(item);
+        return from_ptr(new JsArray(std::move(vec)));
+    }
+    inline AnyValue AnyValue::make_array(const std::vector<AnyValue> &dense) noexcept {
+        return from_ptr(new JsArray(dense));
+    }
+    inline AnyValue AnyValue::make_array(std::vector<AnyValue> &&dense) noexcept {
+        return from_ptr(new JsArray(std::move(dense)));
+    }
+    inline AnyValue AnyValue::make_array_with_proto(std::span<const AnyValue> dense, AnyValue proto) noexcept {
+        auto arr = new JsArray();
+        arr->dense.reserve(dense.size());
+        for (const auto &item : dense) arr->dense.push_back(item);
+        arr->length = dense.size();
+        arr->proto = proto;
+        return from_ptr(arr);
+    }
+    inline AnyValue AnyValue::make_array_with_proto(const std::vector<AnyValue> &dense, AnyValue proto) noexcept {
+        auto arr = new JsArray(dense);
+        arr->proto = proto;
+        return from_ptr(arr);
+    }
+    inline AnyValue AnyValue::make_function(const JsFunctionCallable &call, const std::optional<std::string> &name, bool is_constructor) noexcept {
+        auto v = from_ptr(new JsFunction(call, name, {}, false, is_constructor));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    inline AnyValue AnyValue::make_class(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+        auto v = from_ptr(new JsFunction(call, name, {}, true));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    inline AnyValue AnyValue::make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+        auto v = from_ptr(new JsFunction(call, true, name));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    inline AnyValue AnyValue::make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+        auto v = from_ptr(new JsFunction(call, false, true, name));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    inline AnyValue AnyValue::make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+        auto v = from_ptr(new JsFunction(call, true, true, name));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    inline AnyValue AnyValue::make_symbol(const std::string &description) noexcept {
+        return from_ptr(new JsSymbol(description));
+    }
+    inline AnyValue AnyValue::make_promise(const JsPromise &promise) noexcept {
+        auto p = new JsPromise();
+        *p = promise;
+        return from_ptr(p);
+    }
+    inline AnyValue AnyValue::make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept {
+        return from_ptr(new DataDescriptor(value, writable, enumerable, configurable));
+    }
+    inline AnyValue AnyValue::make_accessor_descriptor(const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &get,
+                                                     const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &set,
+                                                     bool enumerable,
+                                                     bool configurable) noexcept {
+        return from_ptr(new AccessorDescriptor(get, set, enumerable, configurable));
+    }
+
+    inline AnyValue AnyValue::from_symbol(JsSymbol *sym) noexcept {
+        return from_ptr(sym);
+    }
+    inline AnyValue AnyValue::from_string(JsString *str) noexcept {
+        return from_ptr(str);
+    }
+
+    inline AnyValue AnyValue::from_iterator(JsIterator<AnyValue> &&iterator) noexcept {
+        auto it = new JsIterator<AnyValue>(std::move(iterator));
+        return from_ptr(it);
+    }
+    inline AnyValue AnyValue::from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept {
+        return from_ptr(iterator); 
+    }
+    inline AnyValue AnyValue::from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept {
+        auto it = new JsAsyncIterator<AnyValue>(std::move(iterator));
+        return from_ptr(it);
+    }
+
+    inline AnyValue AnyValue::resolve_property_for_read(const AnyValue &val, const AnyValue &thisVal, const std::string &propName) noexcept
+    {
+        if (val.is_data_descriptor())
+        {
+            return val.as_data_descriptor()->value;
+        }
+        if (val.is_accessor_descriptor())
+        {
+            auto accessor = val.as_accessor_descriptor();
+            if (accessor->get.has_value())
+                return accessor->get.value()(thisVal, std::span<const AnyValue>{});
+            else
+            {
+                return Constants::UNDEFINED;
+            }
+        }
+        return val;
+    }
+    inline AnyValue AnyValue::resolve_property_for_write(AnyValue &val, const AnyValue &thisVal, const AnyValue &new_val, const std::string &propName)
+    {
+        if (val.is_data_descriptor())
+        {
+            auto data = val.as_data_descriptor();
+            if (data->writable)
+            {
+                data->value = new_val;
+                return new_val;
+            }
+            else
+            {
+                throw Exception::make_exception("Cannot assign to read only property '" + propName + "' of object '#<Object>'", "TypeError");
+            }
+        }
+        if (val.is_accessor_descriptor())
+        {
+            auto accessor = val.as_accessor_descriptor();
+            if (accessor->set.has_value())
+            {
+                const AnyValue args[] = {new_val};
+                accessor->set.value()(thisVal, std::span<const AnyValue>(args, 1));
+                return new_val;
+            }
+            else
+            {
+                throw Exception::make_exception("Cannot set property of #<Object> which has only a getter", "TypeError");
+            }
+        }
+        val = new_val;
+        return new_val;
+    }
+
+    inline std::string AnyValue::to_std_string() const
     {
         switch (get_type())
         {
@@ -16,35 +202,35 @@ namespace jspp
         case JsType::Null:
             return "null";
         case JsType::Boolean:
-            return std::get<bool>(storage) ? "true" : "false";
+            return as_boolean() ? "true" : "false";
         case JsType::String:
-            return std::get<std::shared_ptr<JsString>>(storage)->to_std_string();
+            return as_string()->to_std_string();
         case JsType::Object:
-            return std::get<std::shared_ptr<JsObject>>(storage)->to_std_string();
+            return as_object()->to_std_string();
         case JsType::Array:
-            return std::get<std::shared_ptr<JsArray>>(storage)->to_std_string();
+            return as_array()->to_std_string();
         case JsType::Function:
-            return std::get<std::shared_ptr<JsFunction>>(storage)->to_std_string();
+            return as_function()->to_std_string();
         case JsType::Iterator:
-            return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage)->to_std_string();
+            return as_iterator()->to_std_string();
         case JsType::AsyncIterator:
-            return std::get<std::shared_ptr<JsAsyncIterator<AnyValue>>>(storage)->to_std_string();
+            return as_async_iterator()->to_std_string();
         case JsType::Promise:
-            return std::get<std::shared_ptr<JsPromise>>(storage)->to_std_string();
+            return as_promise()->to_std_string();
         case JsType::Symbol:
-            return std::get<std::shared_ptr<JsSymbol>>(storage)->to_std_string();
+            return as_symbol()->to_std_string();
         case JsType::DataDescriptor:
-            return std::get<std::shared_ptr<DataDescriptor>>(storage)->value->to_std_string();
+            return as_data_descriptor()->value.to_std_string();
         case JsType::AccessorDescriptor:
         {
-            if (std::get<std::shared_ptr<AccessorDescriptor>>(storage)->get.has_value())
-                return std::get<std::shared_ptr<AccessorDescriptor>>(storage)->get.value()(*this, {}).to_std_string();
+            if (as_accessor_descriptor()->get.has_value())
+                return as_accessor_descriptor()->get.value()(*this, {}).to_std_string();
             else
                 return "undefined";
         }
         case JsType::Number:
         {
-            double num = std::get<double>(storage);
+            double num = as_double();
             if (std::isnan(num))
             {
                 return "NaN";
@@ -75,19 +261,19 @@ namespace jspp
         }
     }
 
-    void AnyValue::set_prototype(const AnyValue &proto)
+    inline void AnyValue::set_prototype(const AnyValue &proto)
     {
         if (is_object())
         {
-            std::get<std::shared_ptr<JsObject>>(storage)->proto = std::make_shared<AnyValue>(proto);
+            as_object()->proto = proto;
         }
         else if (is_array())
         {
-            std::get<std::shared_ptr<JsArray>>(storage)->proto = std::make_shared<AnyValue>(proto);
+            as_array()->proto = proto;
         }
         else if (is_function())
         {
-            std::get<std::shared_ptr<JsFunction>>(storage)->proto = std::make_shared<AnyValue>(proto);
+            as_function()->proto = proto;
         }
         else if (is_uninitialized())
         {
@@ -96,28 +282,25 @@ namespace jspp
     }
 
     // AnyValue::call implementation
-    const AnyValue AnyValue::call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt) const
+    inline AnyValue AnyValue::call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const
     {
         if (!is_function())
         {
             throw Exception::make_exception(expr.value_or(to_std_string()) + " is not a function", "TypeError");
         }
-        return as_function()->call(thisVal, args); // Convert to function before calling, to avoid an infinite loop
+        return as_function()->call(thisVal, args); 
     }
 
     // AnyValue::construct implementation
-    const AnyValue AnyValue::construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const
+    inline AnyValue AnyValue::construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const
     {
         if (!is_function() || !as_function()->is_constructor)
         {
-            // std::cerr << "Construct fail: " << name.value_or(to_std_string()) << " is_function=" << is_function() << " is_constructor=" << (is_function() ? as_function()->is_constructor : false) << std::endl;
             throw Exception::make_exception(name.value_or(to_std_string()) + " is not a constructor", "TypeError");
         }
 
         // 1. Get prototype
         AnyValue proto = get_own_property("prototype");
-        // If prototype is not an object, default to a plain object (which ideally inherits from Object.prototype)
-        // Here we just make a plain object.
         if (!proto.is_object())
         {
             proto = AnyValue::make_object({});
@@ -127,7 +310,6 @@ namespace jspp
         AnyValue instance = AnyValue::make_object_with_proto({}, proto);
 
         // 3. Call function
-        // We pass 'instance' as 'this'
         AnyValue result = call(instance, args);
 
         // 4. Return result if object, else instance
@@ -138,4 +320,4 @@ namespace jspp
         return instance;
     }
 
-}
+}

package/src/prelude/exception.hpp

@@ -1,32 +1,28 @@
-
-#pragma once
-
-#include <exception>
-#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();
-    };
+#pragma once
+
+#include <exception>
+#include "types.hpp"
+#include "any_value.hpp"
+
+namespace jspp
+{
+    struct Exception : std::exception
+    {
+        AnyValue data;
+
+        explicit Exception(const AnyValue &value)
+            : data(value) {}
+        explicit Exception(AnyValue &&value)
+            : data(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

@@ -1,49 +1,53 @@
-#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, name);
-    errorObj.define_data_property("name", AnyValue::make_string(name), true, false, true);
-
-    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");
-}
+#pragma once
+
+#include "types.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+
+const char *jspp::Exception::what() const noexcept
+{
+    // Note: this returns a pointer to a temporary string if we are not careful.
+    // In a real implementation, we might need to store the message string in the Exception object.
+    static thread_local std::string last_msg;
+    last_msg = data.to_std_string();
+    return last_msg.c_str();
+}
+
+jspp::Exception jspp::Exception::make_exception(const std::string &message, const std::string &name)
+{
+    // Use the global Error object to construct the exception
+    std::vector<AnyValue> args = {AnyValue::make_string(message)};
+    AnyValue errorObj = ::Error.construct(args, name);
+    errorObj.define_data_property("name", AnyValue::make_string(name), true, false, true);
+
+    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

@@ -7,15 +7,15 @@
 #include "values/shape.hpp"
 #include "values/symbol.hpp"
 #include "values/non_values.hpp"
-#include "values/object.hpp"
-#include "values/array.hpp"
-#include "values/function.hpp"
 #include "values/iterator.hpp"
 #include "values/async_iterator.hpp"
-#include "values/promise.hpp"
 #include "values/string.hpp"
 
 #include "any_value.hpp"
+#include "values/object.hpp"
+#include "values/array.hpp"
+#include "values/function.hpp"
+#include "values/promise.hpp"
 #include "values/descriptors.hpp"
 #include "any_value_helpers.hpp"
 #include "any_value_access.hpp"

package/src/prelude/library/array.hpp

@@ -14,7 +14,7 @@ inline auto Array = jspp::AnyValue::make_class([](const jspp::AnyValue &thisVal,
         }
         auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
         arr.as_array()->length = static_cast<uint64_t>(len);
-        arr.as_array()->dense.resize(static_cast<size_t>(len), jspp::AnyValue::make_uninitialized());
+        arr.as_array()->dense.resize(static_cast<size_t>(len), jspp::Constants::UNINITIALIZED);
         return arr;
     }
     std::vector<jspp::AnyValue> elements;
@@ -27,9 +27,6 @@ struct ArrayInit
 {
     ArrayInit()
     {
-        // Set Array.prototype.proto to Object.prototype
-        // Array.get_own_property("prototype").set_prototype(::Object.get_own_property("prototype"));
-
         // Array.isArray(value)
         Array.define_data_property("isArray", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                             {
@@ -58,8 +55,6 @@ struct ArrayInit
 
             std::vector<jspp::AnyValue> result;
 
-            // Check if iterable
-            // Simple check: does it have [Symbol.iterator]?
             auto iteratorSym = jspp::WellKnownSymbols::iterator;
             if (items.has_property(iteratorSym->key)) {
                 auto iter = jspp::Access::get_object_value_iterator(items, "Array.from source");
@@ -111,8 +106,8 @@ struct ArrayInit
             std::vector<jspp::AnyValue> result;
             
             bool isAsync = false;
-            jspp::AnyValue iter;
-            jspp::AnyValue nextFn;
+            jspp::AnyValue iter = jspp::Constants::UNDEFINED;
+            jspp::AnyValue nextFn = jspp::Constants::UNDEFINED;
 
             if (items.has_property(jspp::WellKnownSymbols::asyncIterator->key)) {
                 auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::asyncIterator->key, items);
@@ -187,4 +182,4 @@ struct ArrayInit
         Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                                                                         { return thisVal; }, "get [Symbol.species]"));
     }
-} arrayInit;
+} arrayInit;