@ugo-studio/jspp 0.2.9 → 0.3.1

package/src/prelude/library/object.hpp

@@ -1,276 +1,14 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "utils/access.hpp"
-#include "exception.hpp"
-
-// Define Object constructor
-inline auto Object = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                {
-    if (args.empty() || args[0].is_undefined() || args[0].is_null()) {
-        return jspp::AnyValue::make_object({});
-    }
-    // Return argument if it is an object
-    if (args[0].is_object() || args[0].is_array() || args[0].is_function() || args[0].is_promise() || args[0].is_iterator()) {
-        return args[0];
-    }
-    // TODO: Wrapper objects for primitives
-    return jspp::AnyValue::make_object({}); }, "Object");
-
-struct ObjectInit
-{
-    ObjectInit()
-    {
-        // Object.keys(obj)
-        Object.define_data_property("keys", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                          {
-            if (args.empty()) throw jspp::Exception::make_exception("Object.keys called on non-object", "TypeError");
-            auto obj = args[0];
-            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.keys called on null or undefined", "TypeError");
-            
-            auto keys = jspp::Access::get_object_keys(obj);
-            std::vector<jspp::AnyValue> keyValues;
-            for(const auto& k : keys) {
-                keyValues.push_back(jspp::AnyValue::make_string(k));
-            }
-            return jspp::AnyValue::make_array(std::move(keyValues)); }, "keys"));
-
-        // Object.values(obj)
-        Object.define_data_property("values", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-            if (args.empty()) throw jspp::Exception::make_exception("Object.values called on non-object", "TypeError");
-            auto obj = args[0];
-            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.values called on null or undefined", "TypeError");
-            
-            auto keys = jspp::Access::get_object_keys(obj);
-            std::vector<jspp::AnyValue> values;
-            for(const auto& k : keys) {
-                values.push_back(obj.get_property_with_receiver(k, obj));
-            }
-            return jspp::AnyValue::make_array(std::move(values)); }, "values"));
-
-        // Object.entries(obj)
-        Object.define_data_property("entries", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                             {
-            if (args.empty()) throw jspp::Exception::make_exception("Object.entries called on non-object", "TypeError");
-            auto obj = args[0];
-            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.entries called on null or undefined", "TypeError");
-            
-            auto keys = jspp::Access::get_object_keys(obj);
-            std::vector<jspp::AnyValue> entries;
-            for(const auto& k : keys) {
-                std::vector<jspp::AnyValue> entry;
-                entry.push_back(jspp::AnyValue::make_string(k));
-                entry.push_back(obj.get_property_with_receiver(k, obj));
-                entries.push_back(jspp::AnyValue::make_array(std::move(entry)));
-            }
-            return jspp::AnyValue::make_array(std::move(entries)); }, "entries"));
-
-        // Object.assign(target, ...sources)
-        Object.define_data_property("assign", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-            if (args.empty()) throw jspp::Exception::make_exception("Cannot convert undefined or null to object", "TypeError");
-            auto target = args[0];
-            if (target.is_null() || target.is_undefined()) throw jspp::Exception::make_exception("Cannot convert undefined or null to object", "TypeError");
-
-            for (size_t i = 1; i < args.size(); ++i) {
-                auto source = args[i];
-                if (source.is_null() || source.is_undefined()) continue;
-                
-                auto keys = jspp::Access::get_object_keys(source);
-                for(const auto& k : keys) {
-                     auto val = source.get_property_with_receiver(k, source);
-                     target.set_own_property(k, val);
-                }
-            }
-            return target; }, "assign"));
-
-        // Object.is(value1, value2)
-        Object.define_data_property("is", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                        {
-            jspp::AnyValue v1 = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
-            jspp::AnyValue v2 = args.size() > 1 ? args[1] : jspp::Constants::UNDEFINED;
-            
-            if (v1.is_number() && v2.is_number()) {
-                double d1 = v1.as_double();
-                double d2 = v2.as_double();
-                if (std::isnan(d1) && std::isnan(d2)) return jspp::Constants::TRUE;
-                if (d1 == 0 && d2 == 0) {
-                    return jspp::AnyValue::make_boolean(std::signbit(d1) == std::signbit(d2));
-                }
-                return jspp::AnyValue::make_boolean(d1 == d2);
-            }
-            
-            return jspp::is_strictly_equal_to(v1, v2); }, "is"));
-
-        // Object.getPrototypeOf(obj)
-        Object.define_data_property("getPrototypeOf", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                    {
-             if (args.empty()) throw jspp::Exception::make_exception("Object.getPrototypeOf called on non-object", "TypeError");
-             auto obj = args[0];
-             
-             if (obj.is_object()) {
-                 return obj.as_object()->proto;
-             }
-             if (obj.is_array()) {
-                 return obj.as_array()->proto;
-             }
-             if (obj.is_function()) {
-                 return obj.as_function()->proto;
-             }
-             
-             return jspp::Constants::Null; }, "getPrototypeOf"));
-
-        // Object.setPrototypeOf(obj, proto)
-        Object.define_data_property("setPrototypeOf", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                    {
-             if (args.size() < 2) throw jspp::Exception::make_exception("Object.setPrototypeOf requires at least 2 arguments", "TypeError");
-             auto obj = args[0];
-             auto proto = args[1];
-             
-             if (!proto.is_object() && !proto.is_null()) {
-                 throw jspp::Exception::make_exception("Object prototype may only be an Object or null", "TypeError");
-             }
-             
-             if (obj.is_object()) {
-                 obj.as_object()->proto = proto;
-             } else if (obj.is_array()) {
-                 obj.as_array()->proto = proto;
-             } else if (obj.is_function()) {
-                 obj.as_function()->proto = proto;
-             }
-             
-             return obj; }, "setPrototypeOf"));
-
-        // Object.create(proto, [propertiesObject])
-        Object.define_data_property("create", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-             if (args.empty()) throw jspp::Exception::make_exception("Object prototype may only be an Object or null", "TypeError");
-             auto proto = args[0];
-             if (!proto.is_object() && !proto.is_null()) {
-                 throw jspp::Exception::make_exception("Object prototype may only be an Object or null", "TypeError");
-             }
-             
-             auto newObj = jspp::AnyValue::make_object_with_proto({}, proto);
-             
-             if (args.size() > 1 && !args[1].is_undefined()) {
-                 // Object.defineProperties(newObj, propertiesObject)
-                 // TODO: implement defineProperties logic if needed.
-             }
-             
-             return newObj; }, "create"));
-
-        // Object.defineProperty(obj, prop, descriptor)
-        Object.define_data_property("defineProperty", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                    {
-             if (args.size() < 3) throw jspp::Exception::make_exception("Object.defineProperty requires 3 arguments", "TypeError");
-             auto obj = args[0];
-             if (!obj.is_object() && !obj.is_array() && !obj.is_function()) throw jspp::Exception::make_exception("Object.defineProperty called on non-object", "TypeError");
-             
-             std::string prop = args[1].to_std_string();
-             auto descObj = args[2];
-             
-             bool enumerable = false;
-             bool configurable = false;
-             bool writable = false;
-             
-             if (descObj.has_property("enumerable")) enumerable = jspp::is_truthy(descObj.get_own_property("enumerable"));
-             if (descObj.has_property("configurable")) configurable = jspp::is_truthy(descObj.get_own_property("configurable"));
-             if (descObj.has_property("writable")) writable = jspp::is_truthy(descObj.get_own_property("writable"));
-             
-             bool hasValue = descObj.has_property("value");
-             bool hasGet = descObj.has_property("get");
-             bool hasSet = descObj.has_property("set");
-             
-             if (hasValue && (hasGet || hasSet)) {
-                 throw jspp::Exception::make_exception("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute", "TypeError");
-             }
-             
-             if (hasValue) {
-                 auto value = descObj.get_own_property("value");
-                 obj.define_data_property(prop, value, writable, enumerable, configurable);
-             } else {
-                 jspp::AnyValue getter = jspp::Constants::UNDEFINED;
-                 jspp::AnyValue setter = jspp::Constants::UNDEFINED;
-                 
-                 if (hasGet) getter = descObj.get_own_property("get");
-                 if (hasSet) setter = descObj.get_own_property("set");
-                 
-                 if (!getter.is_undefined() && !getter.is_function()) throw jspp::Exception::make_exception("Getter must be a function: " + getter.to_std_string(), "TypeError");
-                 if (!setter.is_undefined() && !setter.is_function()) throw jspp::Exception::make_exception("Setter must be a function", "TypeError");
-
-                 if (obj.is_object()) {
-                    auto o_ptr = obj.as_object();
-                    std::optional<std::function<jspp::AnyValue(jspp::AnyValue, std::span<const jspp::AnyValue>)>> getFunc;
-                    std::optional<std::function<jspp::AnyValue(jspp::AnyValue, std::span<const jspp::AnyValue>)>> setFunc;
-                    
-                    if (getter.is_function()) {
-                        getFunc = [getter](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-                            return getter.call(thisVal, args);
-                        };
-                    }
-                    if (setter.is_function()) {
-                        setFunc = [setter](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-                            return setter.call(thisVal, args);
-                        };
-                    }
-                    
-                    auto desc = jspp::AnyValue::make_accessor_descriptor(getFunc, setFunc, enumerable, configurable);
-                    auto offset = o_ptr->shape->get_offset(prop);
-                    if (offset.has_value()) {
-                        o_ptr->storage[offset.value()] = desc;
-                    } else {
-                        o_ptr->shape = o_ptr->shape->transition(prop);
-                        o_ptr->storage.push_back(desc);
-                    }
-                 }
-             }
-             
-             return obj; }, "defineProperty"));
-
-        // Object.hasOwn(obj, prop)
-        Object.define_data_property("hasOwn", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-            if (args.empty()) throw jspp::Exception::make_exception("Object.hasOwn called on non-object", "TypeError");
-            auto obj = args[0];
-            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.hasOwn called on null or undefined", "TypeError");
-            std::string prop = args.size() > 1 ? args[1].to_std_string() : "undefined";
-            
-            if (obj.is_object()) return jspp::AnyValue::make_boolean(obj.as_object()->shape->get_offset(prop).has_value());
-            if (obj.is_function()) return jspp::AnyValue::make_boolean(obj.as_function()->props.count(prop));
-            if (obj.is_array()) {
-                if (prop == "length") return jspp::Constants::TRUE;
-                if (jspp::JsArray::is_array_index(prop)) {
-                    uint32_t idx = static_cast<uint32_t>(std::stoull(prop));
-                    auto arr = obj.as_array();
-                    if (idx < arr->dense.size() && !(arr->dense[idx].is_uninitialized())) return jspp::Constants::TRUE;
-                    if (arr->sparse.count(idx)) return jspp::Constants::TRUE;
-                    return jspp::Constants::FALSE;
-                }
-                return jspp::AnyValue::make_boolean(obj.as_array()->props.count(prop));
-            }
-            
-            return jspp::Constants::FALSE; }, "hasOwn"));
-
-        // Object.prototype.hasOwnProperty
-        auto proto = Object.get_own_property("prototype");
-        proto.define_data_property("hasOwnProperty", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                   {
-             std::string prop = args.size() > 0 ? args[0].to_std_string() : "undefined";
-             if (thisVal.is_object()) return jspp::AnyValue::make_boolean(thisVal.as_object()->shape->get_offset(prop).has_value());
-             if (thisVal.is_function()) return jspp::AnyValue::make_boolean(thisVal.as_function()->props.count(prop));
-             if (thisVal.is_array()) {
-                 if (prop == "length") return jspp::Constants::TRUE;
-                 if (jspp::JsArray::is_array_index(prop)) {
-                     uint32_t idx = static_cast<uint32_t>(std::stoull(prop));
-                     auto arr = thisVal.as_array();
-                     if (idx < arr->dense.size() && !(arr->dense[idx].is_uninitialized())) return jspp::Constants::TRUE;
-                     if (arr->sparse.count(idx)) return jspp::Constants::TRUE;
-                     return jspp::Constants::FALSE;
-                 }
-                 return jspp::AnyValue::make_boolean(thisVal.as_array()->props.count(prop));
-             }
-             return jspp::Constants::FALSE; }, "hasOwnProperty"));
-    }
-} objectInit;
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/access.hpp"
+#include "exception.hpp"
+
+namespace jspp
+{
+    extern AnyValue Object;
+    void init_object();
+}
+
+using jspp::Object;

package/src/prelude/library/performance.cpp

@@ -0,0 +1,21 @@
+#include "jspp.hpp"
+#include "library/performance.hpp"
+#include <chrono>
+
+namespace jspp
+{
+
+    AnyValue performance = jspp::AnyValue::make_object({
+        {"now",
+         jspp::AnyValue::make_function(
+             [startTime = std::chrono::steady_clock::now()](jspp::AnyValue, std::span<const jspp::AnyValue>)
+             {
+                 std::chrono::duration<double, std::milli> duration =
+                     std::chrono::steady_clock::now() - startTime;
+
+                 return jspp::AnyValue::make_number(duration.count());
+             },
+             "now")},
+    });
+
+} // namespace jspp

package/src/prelude/library/performance.hpp

@@ -1,25 +1,10 @@
 #pragma once
 
-#include <chrono>
 #include "types.hpp"
-#include "values/non_values.hpp"
-#include "values/object.hpp"
-#include "values/function.hpp"
-#include "utils/operators.hpp"
+#include "any_value.hpp"
 
-inline auto performance = jspp::AnyValue::make_object({
-    {"now",
-     jspp::AnyValue::make_function(
-         // [C++14 Feature] Generalized Lambda Capture
-         // We initialize 'startTime' RIGHT HERE inside the [].
-         // It acts like a private variable stored inside this specific function.
-         [startTime = std::chrono::steady_clock::now()](jspp::AnyValue, std::span<const jspp::AnyValue>)
-         {
-             // We calculate the diff against the captured startTime
-             std::chrono::duration<double, std::milli> duration =
-                 std::chrono::steady_clock::now() - startTime;
+namespace jspp {
+    extern AnyValue performance;
+}
 
-             return jspp::AnyValue::make_number(duration.count());
-         },
-         "now")},
-});
+using jspp::performance;

package/src/prelude/library/process.cpp

@@ -0,0 +1,38 @@
+#include "jspp.hpp"
+#include "library/process.hpp"
+
+#ifdef _WIN32
+#define JSPP_PLATFORM "win32"
+#else
+#define JSPP_PLATFORM "linux"
+#endif
+
+namespace jspp {
+
+AnyValue process = jspp::AnyValue::make_object({
+    {"argv", jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})},
+    {"env", jspp::AnyValue::make_object({})},
+    {"platform", jspp::AnyValue::make_string(JSPP_PLATFORM)},
+    {"exit", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+        int code = 0;
+        if (!args.empty() && args[0].is_number()) {
+            code = static_cast<int>(args[0].as_double());
+        }
+        std::exit(code);
+        return jspp::Constants::UNDEFINED;
+    }, "exit")}
+});
+
+void setup_process_argv(int argc, char** argv) {
+    std::vector<jspp::AnyValue> args;
+    if (argc > 0) {
+        args.push_back(jspp::AnyValue::make_string(argv[0]));
+        args.push_back(jspp::AnyValue::make_string("index.js"));
+        for (int i = 1; i < argc; ++i) {
+            args.push_back(jspp::AnyValue::make_string(argv[i]));
+        }
+    }
+    process.set_own_property("argv", jspp::AnyValue::make_array(std::move(args)));
+}
+
+} // namespace jspp

package/src/prelude/library/process.hpp

@@ -1,39 +1,11 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-
-#ifdef _WIN32
-#define JSPP_PLATFORM "win32"
-#else
-#define JSPP_PLATFORM "linux"
-#endif
-
-inline auto process = jspp::AnyValue::make_object({
-    {"argv", jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})},
-    {"env", jspp::AnyValue::make_object({})},
-    {"platform", jspp::AnyValue::make_string(JSPP_PLATFORM)},
-    {"exit", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-        int code = 0;
-        if (!args.empty() && args[0].is_number()) {
-            code = static_cast<int>(args[0].as_double());
-        }
-        std::exit(code);
-        return jspp::Constants::UNDEFINED;
-    }, "exit")}
-});
-
-namespace jspp {
-    inline void setup_process_argv(int argc, char** argv) {
-        std::vector<jspp::AnyValue> args;
-        if (argc > 0) {
-            args.push_back(jspp::AnyValue::make_string(argv[0]));
-            args.push_back(jspp::AnyValue::make_string("index.js"));
-            for (int i = 1; i < argc; ++i) {
-                args.push_back(jspp::AnyValue::make_string(argv[i]));
-            }
-        }
-        process.set_own_property("argv", jspp::AnyValue::make_array(std::move(args)));
-    }
-}
-
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+namespace jspp {
+    extern AnyValue process;
+    void setup_process_argv(int argc, char** argv);
+}
+
+using jspp::process;

package/src/prelude/library/promise.cpp

@@ -0,0 +1,131 @@
+#include "jspp.hpp"
+#include "library/promise.hpp"
+
+namespace jspp
+{
+    jspp::AnyValue Promise = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                     {
+        if (args.empty() || !args[0].is_function())
+        {
+            throw jspp::Exception::make_exception("Promise resolver undefined is not a function", "TypeError");
+        }
+        auto executor = args[0].as_function();
+
+        jspp::JsPromise promise;
+        auto state = promise.state; // Share state
+
+        // resolve function
+        auto resolveFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        {
+            jspp::JsPromise p; p.state = state;
+            p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+            return jspp::Constants::UNDEFINED; 
+        }), "resolve");
+
+        // reject function
+        auto rejectFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        {
+            jspp::JsPromise p; p.state = state;
+            p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+            return jspp::Constants::UNDEFINED; 
+        }), "reject");
+
+        try
+        {
+            const jspp::AnyValue executorArgs[] = {resolveFn, rejectFn};
+            executor->call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(executorArgs, 2));
+        }
+        catch (const jspp::Exception &e)
+        {
+            promise.reject(e.data);
+        }
+        catch (...)
+        {
+            promise.reject(jspp::AnyValue::make_string("Unknown error during Promise execution"));
+        }
+
+        return jspp::AnyValue::make_promise(promise); }),
+        "Promise");
+
+    struct PromiseInit
+    {
+        PromiseInit()
+        {
+            Promise.define_data_property("resolve", jspp::AnyValue::make_function(
+                                                        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                     {
+                jspp::JsPromise p;
+                p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+                return jspp::AnyValue::make_promise(p); }),
+                                                        "resolve"));
+
+            Promise.define_data_property("reject", jspp::AnyValue::make_function(
+                                                       std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                    {
+                jspp::JsPromise p;
+                p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+                return jspp::AnyValue::make_promise(p); }),
+                                                       "reject"));
+
+            Promise.define_data_property("all", jspp::AnyValue::make_function(
+                                                    std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                 {
+                 if (args.empty() || !args[0].is_array()) {
+                     jspp::JsPromise p; p.reject(jspp::AnyValue::make_string("Promise.all argument must be an array"));
+                     return jspp::AnyValue::make_promise(p);
+                 }
+
+                 auto arr = args[0].as_array();
+                 size_t len = static_cast<size_t>(arr->length);
+                 if (len == 0) {
+                     jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array(std::vector<jspp::AnyValue>()));
+                     return jspp::AnyValue::make_promise(p);
+                 }
+
+                 jspp::JsPromise masterPromise;
+                 auto masterState = masterPromise.state;
+                 
+                 auto results = std::make_shared<std::vector<jspp::AnyValue>>(len, jspp::Constants::UNDEFINED);
+                 auto count = std::make_shared<size_t>(len);
+                 auto rejected = std::make_shared<bool>(false);
+
+                 for (size_t i = 0; i < len; ++i) {
+                     jspp::AnyValue item = arr->get_property(static_cast<uint32_t>(i));
+                     
+                     auto handleResult = [masterState, results, count, i, rejected](jspp::AnyValue res) {
+                          if (*rejected) return;
+                          (*results)[i] = res;
+                          (*count)--;
+                          if (*count == 0) {
+                              jspp::JsPromise p; p.state = masterState;
+                              p.resolve(jspp::AnyValue::make_array(std::move(*results))); 
+                          }
+                     };
+                     
+                     auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
+                          if (*rejected) return;
+                          *rejected = true;
+                          jspp::JsPromise p; p.state = masterState;
+                          masterState->status = jspp::PromiseStatus::Rejected;
+                          p.reject(reason);
+                     };
+
+                     if (item.is_promise()) {
+                         item.as_promise()->then(handleResult, handleReject);
+                     } else {
+                         handleResult(item);
+                     }
+                 }
+                 
+                 return jspp::AnyValue::make_promise(masterPromise); }),
+                                                    "all"));
+        }
+    };
+    void init_promise()
+    {
+        static PromiseInit promiseInit;
+    }
+}