@nocobase/plugin-workflow-javascript 2.1.0-beta.11 → 2.1.0-beta.12

package/dist/node_modules/isolated-vm/src/isolate/v8_inspector_wrapper.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "node_wrapper.h"
+#include "./v8_version.h"
+#if V8_AT_LEAST(12, 4, 254)
+#include "v8_inspector/nodejs_v22.0.0.h"
+#elif V8_AT_LEAST(11, 3, 244)
+#include "v8_inspector/nodejs_v20.0.0.h"
+#elif V8_AT_LEAST(10, 2, 154)
+#include "v8_inspector/nodejs_v18.3.0.h"
+#else
+#include "v8_inspector/nodejs_v18.0.0.h"
+#endif

package/dist/node_modules/isolated-vm/src/isolate/v8_version.h

@@ -0,0 +1,12 @@
+#include "node_wrapper.h"
+#define V8_AT_LEAST(major, minor, patch) (\
+	V8_MAJOR_VERSION > (major) || \
+	(V8_MAJOR_VERSION == (major) && V8_MINOR_VERSION > (minor)) || \
+	(V8_MAJOR_VERSION == (major) && V8_MINOR_VERSION == (minor) && V8_BUILD_NUMBER >= (patch)) \
+)
+
+#ifdef NODE_MODULE_VERSION
+#define NODE_MODULE_OR_V8_AT_LEAST(nodejs, v8_major, v8_minor, v8_build) (NODE_MODULE_VERSION >= (nodejs))
+#else
+#define NODE_MODULE_OR_V8_AT_LEAST(nodejs, v8_major, v8_minor, v8_build) (V8_AT_LEAST(v8_major, v8_minor, v8_build))
+#endif

package/dist/node_modules/isolated-vm/src/isolated_vm.h

@@ -0,0 +1,71 @@
+#pragma once
+#ifdef _WIN32
+#define ISOLATED_VM_MODULE extern "C" __declspec(dllexport)
+#else
+#define ISOLATED_VM_MODULE extern "C"
+#endif
+
+#include "isolate/environment.h"
+#include "isolate/holder.h"
+#include "isolate/remote_handle.h"
+#include "isolate/runnable.h"
+#include <memory>
+
+namespace isolated_vm {
+	using Runnable = ivm::Runnable;
+	// ^ The only thing you need to know: `virtual void Run() = 0`
+
+	class IsolateHolder {
+		private:
+			std::shared_ptr<ivm::IsolateHolder> holder;
+			explicit IsolateHolder(std::shared_ptr<ivm::IsolateHolder> holder) : holder{std::move(holder)} {
+				ivm::LockedScheduler::IncrementUvRefForIsolate(holder);
+			}
+
+		public:
+			IsolateHolder(const IsolateHolder& that) : holder{that.holder} {
+				ivm::LockedScheduler::IncrementUvRefForIsolate(holder);
+			}
+
+			IsolateHolder(IsolateHolder&& that) noexcept : holder{std::move(that.holder)} {
+			}
+
+			~IsolateHolder() {
+				if (holder) {
+					ivm::LockedScheduler::DecrementUvRefForIsolate(holder);
+				}
+			}
+
+			auto operator=(const IsolateHolder&) -> IsolateHolder& = default;
+			auto operator=(IsolateHolder&&) -> IsolateHolder& = default;
+
+			static auto GetCurrent() -> IsolateHolder {
+				return IsolateHolder{ivm::IsolateEnvironment::GetCurrentHolder()};
+			}
+
+			void ScheduleTask(std::unique_ptr<Runnable> runnable) {
+				holder->ScheduleTask(std::move(runnable), false, true, false);
+			}
+
+			void Release() {
+				holder.reset();
+			}
+	};
+
+	template <typename T>
+	class RemoteHandle {
+		private:
+			std::shared_ptr<ivm::RemoteHandle<T>> handle;
+
+		public:
+			explicit RemoteHandle(v8::Local<T> handle) : handle(std::make_shared<ivm::RemoteHandle<T>>(handle)) {}
+
+			auto operator*() const {
+				return handle->Deref();
+			}
+
+			void Release() {
+				handle.reset();
+			}
+	};
+} // namespace isolated_vm

package/dist/node_modules/isolated-vm/src/lib/covariant.h

@@ -0,0 +1,50 @@
+#include <type_traits>
+
+namespace detail {
+
+template <class Base, class Type>
+void destructor_wrapper(Base* value) {
+	static_cast<Type*>(value)->~Type();
+}
+
+template <class Type, class Pack, class ...Rest>
+struct contains_type {
+	static constexpr bool value =
+		std::is_same<Type, Pack>::value || contains_type<Type, Rest...>::value;
+};
+
+template <class Type, class Pack>
+struct contains_type<Type, Pack> : std::is_same<Type, Pack> {};
+
+} // namespace detail
+
+template <class Type>
+class in_place {};
+
+template <class Base, class ...Storage>
+class covariant_t {
+	public:
+		template <class Ctor, class ...Args>
+		explicit covariant_t(in_place<Ctor> /*tag*/, Args&&... args) : dtor{&::detail::destructor_wrapper<Base, Ctor>} {
+			static_assert(::detail::contains_type<Ctor, Storage...>::value, "Instantiated constructor must inherit from `Base`");
+			new(&storage) Ctor(std::forward<Args>(args)...);
+		}
+
+		~covariant_t() {
+			dtor(base());
+		}
+
+		covariant_t(const covariant_t&) = delete;
+		auto operator=(const covariant_t&) = delete;
+
+		auto operator*() -> auto& { return *base(); }
+		auto operator*() const -> auto& { return *base(); }
+		auto operator->() { return base(); }
+		auto operator->() const { return base(); }
+
+	private:
+		auto base() { return static_cast<Base*>(static_cast<void*>(&storage)); }
+
+		std::aligned_union_t<1, Storage...> storage;
+		void(*dtor)(Base*);
+};

package/dist/node_modules/isolated-vm/src/lib/lockable.h

@@ -0,0 +1,178 @@
+#pragma once
+#include <condition_variable>
+#include <mutex>
+#include <shared_mutex>
+
+namespace ivm {
+namespace detail {
+
+// C++17 adds mandatory return value optimization which enables returning a scoped_lock
+#if __cplusplus >= 201700 && __cpp_lib_scoped_lock
+	template <class Mutex>
+	using scoped_lock = std::scoped_lock<Mutex>;
+#else
+	template <class Mutex>
+	using scoped_lock = std::unique_lock<Mutex>;
+#endif
+
+// Detect shared mutex implementation (if any)
+template <bool Shared>
+struct mutex_traits_t {
+	using mutex_t = std::mutex;
+	static constexpr bool shared = false;
+};
+
+template <>
+struct mutex_traits_t<true> {
+#if __cpp_lib_shared_mutex
+	using mutex_t = std::shared_mutex;
+	static constexpr bool shared = true;
+#elif __cpp_lib_shared_timed_mutex && !__APPLE__
+	using mutex_t = std::shared_timed_mutex;
+	static constexpr bool shared = true;
+#else
+	using mutex_t = std::mutex;
+	static constexpr bool shared = false;
+#endif
+};
+
+// Detect lock needed for mutex + wait
+template <class Traits, bool Waitable>
+struct lock_traits_t;
+
+template <class Traits>
+struct lock_traits_t<Traits, false> {
+	using read_t = typename std::conditional<Traits::shared,
+		std::shared_lock<typename Traits::mutex_t>,
+		scoped_lock<typename Traits::mutex_t>>::type;
+	using write_t = scoped_lock<typename Traits::mutex_t>;
+};
+
+template <class Traits>
+struct lock_traits_t<Traits, true> {
+	static_assert(Traits::waitable, "Mutex is not waitable");
+	using read_t = typename std::conditional<Traits::shared,
+		std::shared_lock<typename Traits::mutex_t>,
+		std::unique_lock<typename Traits::mutex_t>>::type;
+	using write_t = std::unique_lock<typename Traits::mutex_t>;
+};
+
+// std::condition_variable is only good for std::unique_lock<std::mutex>
+template <class Mutex>
+struct condition_variable_t {
+	using type_t = std::condition_variable_any;
+};
+
+template <>
+struct condition_variable_t<std::mutex> {
+	using type_t = std::condition_variable;
+};
+
+// Holds the lock and provides pointer semantics
+template <class Lockable, class Lock>
+class lock_holder_t {
+	template <bool, class> friend struct wait_impl_t;
+
+	public:
+		explicit lock_holder_t(Lockable& lockable) : lockable{lockable}, lock{lockable.mutex} {}
+
+		auto operator*() -> auto& { return lockable.resource; }
+		auto operator*() const -> auto& { return lockable.resource; }
+		auto operator->() { return &lockable.resource; }
+		auto operator->() const { return &lockable.resource; }
+
+	private:
+		Lockable& lockable;
+		Lock lock;
+};
+
+// `wait` implementation
+template <bool Waitable, class Type>
+struct wait_impl_t;
+
+template <class Type>
+struct wait_impl_t<false, Type> {
+	using lock_t = Type;
+};
+
+template <class Type>
+struct wait_impl_t<true, Type> {
+	class lock_t : public Type {
+		public:
+			using Type::Type;
+			void wait() {
+				wait_impl(*this);
+			}
+	};
+
+	private:
+		template <class Lock>
+		static void wait_impl(Lock& lock) {
+			lock.lockable.cv.wait(lock.lock);
+		}
+};
+
+// Internal `condition_variable` storage
+template <bool Waitable, class Mutex>
+class condition_variable_holder_t {};
+
+template <class Mutex>
+class condition_variable_holder_t<true, Mutex> {
+	template <bool, class> friend struct wait_impl_t;
+
+	public:
+		void notify_one() {
+			cv.notify_one();
+		}
+
+		void notify_all() {
+			cv.notify_all();
+		}
+
+	private:
+		mutable typename condition_variable_t<Mutex>::type_t cv;
+};
+
+// Holds resource and mutex
+template <class Type, class Traits>
+class lockable_impl_t : public condition_variable_holder_t<Traits::waitable, typename Traits::mutex_t> {
+	template <class, class> friend class lock_holder_t;
+
+	public:
+		lockable_impl_t() = default;
+		template <class... Args>
+		explicit lockable_impl_t(Args&&... args) : resource{std::forward<Args>(args)...} {}
+		lockable_impl_t(const lockable_impl_t&) = delete;
+		~lockable_impl_t() = default;
+		auto operator=(const lockable_impl_t&) = delete;
+
+		template <bool Waitable = false>
+		auto read() const {
+			return typename wait_impl_t<Waitable, lock_holder_t<const lockable_impl_t, typename lock_traits_t<Traits, Waitable>::read_t>>::lock_t{*this};
+		}
+
+		template <bool Waitable = false>
+		auto write() {
+			return typename wait_impl_t<Waitable, lock_holder_t<lockable_impl_t, typename lock_traits_t<Traits, Waitable>::write_t>>::lock_t{*this};
+		}
+
+	private:
+		Type resource{};
+		mutable typename Traits::mutex_t mutex;
+};
+
+// Combine mutex traits and waitable traits
+template <bool Waitable>
+struct waitable_traits_t {
+	static constexpr bool waitable = Waitable;
+};
+
+template <bool Shared, bool Waitable>
+struct lockable_traits_t : mutex_traits_t<Shared>, waitable_traits_t<Waitable> {};
+
+} // namespace detail
+
+template <class Type, bool Shared = false, bool Waitable = false>
+using lockable_t = detail::lockable_impl_t<Type, detail::lockable_traits_t<Shared, Waitable>>;
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/lib/suspend.h

@@ -0,0 +1,106 @@
+#pragma once
+
+// Linux
+#ifdef __linux__
+#include <signal.h>
+namespace ivm {
+class thread_suspend_handle {
+	public:
+		thread_suspend_handle() :
+			id{pthread_self()},
+			prev{std::exchange(instance(), this)} {}
+
+		~thread_suspend_handle() {
+			std::exchange(instance(), prev);
+		}
+
+		thread_suspend_handle(const thread_suspend_handle&) = delete;
+		auto operator=(thread_suspend_handle&) = delete;
+
+		void suspend() {
+			// Called from another thread
+			invoked = true;
+			pthread_kill(id, SIGRTMIN);
+		}
+
+		struct initialize {
+			initialize() {
+				// Set process-wide signal handler
+				struct sigaction handler;
+				memset(&handler, '\0', sizeof(handler));
+				handler.sa_handler = callback;
+				sigemptyset(&handler.sa_mask);
+				assert(sigaction(SIGRTMIN, &handler, nullptr) == 0);
+			}
+		};
+
+	private:
+		static void callback(int) {
+			if (instance() != nullptr && instance()->invoked == true) {
+				while (true) {
+					using namespace std::chrono_literals;
+					std::this_thread::sleep_for(100s);
+				}
+			}
+		}
+
+		static thread_suspend_handle*& instance() {
+			static thread_local thread_suspend_handle* instance = nullptr;
+			return instance;
+		}
+
+		pthread_t id;
+		thread_suspend_handle* prev;
+		bool invoked = false;
+};
+} // namespace ivm
+
+// macOS
+#elif __APPLE__
+#include <mach/mach.h>
+namespace ivm {
+class thread_suspend_handle {
+	public:
+		thread_suspend_handle() : id{mach_thread_self()} {}
+		~thread_suspend_handle() = default;
+		thread_suspend_handle(const thread_suspend_handle&) = delete;
+		auto operator=(thread_suspend_handle&) = delete;
+		void suspend() const { thread_suspend(id); }
+		struct initialize {};
+	private:
+		mach_port_t id;
+};
+} // namespace ivm
+
+// Windows
+#elif _WIN32
+#include <processthreadsapi.h>
+namespace ivm {
+class thread_suspend_handle {
+	public:
+		thread_suspend_handle() : id{GetCurrentThread()} {}
+		~thread_suspend_handle() = default;
+		thread_suspend_handle(const thread_suspend_handle&) = delete;
+		auto operator=(thread_suspend_handle&) = delete;
+		void suspend() const { SuspendThread(id); }
+		struct initialize {};
+	private:
+		HANDLE id;
+};
+} // namespace ivm
+
+// Fallback [no-op]
+#else
+namespace ivm {
+class thread_suspend_handle {
+	public:
+		thread_suspend_handle() {}
+		~thread_suspend_handle() = default;
+		thread_suspend_handle(const thread_suspend_handle&) = delete;
+		auto operator=(thread_suspend_handle&) = delete;
+		void suspend() const {}
+		struct initialize {};
+};
+} // namespace ivm
+
+#endif

package/dist/node_modules/isolated-vm/src/lib/thread_pool.cc

@@ -0,0 +1,98 @@
+#include "thread_pool.h"
+#include <functional>
+
+namespace ivm {
+
+void thread_pool_t::exec(affinity_t& affinity, entry_t* entry, void* param) {
+	std::lock_guard<std::mutex> lock{mutex};
+
+	// First try to use an old thread
+	unsigned thread = std::numeric_limits<unsigned>::max();
+	if (affinity.previous < thread_data.size() && thread_data[affinity.previous].entry == nullptr) {
+		thread = affinity.previous;
+	} else {
+		for (auto ii = affinity.ids.begin(); ii != affinity.ids.end(); ) {
+			if (*ii >= thread_data.size()) {
+				ii = affinity.ids.erase(ii);
+				continue;
+			}
+			if (thread_data[*ii].entry == nullptr) {
+				affinity.previous = thread = *ii;
+				break;
+			}
+			++ii;
+		}
+	}
+
+	if (thread == std::numeric_limits<unsigned>::max()) {
+		if (desired_size > thread_data.size()) {
+			// Thread pool hasn't yet reached `desired_size`, so we can make a new thread
+			thread = new_thread(lock);
+			affinity.previous = thread;
+			affinity.ids.insert(thread);
+		} else {
+			// Now try to re-use a non-busy thread
+			size_t offset = rr++;
+			for (size_t ii = 0; ii < thread_data.size(); ++ii) {
+				size_t jj = (rr + ii + offset) % thread_data.size();
+				if (thread_data[jj].entry == nullptr) {
+					thread = jj;
+					affinity.previous = thread;
+					affinity.ids.insert(thread);
+					break;
+				}
+			}
+
+			if (thread == std::numeric_limits<unsigned>::max()) {
+				// All threads are busy and pool is full, just run this in a new thread
+				std::thread tmp_thread{[=]() { entry(false, param); }};
+				tmp_thread.detach();
+				return;
+			}
+		}
+	}
+
+	thread_data[thread].entry = entry;
+	thread_data[thread].param = param;
+	thread_data[thread].cv.notify_one();
+}
+
+void thread_pool_t::resize(size_t size) {
+	std::unique_lock<std::mutex> lock{mutex};
+	desired_size = size;
+	if (thread_data.size() > desired_size) {
+		for (size_t ii = desired_size; ii < thread_data.size(); ++ii) {
+			thread_data[ii].should_exit = true;
+			thread_data[ii].cv.notify_one();
+		}
+		lock.unlock();
+		for (size_t ii = desired_size; ii < thread_data.size(); ++ii) {
+			thread_data[ii].thread.join();
+		}
+		thread_data.resize(desired_size);
+	}
+}
+
+auto thread_pool_t::new_thread(std::lock_guard<std::mutex>& /*lock*/) -> size_t {
+  thread_data.emplace_back();
+	auto& data = thread_data.back();
+  data.thread = std::thread{[this, &data]() {
+    std::unique_lock<std::mutex> lock{mutex};
+    while (!data.should_exit) {
+      if (data.entry == nullptr) {
+        data.cv.wait(lock);
+      } else {
+        entry_t* entry = data.entry;
+        void* param = data.param;
+        lock.unlock();
+        entry(true, param);
+        lock.lock();
+        data.entry = nullptr;
+        data.param = nullptr;
+      }
+    }
+  }};
+	return thread_data.size() - 1;
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/lib/thread_pool.h

@@ -0,0 +1,45 @@
+#pragma once
+#include <condition_variable>
+#include <deque>
+#include <limits>
+#include <mutex>
+#include <thread>
+#include <unordered_set>
+
+namespace ivm {
+
+class thread_pool_t {
+	public:
+		using entry_t = void(bool, void*);
+		class affinity_t {
+			friend thread_pool_t;
+			std::unordered_set<unsigned> ids;
+			unsigned previous = std::numeric_limits<unsigned>::max();
+		};
+
+		explicit thread_pool_t(size_t desired_size) noexcept : desired_size{desired_size} {}
+		thread_pool_t(const thread_pool_t&) = delete;
+		~thread_pool_t() { resize(0); }
+		auto operator= (const thread_pool_t&) = delete;
+
+		void exec(affinity_t& affinity, entry_t* entry, void* param);
+		void resize(size_t size);
+
+	private:
+		auto new_thread(std::lock_guard<std::mutex>& /*lock*/) -> size_t;
+
+		struct thread_data_t {
+			std::thread thread;
+			std::condition_variable cv;
+			entry_t* entry = nullptr;
+			void* param = nullptr;
+			bool should_exit = false;
+		};
+
+		size_t desired_size;
+		size_t rr = 0;
+		std::mutex mutex;
+		std::deque<thread_data_t> thread_data;
+};
+
+} // namespace ivm