botbuilder-azure
Version:
Azure extensions for Microsoft BotBuilder.
264 lines (263 loc) • 9.4 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
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 __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
var __await = function(promise, isYieldStar) {
this[0] = promise;
this[1] = isYieldStar;
};
var __asyncGenerator = (__this, __arguments, generator) => {
var resume = (k, v, yes, no) => {
try {
var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
} catch (e) {
no(e);
}
}, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
};
// node_modules/p-map/index.js
var index_exports = {};
__export(index_exports, {
default: () => pMap,
pMapIterable: () => pMapIterable,
pMapSkip: () => pMapSkip
});
module.exports = __toCommonJS(index_exports);
function pMap(_0, _1) {
return __async(this, arguments, function* (iterable, mapper, {
concurrency = Number.POSITIVE_INFINITY,
stopOnError = true,
signal
} = {}) {
return new Promise((resolve_, reject_) => {
if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) {
throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
}
if (typeof mapper !== "function") {
throw new TypeError("Mapper function is required");
}
if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
}
const result = [];
const errors = [];
const skippedIndexesMap = /* @__PURE__ */ new Map();
let isRejected = false;
let isResolved = false;
let isIterableDone = false;
let resolvingCount = 0;
let currentIndex = 0;
const iterator = iterable[Symbol.iterator] === void 0 ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
const signalListener = () => {
reject(signal.reason);
};
const cleanup = () => {
signal == null ? void 0 : signal.removeEventListener("abort", signalListener);
};
const resolve = (value) => {
resolve_(value);
cleanup();
};
const reject = (reason) => {
isRejected = true;
isResolved = true;
reject_(reason);
cleanup();
};
if (signal) {
if (signal.aborted) {
reject(signal.reason);
}
signal.addEventListener("abort", signalListener, { once: true });
}
const next = () => __async(this, null, function* () {
if (isResolved) {
return;
}
const nextItem = yield iterator.next();
const index = currentIndex;
currentIndex++;
if (nextItem.done) {
isIterableDone = true;
if (resolvingCount === 0 && !isResolved) {
if (!stopOnError && errors.length > 0) {
reject(new AggregateError(errors));
return;
}
isResolved = true;
if (skippedIndexesMap.size === 0) {
resolve(result);
return;
}
const pureResult = [];
for (const [index2, value] of result.entries()) {
if (skippedIndexesMap.get(index2) === pMapSkip) {
continue;
}
pureResult.push(value);
}
resolve(pureResult);
}
return;
}
resolvingCount++;
(() => __async(this, null, function* () {
try {
const element = yield nextItem.value;
if (isResolved) {
return;
}
const value = yield mapper(element, index);
if (value === pMapSkip) {
skippedIndexesMap.set(index, value);
}
result[index] = value;
resolvingCount--;
yield next();
} catch (error) {
if (stopOnError) {
reject(error);
} else {
errors.push(error);
resolvingCount--;
try {
yield next();
} catch (error2) {
reject(error2);
}
}
}
}))();
});
(() => __async(this, null, function* () {
for (let index = 0; index < concurrency; index++) {
try {
yield next();
} catch (error) {
reject(error);
break;
}
if (isIterableDone || isRejected) {
break;
}
}
}))();
});
});
}
function pMapIterable(iterable, mapper, {
concurrency = Number.POSITIVE_INFINITY,
backpressure = concurrency
} = {}) {
if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) {
throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
}
if (typeof mapper !== "function") {
throw new TypeError("Mapper function is required");
}
if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
}
if (!(Number.isSafeInteger(backpressure) && backpressure >= concurrency || backpressure === Number.POSITIVE_INFINITY)) {
throw new TypeError(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`);
}
return {
[Symbol.asyncIterator]() {
return __asyncGenerator(this, null, function* () {
const iterator = iterable[Symbol.asyncIterator] === void 0 ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
const promises = [];
let runningMappersCount = 0;
let isDone = false;
let index = 0;
function trySpawn() {
if (isDone || !(runningMappersCount < concurrency && promises.length < backpressure)) {
return;
}
const promise = (() => __async(this, null, function* () {
const { done, value } = yield iterator.next();
if (done) {
return { done: true };
}
runningMappersCount++;
trySpawn();
try {
const returnValue = yield mapper(yield value, index++);
runningMappersCount--;
if (returnValue === pMapSkip) {
const index2 = promises.indexOf(promise);
if (index2 > 0) {
promises.splice(index2, 1);
}
}
trySpawn();
return { done: false, value: returnValue };
} catch (error) {
isDone = true;
return { error };
}
}))();
promises.push(promise);
}
trySpawn();
while (promises.length > 0) {
const { error, done, value } = yield new __await(promises[0]);
promises.shift();
if (error) {
throw error;
}
if (done) {
return;
}
trySpawn();
if (value === pMapSkip) {
continue;
}
yield value;
}
});
}
};
}
var pMapSkip = Symbol("skip");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
pMapIterable,
pMapSkip
});
//# sourceMappingURL=index.js.map