@ugo-studio/jspp 0.2.8 → 0.3.0

package/src/prelude/values/array.hpp

@@ -23,7 +23,6 @@ namespace jspp
         JsType get_heap_type() const override { return JsType::Array; }
 
         std::string to_std_string() const;
-        JsIterator<AnyValue> get_iterator();
 
         bool has_property(const std::string &key) const;
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);

package/src/prelude/values/async_iterator.hpp

@@ -1,81 +1,83 @@
-#pragma once
-
-#include "types.hpp"
-#include <coroutine>
-#include <optional>
-#include <queue>
-#include <iostream>
-#include <utility>
-#include <exception>
-#include "values/promise.hpp"
-#include "scheduler.hpp"
-
-namespace jspp
-{
-    // Forward declaration of AnyValue
-    class AnyValue;
-
-    template <typename T>
-    class JsAsyncIterator : public HeapObject
-    {
-    public:
-        JsType get_heap_type() const override { return JsType::AsyncIterator; }
-
-        struct promise_type
-        {
-            std::queue<std::pair<JsPromise, T>> pending_calls;
-            bool is_awaiting = false;
-            bool is_running = false;
-            T current_input;
-
-            JsAsyncIterator get_return_object()
-            {
-                return JsAsyncIterator{
-                    std::coroutine_handle<promise_type>::from_promise(*this)};
-            }
-
-            std::suspend_always initial_suspend() noexcept { return {}; }
-
-            std::suspend_always final_suspend() noexcept { return {}; }
-
-            // Declarations
-            template <typename From>
-            auto yield_value(From &&from);
-
-            template <typename From>
-            void return_value(From &&from);
-
-            void unhandled_exception();
-
-            void fail_all(const AnyValue &reason);
-
-            auto await_transform(AnyValue value);
-        };
-
-        using handle_type = std::coroutine_handle<promise_type>;
-        handle_type handle;
-
-        explicit JsAsyncIterator(handle_type h) : handle(h) {}
-        JsAsyncIterator(JsAsyncIterator &&other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
-
-        JsAsyncIterator(const JsAsyncIterator &) = delete;
-        JsAsyncIterator &operator=(const JsAsyncIterator &) = delete;
-
-        ~JsAsyncIterator()
-        {
-            if (handle)
-                handle.destroy();
-        }
-
-        std::unordered_map<std::string, AnyValue> props;
-
-        std::string to_std_string() const;
-
-        JsPromise next(const T &val = T());
-
-        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
-        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
-
-        void resume_next();
-    };
-}
+#pragma once
+
+#include "types.hpp"
+#include <coroutine>
+#include <optional>
+#include <queue>
+#include <iostream>
+#include <utility>
+#include <exception>
+#include "values/promise.hpp"
+#include "scheduler.hpp"
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    template <typename T>
+    class JsAsyncIterator : public HeapObject
+    {
+    public:
+        JsType get_heap_type() const override { return JsType::AsyncIterator; }
+
+        struct promise_type
+        {
+            std::queue<std::pair<JsPromise, T>> pending_calls;
+            bool is_awaiting = false;
+            bool is_running = false;
+            T current_input;
+
+            JsAsyncIterator get_return_object()
+            {
+                return JsAsyncIterator{
+                    std::coroutine_handle<promise_type>::from_promise(*this)};
+            }
+
+            std::suspend_always initial_suspend() noexcept { return {}; }
+
+            std::suspend_always final_suspend() noexcept { return {}; }
+
+            // Declarations
+            template <typename From>
+            auto yield_value(From &&from);
+
+            template <typename From>
+            void return_value(From &&from);
+
+            void unhandled_exception();
+
+            void fail_all(const AnyValue &reason);
+
+            auto await_transform(AnyValue value);
+        };
+
+        using handle_type = std::coroutine_handle<promise_type>;
+        handle_type handle;
+
+        explicit JsAsyncIterator(handle_type h) : handle(h) {}
+        JsAsyncIterator(JsAsyncIterator &&other) noexcept 
+            : handle(std::exchange(other.handle, nullptr)),
+              props(std::move(other.props)) {}
+
+        JsAsyncIterator(const JsAsyncIterator &) = delete;
+        JsAsyncIterator &operator=(const JsAsyncIterator &) = delete;
+
+        ~JsAsyncIterator()
+        {
+            if (handle)
+                handle.destroy();
+        }
+
+        std::unordered_map<std::string, AnyValue> props;
+
+        std::string to_std_string() const;
+
+        JsPromise next(const T &val = T());
+
+        AnyValue get_property(const std::string &key, AnyValue thisVal);
+        AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
+
+        void resume_next();
+    };
+}

package/src/prelude/values/function.hpp

@@ -1,82 +1,82 @@
-#pragma once
-
-#include "types.hpp"
-#include <optional>
-
-namespace jspp
-{
-  // Forward declaration of AnyValue
-  class AnyValue;
-
-  struct JsFunction : HeapObject
-  {
-    JsFunctionCallable callable;
-    std::optional<std::string> name;
-    std::unordered_map<std::string, AnyValue> props;
-    AnyValue proto;
-    bool is_generator;
-    bool is_async;
-    bool is_class;
-    bool is_constructor;
-
-    // ---- Constructor A: infer flags ----
-    JsFunction(const JsFunctionCallable &c,
-               std::optional<std::string> n = std::nullopt,
-               std::unordered_map<std::string, AnyValue> p = {},
-               bool is_cls = false,
-               bool is_ctor = true)
-        : callable(c),
-          name(std::move(n)),
-          props(std::move(p)),
-          is_generator(callable.index() == 1),
-          is_async(callable.index() == 2),
-          is_class(is_cls),
-          is_constructor(is_ctor && !is_generator && !is_async) // Generators and asyncs are never constructors
-    {
-    }
-
-    // ---- Constructor B: explicit generator flag (backward compat) ----
-    JsFunction(const JsFunctionCallable &c,
-               bool is_gen,
-               std::optional<std::string> n = std::nullopt,
-               std::unordered_map<std::string, AnyValue> p = {},
-               bool is_cls = false,
-               bool is_ctor = true)
-        : callable(c),
-          name(std::move(n)),
-          props(std::move(p)),
-          is_generator(is_gen),
-          is_async(callable.index() == 2),
-          is_class(is_cls),
-          is_constructor(is_ctor && !is_gen && !is_async)
-    {
-    }
-
-    // ---- Constructor C: explicit async flag ----
-    JsFunction(const JsFunctionCallable &c,
-               bool is_gen,
-               bool is_async_func,
-               std::optional<std::string> n = std::nullopt,
-               std::unordered_map<std::string, AnyValue> p = {},
-               bool is_cls = false,
-               bool is_ctor = true)
-        : callable(c),
-          name(std::move(n)),
-          props(std::move(p)),
-          is_generator(is_gen),
-          is_async(is_async_func),
-          is_class(is_cls),
-          is_constructor(is_ctor && !is_gen && !is_async_func)
-    {
-    }
-
-    JsType get_heap_type() const override { return JsType::Function; }
-
-    std::string to_std_string() const;
-    AnyValue call(const AnyValue &thisVal, std::span<const AnyValue> args);
-
-    bool has_property(const std::string &key) const;
-    AnyValue get_property(const std::string &key, const AnyValue &thisVal);
-    AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
-  };
-}
+#pragma once
+
+#include "types.hpp"
+#include <optional>
+
+namespace jspp
+{
+  // Forward declaration of AnyValue
+  class AnyValue;
+
+  struct JsFunction : HeapObject
+  {
+    JsFunctionCallable callable;
+    std::optional<std::string> name;
+    std::unordered_map<std::string, AnyValue> props;
+    AnyValue proto;
+    bool is_generator;
+    bool is_async;
+    bool is_class;
+    bool is_constructor;
+
+    // ---- Constructor A: infer flags ----
+    JsFunction(const JsFunctionCallable &c,
+               std::optional<std::string> n = std::nullopt,
+               std::unordered_map<std::string, AnyValue> p = {},
+               bool is_cls = false,
+               bool is_ctor = true)
+        : callable(c),
+          name(std::move(n)),
+          props(std::move(p)),
+          is_generator(callable.index() == 1),
+          is_async(callable.index() == 2),
+          is_class(is_cls),
+          is_constructor(is_ctor && !is_generator && !is_async) // Generators and asyncs are never constructors
+    {
+    }
+
+    // ---- Constructor B: explicit generator flag (backward compat) ----
+    JsFunction(const JsFunctionCallable &c,
+               bool is_gen,
+               std::optional<std::string> n = std::nullopt,
+               std::unordered_map<std::string, AnyValue> p = {},
+               bool is_cls = false,
+               bool is_ctor = true)
+        : callable(c),
+          name(std::move(n)),
+          props(std::move(p)),
+          is_generator(is_gen),
+          is_async(callable.index() == 2),
+          is_class(is_cls),
+          is_constructor(is_ctor && !is_gen && !is_async)
+    {
+    }
+
+    // ---- Constructor C: explicit async flag ----
+    JsFunction(const JsFunctionCallable &c,
+               bool is_gen,
+               bool is_async_func,
+               std::optional<std::string> n = std::nullopt,
+               std::unordered_map<std::string, AnyValue> p = {},
+               bool is_cls = false,
+               bool is_ctor = true)
+        : callable(c),
+          name(std::move(n)),
+          props(std::move(p)),
+          is_generator(is_gen),
+          is_async(is_async_func),
+          is_class(is_cls),
+          is_constructor(is_ctor && !is_gen && !is_async_func)
+    {
+    }
+
+    JsType get_heap_type() const override { return JsType::Function; }
+
+    std::string to_std_string() const;
+    AnyValue call(AnyValue thisVal, std::span<const AnyValue> args);
+
+    bool has_property(const std::string &key) const;
+    AnyValue get_property(const std::string &key, AnyValue thisVal);
+    AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
+  };
+}