@nocobase/plugin-workflow-javascript 2.1.0-beta.25 → 2.1.0-beta.27

package/dist/node_modules/isolated-vm/src/isolate/scheduler.cc

@@ -1,191 +0,0 @@
-#include "environment.h"
-#include "executor.h"
-#include "node_wrapper.h"
-#include "scheduler.h"
-#include <memory>
-#include <v8.h>
-#include <utility>
-
-using namespace v8;
-namespace ivm {
-namespace {
-	thread_pool_t thread_pool{std::thread::hardware_concurrency() + 1};
-}
-
-/*
- * Scheduler implementation
- */
-void Scheduler::CancelAsync() {
-	if (async_wait != nullptr) {
-		async_wait->Cancel();
-	}
-}
-
-void Scheduler::DoneRunning() {
-	assert(status == Status::Running);
-	status = Status::Waiting;
-}
-
-void Scheduler::InterruptIsolate() {
-	assert(status == Status::Running);
-	// Since this callback will be called by v8 we can be certain the pointer to `isolate` is still valid
-	env.GetIsolate()->RequestInterrupt([](Isolate* /*isolate_ptr*/, void* env_ptr) {
-		static_cast<IsolateEnvironment*>(env_ptr)->InterruptEntryAsync();
-	}, &env);
-}
-
-void Scheduler::InterruptSyncIsolate() {
-	env.GetIsolate()->RequestInterrupt([](Isolate* /*isolate_ptr*/, void* env_ptr) {
-		static_cast<IsolateEnvironment*>(env_ptr)->InterruptEntrySync();
-	}, &env);
-}
-
-auto Scheduler::WakeIsolate(std::shared_ptr<IsolateEnvironment> isolate_ptr) -> bool {
-	if (status == Status::Waiting) {
-		status = Status::Running;
-		// Move shared reference to this scheduler to ensure the IsolateEnvironment won't be deleted
-		// before a thread picks up this work.
-		assert(!env_ref);
-		env_ref = std::move(isolate_ptr);
-		IncrementUvRef();
-		SendWake();
-		return true;
-	} else {
-		return false;
-	}
-}
-
-auto LockedScheduler::GetForegroundTaskRunner() -> std::shared_ptr<v8::TaskRunner> {
-	return env.GetTaskRunner();
-}
-
-void LockedScheduler::DecrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder) {
-	auto ref = holder->GetIsolate();
-	if (ref) {
-		ref->scheduler->DecrementUvRef();
-	}
-}
-
-void LockedScheduler::IncrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder) {
-	auto ref = holder->GetIsolate();
-	if (ref) {
-		ref->scheduler->IncrementUvRef();
-	}
-}
-
-IsolatedScheduler::IsolatedScheduler(IsolateEnvironment& env, UvScheduler& default_scheduler) :
-	LockedScheduler{env},
-	default_scheduler{default_scheduler} {}
-
-void IsolatedScheduler::DecrementUvRef() {
-	default_scheduler.DecrementUvRef();
-}
-
-void IsolatedScheduler::IncrementUvRef() {
-	default_scheduler.IncrementUvRef();
-}
-
-void IsolatedScheduler::SendWake() {
-	thread_pool.exec(thread_affinity, [](bool pool_thread, void* param) {
-		auto& scheduler = *static_cast<IsolatedScheduler*>(param);
-		auto ref = std::exchange(scheduler.env_ref, {});
-		ref->AsyncEntry();
-		if (!pool_thread) {
-			ref->GetIsolate()->DiscardThreadSpecificMetadata();
-		}
-		// Grab reference to default scheduler, since resetting `ref` may deallocate `scheduler` and
-		// invalidate the instance. Resetting `ref` must take place here because the destructor might
-		// invoke cleanup tasks on the default isolate which will increment `uv_ref_count`.
-		// `uv_ref_count` needs to be incremented before it's decremented otherwise `UvScheduler` will
-		// try to invoke `uv_ref` from a non-default thread.
-		auto& default_scheduler = scheduler.default_scheduler;
-		ref = {};
-		if (--default_scheduler.uv_ref_count == 0) {
-			// Wake up the libuv loop so we can unref the async handle from the default thread.
-			uv_async_send(default_scheduler.uv_async);
-		}
-	}, this);
-}
-
-UvScheduler::UvScheduler(IsolateEnvironment& env) :
-		LockedScheduler{env},
-		loop{node::GetCurrentEventLoop(v8::Isolate::GetCurrent())},
-		uv_async{new uv_async_t} {
-	uv_async_init(loop, uv_async, [](uv_async_t* async) {
-		auto& scheduler = *static_cast<UvScheduler*>(async->data);
-		auto ref = [&]() {
-			// Lock is required to access env_ref on the default scheduler but a non-default scheduler
-			// doesn't need it. This is because `WakeIsolate` can trigger this function via
-			// `uv_async_send` while another thread is writing to `env_ref`
-			std::lock_guard<std::mutex> lock{scheduler.mutex};
-			return std::exchange(scheduler.env_ref, {});
-		}();
-		if (ref) {
-			ref->AsyncEntry();
-			if (--scheduler.uv_ref_count == 0) {
-				uv_unref(reinterpret_cast<uv_handle_t*>(scheduler.uv_async));
-			}
-		} else {
-			if (scheduler.uv_ref_count.load() == 0) {
-				uv_unref(reinterpret_cast<uv_handle_t*>(scheduler.uv_async));
-			}
-		}
-	});
-	uv_async->data = this;
-	uv_unref(reinterpret_cast<uv_handle_t*>(uv_async));
-}
-
-UvScheduler::~UvScheduler() {
-	uv_close(reinterpret_cast<uv_handle_t*>(uv_async), [](uv_handle_t* handle) {
-		delete reinterpret_cast<uv_async_t*>(handle);
-	});
-}
-
-void UvScheduler::DecrementUvRef() {
-	if (--uv_ref_count == 0) {
-		if (Executor::IsDefaultThread()) {
-			uv_unref(reinterpret_cast<uv_handle_t*>(uv_async));
-		} else {
-			uv_async_send(uv_async);
-		}
-	}
-}
-
-void UvScheduler::IncrementUvRef() {
-	if (++uv_ref_count == 1) {
-		// Only the default thread should be able to reach this branch
-		assert(Executor::IsDefaultThread());
-		uv_ref(reinterpret_cast<uv_handle_t*>(uv_async));
-	}
-}
-
-void UvScheduler::SendWake() {
-	uv_async_send(uv_async);
-}
-
-/*
- * Scheduler::AsyncWait implementation
- */
-Scheduler::AsyncWait::~AsyncWait() {
-	scheduler.Lock()->async_wait = nullptr;
-}
-
-void Scheduler::AsyncWait::Cancel() {
-	*state.write() = canceled;
-	state.notify_one();
-}
-
-void Scheduler::AsyncWait::Done() {
-	*state.write() = finished;
-	state.notify_one();
-}
-
-auto Scheduler::AsyncWait::Wait() const -> Scheduler::AsyncWait::State {
-	auto lock = state.read<true>();
-	while (*lock == pending) {
-		lock.wait();
-	}
-	return *lock;
-}
-
-} // namespace ivm

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

@@ -1,165 +0,0 @@
-#pragma once
-#include "platform_delegate.h"
-#include "runnable.h"
-#include "lib/lockable.h"
-#include "lib/thread_pool.h"
-#include <uv.h>
-#include <atomic>
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <queue>
-
-namespace ivm {
-class IsolateEnvironment;
-class IsolateHolder;
-
-// gcc 5's std::queue implementation has an explicit default ctor so std::exchange(..., {})
-// doesn't work. This changed in C++11 and I guess they're behind.
-template <class Type>
-auto ExchangeDefault(Type& container) {
-	return std::exchange(container, Type{});
-}
-
-/**
- * Keeps track of tasks an isolate needs to run and manages its run state (running or waiting).
- * This does all the interaction with libuv async and the thread pool.
- */
-class UvScheduler;
-class Scheduler {
-	friend IsolateEnvironment;
-	friend class LockedScheduler;
-	private:
-		using TaskQueue = std::queue<std::unique_ptr<Runnable>>;
-
-	public:
-		explicit Scheduler(IsolateEnvironment& env) : env{env} {}
-		Scheduler(const Scheduler&) = delete;
-		~Scheduler() = default;
-		auto operator=(const Scheduler&) = delete;
-
-		// Request cancellation of current async task
-		void CancelAsync();
-		// Called after AsyncEntry finishes
-		void DoneRunning();
-		// Request an interrupt in this isolate. `status` must == Running to invoke this.
-		void InterruptIsolate();
-		// Interrupts an isolate running in the default thread
-		void InterruptSyncIsolate();
-		// Returns true if a wake was scheduled, false if the isolate is already running.
-		auto WakeIsolate(std::shared_ptr<IsolateEnvironment> isolate_ptr) -> bool;
-
-		// Scheduler::AsyncWait will pause the current thread until woken up by another thread
-		class AsyncWait {
-			public:
-				enum State { pending, finished, canceled };
-
-				// This is templated so we can cast to the protected base class here instead of at the call
-				// site
-				template <class Type>
-				explicit AsyncWait(Type& scheduler) :
-						scheduler{scheduler} {
-					auto lock = scheduler.Lock();
-					assert(lock->async_wait == nullptr);
-					lock->async_wait = this;
-				}
-				AsyncWait(const AsyncWait&) = delete;
-				~AsyncWait();
-				auto operator=(const AsyncWait&) = delete;
-
-				void Cancel();
-				void Done();
-				auto Wait() const -> State;
-
-				class LockedScheduler& scheduler;
-				lockable_t<State, false, true> state{pending};
-		};
-
-		// Task queues
-		TaskQueue tasks;
-		TaskQueue handle_tasks;
-		TaskQueue interrupts;
-		TaskQueue sync_interrupts;
-
-	protected:
-		mutable std::mutex mutex;
-		mutable std::condition_variable cv;
-		std::shared_ptr<IsolateEnvironment> env_ref;
-		IsolateEnvironment& env;
-
-	private:
-		virtual void IncrementUvRef() = 0;
-		virtual void DecrementUvRef() = 0;
-		virtual void SendWake() = 0;
-
-		enum class Status { Waiting, Running };
-		AsyncWait* async_wait = nullptr;
-		Status status = Status::Waiting;
-};
-
-class LockedScheduler : protected Scheduler, public node::IsolatePlatformDelegate {
-	friend Scheduler::AsyncWait;
-	public:
-		using Scheduler::Scheduler;
-
-		// Locks the scheduler and return a lock with access to public interface
-		auto Lock() {
-			// TODO: Would be nice to find a way to roll this into the lockable abstraction
-			class Lock {
-				public:
-					auto operator*() -> auto& { return scheduler; }
-					auto operator->() { return &scheduler; }
-
-					explicit Lock(Scheduler& scheduler, std::mutex& mutex) :
-						lock{mutex},
-						scheduler{scheduler} {}
-
-				private:
-					std::unique_lock<std::mutex> lock;
-					Scheduler& scheduler;
-			};
-			return Lock{*this, mutex};
-		}
-
-		// IsolatePlatformDelegate overrides
-		auto GetForegroundTaskRunner() -> std::shared_ptr<v8::TaskRunner> final;
-		auto IdleTasksEnabled() -> bool final { return false; }
-
-		// Used to ref/unref the uv handle from C++ API
-		static void DecrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder);
-		static void IncrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder);
-};
-
-class IsolatedScheduler final : public LockedScheduler {
-	public:
-		explicit IsolatedScheduler(IsolateEnvironment& env, UvScheduler& default_scheduler);
-
-	private:
-		void DecrementUvRef() override;
-		void IncrementUvRef() override;
-		void SendWake() override;
-
-		thread_pool_t::affinity_t thread_affinity;
-		UvScheduler& default_scheduler;
-};
-
-class UvScheduler final : public LockedScheduler {
-	friend IsolatedScheduler;
-	friend Scheduler;
-	public:
-		explicit UvScheduler(IsolateEnvironment& env);
-		UvScheduler(const UvScheduler&) = delete;
-		~UvScheduler();
-		auto operator=(const UvScheduler&) = delete;
-
-	private:
-		void DecrementUvRef() override;
-		void IncrementUvRef() override;
-		void SendWake() override;
-
-		uv_loop_t* loop = nullptr;
-		uv_async_t* uv_async = nullptr;
-		std::atomic<int> uv_ref_count{0};
-};
-
-} // namespace ivm

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

@@ -1,35 +0,0 @@
-#pragma once
-#include <v8.h>
-#include <atomic>
-
-namespace ivm {
-namespace detail {
-	extern std::atomic<size_t> IsolateSpecificSize;
-}
-
-/**
- * Like thread_local data, but specific to an Isolate instead.
- */
-template <class Type>
-class IsolateSpecific {
-	template <class>
-	friend class IsolateSpecific;
-
-	public:
-		IsolateSpecific() = default;
-
-		template <class Functor>
-		auto Deref(Functor callback) -> v8::Local<Type>;
-
-	private:
-		size_t key{detail::IsolateSpecificSize++};
-		union HandleConvert {
-			explicit HandleConvert(v8::Local<v8::Data> data) : data{data} {}
-			v8::Local<v8::Data> data;
-			v8::Local<Type> value;
-		};
-};
-
-} // namespace ivm
-
-#include "environment.h"

package/dist/node_modules/isolated-vm/src/isolate/stack_trace.cc

@@ -1,218 +0,0 @@
-#include "stack_trace.h"
-#include "functor_runners.h"
-#include "specific.h"
-#include "v8_version.h"
-#include <cstring>
-#include <sstream>
-#include <string>
-
-using namespace v8;
-
-namespace ivm {
-
-static auto StringConcat(Isolate* isolate, Local<String> left, Local<String> right) -> Local<String> {
-	return String::Concat(isolate, left, right);
-}
-
-/**
- * This returns an object that's like Symbol() in JS but only C++ can see it.
- */
-auto GetPrivateStackSymbol() -> Local<Private> {
-	static IsolateSpecific<Private> holder;
-	return holder.Deref([]() {
-		return Private::New(Isolate::GetCurrent());
-	});
-}
-
-/**
- * Helper which renders to string either a String (pass-through), StackTrace (render), or Array
- * (recursion pair)
- */
-auto RenderErrorStack(Local<Value> data) -> Local<String> {
-	Isolate* isolate = Isolate::GetCurrent();
-	if (data->IsString()) {
-		// Plain string. We need to remove the first line of `stack` to avoid repeating the error
-		// message
-		String::Utf8Value string_value{isolate, data.As<String>()};
-		const char* c_str = *string_value;
-		// If it starts with "    at" then the message has already been removed
-		if (strncmp(c_str, "    at", 6) == 0) {
-			return data.As<String>();
-		}
-		// Find the newline
-		const char* pos = strchr(c_str, '\n');
-		while (pos != nullptr) {
-			if (strncmp(pos + 1, "    at", 6) == 0) {
-				// Found the start of the stack
-				return Unmaybe(String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(pos), NewStringType::kNormal));
-			}
-			pos = strchr(pos + 1, '\n');
-		}
-		// No stack, just a message
-		return String::Empty(isolate);
-
-	} else if (data->IsArray()) {
-		// Array pair
-		Local<Context> context = isolate->GetCurrentContext();
-		Local<Array> array = data.As<Array>();
-		return StringConcat(isolate,
-			StringConcat(isolate,
-				RenderErrorStack(Unmaybe(array->Get(context, 1))),
-				Unmaybe(String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>("\n    at (<isolated-vm boundary>)"), NewStringType::kNormal))
-			),
-			RenderErrorStack(Unmaybe(array->Get(context, 0)))
-		);
-	} else {
-		// StackTraceHolder
-		StackTraceHolder& that = *ClassHandle::Unwrap<StackTraceHolder>(data.As<Object>());
-		Local<StackTrace> stack_trace = Deref(that.stack_trace);
-		return Unmaybe(String::NewFromUtf8(isolate, StackTraceHolder::RenderSingleStack(stack_trace).c_str(), NewStringType::kNormal));
-	}
-}
-
-/**
- * Accessor on error `stack`. Renders from previously saved stack trace.
- */
-void ErrorStackGetter(Local<Name> /*property*/, const PropertyCallbackInfo<Value>& info) {
-	FunctorRunners::RunCallback(info, [ &info ]() {
-		Isolate* isolate = Isolate::GetCurrent();
-		Local<Context> context = isolate->GetCurrentContext();
-		Local<Object> holder = info.This();
-		Local<Value> name = Unmaybe(holder->Get(context, StringTable::Get().name));
-		if (!name->IsString()) {
-			name = holder->GetConstructorName();
-		}
-		return StringConcat(isolate,
-			StringConcat(isolate, name.As<String>(), StringTable::Get().colonSpace),
-			StringConcat(isolate,
-				Unmaybe(
-					Unmaybe(info.This()->Get(context, StringTable::Get().message))->ToString(context)
-				),
-				RenderErrorStack(Unmaybe(holder->GetPrivate(context, GetPrivateStackSymbol())))
-			)
-		);
-	});
-}
-
-/**
- * Utility function which sets the stack getter on an error object
- */
-void AttachStackGetter(Local<Object> error, Local<Value> data) {
-	Local<Context> context = Isolate::GetCurrent()->GetCurrentContext();
-	Unmaybe(error->SetPrivate(context, GetPrivateStackSymbol(), data));
-	Unmaybe(error->SetNativeDataProperty(
-		context,
-		StringTable::Get().stack,
-		ErrorStackGetter, nullptr,
-		Local<Value>(),
-		PropertyAttribute::DontEnum
-	));
-}
-
-/**
- * StackTraceHolder implementation
- */
-StackTraceHolder::StackTraceHolder(Local<StackTrace> stack_handle) : stack_trace(Isolate::GetCurrent(), stack_handle) {}
-
-auto StackTraceHolder::Definition() -> Local<FunctionTemplate> {
-	return MakeClass("StackTraceHolder", nullptr);
-}
-
-void StackTraceHolder::AttachStack(Local<Object> error, Local<StackTrace> stack) {
-	AttachStackGetter(error, ClassHandle::NewInstance<StackTraceHolder>(stack));
-}
-
-void StackTraceHolder::ChainStack(Local<Object> error, Local<StackTrace> stack) {
-	Isolate* isolate = Isolate::GetCurrent();
-	Local<Context> context = isolate->GetCurrentContext();
-	Local<Value> existing_data = Unmaybe(error->GetPrivate(context, GetPrivateStackSymbol()));
-	if (existing_data->IsUndefined()) {
-		// This error has not passed through ivm yet. Get the existing stack trace.
-		Local<StackTrace> existing_stack = Exception::GetStackTrace(error);
-		if (existing_stack.IsEmpty()) {
-			// In this case it's probably passed through ExternalCopy which flattens the `stack` property
-			// into a plain value
-			existing_data = Unmaybe(error->Get(context, StringTable::Get().stack));
-			if (existing_data->IsUndefined() || !existing_data->IsString()) {
-				return AttachStack(error, stack);
-			}
-		} else {
-			existing_data = ClassHandle::NewInstance<StackTraceHolder>(existing_stack);
-		}
-	}
-	Local<Array> pair = Array::New(isolate, 2);
-	Unmaybe(pair->Set(context, 0, ClassHandle::NewInstance<StackTraceHolder>(stack)));
-	Unmaybe(pair->Set(context, 1, existing_data));
-	AttachStackGetter(error, pair);
-}
-
-auto StackTraceHolder::RenderSingleStack(Local<StackTrace> stack_trace) -> std::string {
-	Isolate* isolate = Isolate::GetCurrent();
-	std::stringstream ss;
-	int size = stack_trace->GetFrameCount();
-	for (int ii = 0; ii < size; ++ii) {
-		Local<StackFrame> frame = stack_trace->GetFrame(isolate, ii);
-		ss <<"\n    at ";
-		String::Utf8Value fn_name{isolate, frame->GetFunctionName()};
-		if (frame->IsWasm()) {
-			String::Utf8Value script_name{isolate, frame->GetScriptName()};
-			bool has_name = fn_name.length() != 0 || script_name.length() != 0;
-			if (has_name) {
-				if (script_name.length() == 0) {
-					ss <<*fn_name;
-				} else {
-					ss <<*script_name;
-					if (fn_name.length() != 0) {
-						ss <<"." <<*fn_name;
-					}
-				}
-				ss <<" (<WASM>";
-			}
-			ss <<frame->GetLineNumber() <<":" <<frame->GetColumn();
-			if (has_name) {
-				ss <<")";
-			}
-		} else {
-			if (frame->IsConstructor()) {
-				ss <<"new ";
-				if (fn_name.length() == 0) {
-					ss <<"<anonymous>";
-				} else {
-					ss <<*fn_name;
-				}
-			} else if (fn_name.length() != 0) {
-				ss <<*fn_name;
-			} else {
-				AppendFileLocation(isolate, frame, ss);
-				return ss.str();
-			}
-			ss <<" (";
-			AppendFileLocation(isolate, frame, ss);
-			ss <<")";
-		}
-	}
-	return ss.str();
-}
-
-void StackTraceHolder::AppendFileLocation(Isolate* /*isolate*/, Local<StackFrame> frame, std::stringstream& ss) {
-	String::Utf8Value script_name{Isolate::GetCurrent(), frame->GetScriptNameOrSourceURL()};
-	if (script_name.length() == 0) {
-		if (frame->IsEval()) {
-			ss <<"[eval]";
-		} else {
-			ss <<"<anonymous>";
-		}
-	} else {
-		ss <<*script_name;
-	}
-	int line_number = frame->GetLineNumber();
-	if (line_number != -1) {
-		ss <<":" <<line_number;
-		int column = frame->GetColumn();
-		if (column != -1) {
-			ss <<":" <<column;
-		}
-	}
-}
-
-} // namespace ivm

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

@@ -1,24 +0,0 @@
-#pragma once
-#include <v8.h>
-#include "class_handle.h"
-#include <string>
-
-namespace ivm {
-
-/**
- * v8::StackTrace doesn't inherit from v8::Value so it can't be set as a property of an object which
- * is what we need to do to pass stack traces in an efficent way.  So this gets around that.
- */
-class StackTraceHolder : public ClassHandle {
-	private:
-		static void AppendFileLocation(v8::Isolate* isolate, v8::Local<v8::StackFrame> frame, std::stringstream& ss);
-	public:
-		v8::Global<v8::StackTrace> stack_trace;
-		explicit StackTraceHolder(v8::Local<v8::StackTrace> stack_handle);
-		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
-		static void AttachStack(v8::Local<v8::Object> error, v8::Local<v8::StackTrace> stack);
-		static void ChainStack(v8::Local<v8::Object> error, v8::Local<v8::StackTrace> stack);
-		static auto RenderSingleStack(v8::Local<v8::StackTrace> stack_trace) -> std::string;
-};
-
-} // namespace ivm