|
var __defProp = Object.defineProperty; |
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
|
var __getOwnPropNames = Object.getOwnPropertyNames; |
|
var __hasOwnProp = Object.prototype.hasOwnProperty; |
|
var __export = (target, all) => { |
|
for (var name in all) |
|
__defProp(target, name, { get: all[name], enumerable: true }); |
|
}; |
|
var __copyProps = (to, from, except, desc) => { |
|
if (from && typeof from === "object" || typeof from === "function") { |
|
for (let key of __getOwnPropNames(from)) |
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
} |
|
return to; |
|
}; |
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
|
|
|
|
|
var src_exports = {}; |
|
__export(src_exports, { |
|
DeferredPromise: () => DeferredPromise, |
|
createDeferredExecutor: () => createDeferredExecutor |
|
}); |
|
module.exports = __toCommonJS(src_exports); |
|
|
|
|
|
function createDeferredExecutor() { |
|
const executor = (resolve, reject) => { |
|
executor.state = "pending"; |
|
executor.resolve = (data) => { |
|
if (executor.state !== "pending") { |
|
return; |
|
} |
|
executor.result = data; |
|
const onFulfilled = (value) => { |
|
executor.state = "fulfilled"; |
|
return value; |
|
}; |
|
return resolve( |
|
data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled) |
|
); |
|
}; |
|
executor.reject = (reason) => { |
|
if (executor.state !== "pending") { |
|
return; |
|
} |
|
queueMicrotask(() => { |
|
executor.state = "rejected"; |
|
}); |
|
return reject(executor.rejectionReason = reason); |
|
}; |
|
}; |
|
return executor; |
|
} |
|
|
|
|
|
var DeferredPromise = class extends Promise { |
|
#executor; |
|
resolve; |
|
reject; |
|
constructor(executor = null) { |
|
const deferredExecutor = createDeferredExecutor(); |
|
super((originalResolve, originalReject) => { |
|
deferredExecutor(originalResolve, originalReject); |
|
executor?.(deferredExecutor.resolve, deferredExecutor.reject); |
|
}); |
|
this.#executor = deferredExecutor; |
|
this.resolve = this.#executor.resolve; |
|
this.reject = this.#executor.reject; |
|
} |
|
get state() { |
|
return this.#executor.state; |
|
} |
|
get rejectionReason() { |
|
return this.#executor.rejectionReason; |
|
} |
|
then(onFulfilled, onRejected) { |
|
return this.#decorate(super.then(onFulfilled, onRejected)); |
|
} |
|
catch(onRejected) { |
|
return this.#decorate(super.catch(onRejected)); |
|
} |
|
finally(onfinally) { |
|
return this.#decorate(super.finally(onfinally)); |
|
} |
|
#decorate(promise) { |
|
return Object.defineProperties(promise, { |
|
resolve: { configurable: true, value: this.resolve }, |
|
reject: { configurable: true, value: this.reject } |
|
}); |
|
} |
|
}; |
|
|
|
0 && (module.exports = { |
|
DeferredPromise, |
|
createDeferredExecutor |
|
}); |
|
|