// Used by C++ to call all init() callbacks. Because some state can be setup

// from C++ there's no need to perform all the same operations as in

// emitInitScript.

function emitInitNative(asyncId, type, triggerAsyncId, resource) {

function emitInitNative(asyncId, type, triggerAsyncId, resource, isPromiseHook) {

active_hooks.call_depth += 1;

resource = lookupPublicResource(resource);

// Use a single try/catch for all hooks to avoid setting up one per iteration.

// eslint-disable-next-line no-var

for (var i = 0; i < active_hooks.array.length; i++) {

if (typeof active_hooks.array[i][init_symbol] === 'function') {

if (isPromiseHook &&

active_hooks.array[i][kNoPromiseHook]) {

continue;

}

active_hooks.array[i][init_symbol](

asyncId, type, triggerAsyncId,

resource,

// Called from native. The asyncId stack handling is taken care of there

// before this is called.

function emitHook(symbol, asyncId) {

function emitHook(symbol, asyncId, isPromiseHook) {

active_hooks.call_depth += 1;

// Use a single try/catch for all hook to avoid setting up one per

// iteration.

// eslint-disable-next-line no-var

for (var i = 0; i < active_hooks.array.length; i++) {

if (typeof active_hooks.array[i][symbol] === 'function') {

if (isPromiseHook &&

active_hooks.array[i][kNoPromiseHook]) {

continue;

}

active_hooks.array[i][symbol](asyncId);

}

}

trackPromise(promise, parent);

const asyncId = promise[async_id_symbol];

const triggerAsyncId = promise[trigger_async_id_symbol];

emitInitScript(asyncId, 'PROMISE', triggerAsyncId, promise);

emitInitScript(asyncId, 'PROMISE', triggerAsyncId, promise, true);

}

function promiseInitHookWithDestroyTracking(promise, parent) {

trackPromise(promise);

const asyncId = promise[async_id_symbol];

const triggerId = promise[trigger_async_id_symbol];

emitBeforeScript(asyncId, triggerId, promise);

emitBeforeScript(asyncId, triggerId, promise, true);

}

function promiseAfterHook(promise) {

trackPromise(promise);

const asyncId = promise[async_id_symbol];

if (hasHooks(kAfter)) {

emitAfterNative(asyncId);

emitAfterNative(asyncId, true);

}

if (asyncId === executionAsyncId()) {

// This condition might not be true if async_hooks was enabled during

function promiseResolveHook(promise) {

trackPromise(promise);

const asyncId = promise[async_id_symbol];

emitPromiseResolveNative(asyncId);

emitPromiseResolveNative(asyncId, true);

}

let wantPromiseHook = false;

}

function emitInitScript(asyncId, type, triggerAsyncId, resource) {

function emitInitScript(asyncId, type, triggerAsyncId, resource, isPromiseHook = false) {

// Short circuit all checks for the common case. Which is that no hooks have

// been set. Do this to remove performance impact for embedders (and core).

if (!hasHooks(kInit))

triggerAsyncId = getDefaultTriggerAsyncId();

}

emitInitNative(asyncId, type, triggerAsyncId, resource);

emitInitNative(asyncId, type, triggerAsyncId, resource, isPromiseHook);

}

function emitBeforeScript(asyncId, triggerAsyncId, resource) {

function emitBeforeScript(asyncId, triggerAsyncId, resource, isPromiseHook = false) {

pushAsyncContext(asyncId, triggerAsyncId, resource);

if (hasHooks(kBefore))

emitBeforeNative(asyncId);

emitBeforeNative(asyncId, isPromiseHook);

}