fyn 2.0.2 → 2.0.3

package/dist/node_modules_f___p-map_7_0_3_p-map_index_js

@@ -11,143 +11,93 @@ exports.modules = {
 /* harmony export */   "default": () => (/* binding */ pMap)
 /* harmony export */ });
 /* unused harmony exports pMapIterable, pMapSkip */
-function _awaitAsyncGenerator(value) { return new _AwaitValue(value); }
-
-function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; }
-
-function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen.return !== "function") { this.return = undefined; } }
-
-_AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () { return this; };
-
-_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
-
-_AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };
-
-_AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
-
-function _AwaitValue(value) { this.wrapped = value; }
-
 async function pMap(iterable, mapper, {
   concurrency = Number.POSITIVE_INFINITY,
   stopOnError = true,
   signal
 } = {}) {
   return new Promise((resolve_, reject_) => {
-    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    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 (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 = new Map();
+    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] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
-
+    const iterator = iterable[Symbol.iterator] === void 0 ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
     const signalListener = () => {
       reject(signal.reason);
     };
-
     const cleanup = () => {
-      signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', signalListener);
+      signal?.removeEventListener("abort", signalListener);
     };
-
-    const resolve = value => {
+    const resolve = (value) => {
       resolve_(value);
       cleanup();
     };
-
-    const reject = reason => {
+    const reject = (reason) => {
       isRejected = true;
       isResolved = true;
       reject_(reason);
       cleanup();
     };
-
     if (signal) {
       if (signal.aborted) {
         reject(signal.reason);
       }
-
-      signal.addEventListener('abort', signalListener, {
-        once: true
-      });
+      signal.addEventListener("abort", signalListener, { once: true });
     }
-
     const next = async () => {
       if (isResolved) {
         return;
       }
-
       const nextItem = await iterator.next();
       const index = currentIndex;
-      currentIndex++; // Note: `iterator.next()` can be called many times in parallel.
-      // This can cause multiple calls to this `next()` function to
-      // receive a `nextItem` with `done === true`.
-      // The shutdown logic that rejects/resolves must be protected
-      // so it runs only one time as the `skippedIndex` logic is
-      // non-idempotent.
-
+      currentIndex++;
       if (nextItem.done) {
         isIterableDone = true;
-
         if (resolvingCount === 0 && !isResolved) {
           if (!stopOnError && errors.length > 0) {
-            reject(new AggregateError(errors)); // eslint-disable-line unicorn/error-message
-
+            reject(new AggregateError(errors));
             return;
           }
-
           isResolved = true;
-
           if (skippedIndexesMap.size === 0) {
             resolve(result);
             return;
           }
-
-          const pureResult = []; // Support multiple `pMapSkip`'s.
-
-          for (const [index, value] of result.entries()) {
-            if (skippedIndexesMap.get(index) === pMapSkip) {
+          const pureResult = [];
+          for (const [index2, value] of result.entries()) {
+            if (skippedIndexesMap.get(index2) === pMapSkip) {
               continue;
             }
-
             pureResult.push(value);
           }
-
           resolve(pureResult);
         }
-
         return;
       }
-
-      resolvingCount++; // Intentionally detached
-
+      resolvingCount++;
       (async () => {
         try {
           const element = await nextItem.value;
-
           if (isResolved) {
             return;
           }
-
-          const value = await mapper(element, index); // Use Map to stage the index of the element.
-
+          const value = await mapper(element, index);
           if (value === pMapSkip) {
             skippedIndexesMap.set(index, value);
           }
-
           result[index] = value;
           resolvingCount--;
           await next();
@@ -156,37 +106,24 @@ async function pMap(iterable, mapper, {
             reject(error);
           } else {
             errors.push(error);
-            resolvingCount--; // In that case we can't really continue regardless of `stopOnError` state
-            // since an iterable is likely to continue throwing after it throws once.
-            // If we continue calling `next()` indefinitely we will likely end up
-            // in an infinite loop of failed iteration.
-
+            resolvingCount--;
             try {
               await next();
-            } catch (error) {
-              reject(error);
+            } catch (error2) {
+              reject(error2);
             }
           }
         }
       })();
-    }; // Create the concurrent runners in a detached (non-awaited)
-    // promise. We need this so we can await the `next()` calls
-    // to stop creating runners before hitting the concurrency limit
-    // if the iterable has already been marked as done.
-    // NOTE: We *must* do this for async iterators otherwise we'll spin up
-    // infinite `next()` calls by default and never start the event loop.
-
-
+    };
     (async () => {
       for (let index = 0; index < concurrency; index++) {
         try {
-          // eslint-disable-next-line no-await-in-loop
           await next();
         } catch (error) {
           reject(error);
           break;
         }
-
         if (isIterableDone || isRejected) {
           break;
         }
@@ -198,115 +135,75 @@ function pMapIterable(iterable, mapper, {
   concurrency = Number.POSITIVE_INFINITY,
   backpressure = concurrency
 } = {}) {
-  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+  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 (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 _wrapAsyncGenerator(function* () {
-        const iterator = iterable[Symbol.asyncIterator] === undefined ? 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;
+    async *[Symbol.asyncIterator]() {
+      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 () => {
+          const { done, value } = await iterator.next();
+          if (done) {
+            return { done: true };
           }
-
-          const promise = (async () => {
-            const {
-              done,
-              value
-            } = await iterator.next();
-
-            if (done) {
-              return {
-                done: true
-              };
+          runningMappersCount++;
+          trySpawn();
+          try {
+            const returnValue = await mapper(await value, index++);
+            runningMappersCount--;
+            if (returnValue === pMapSkip) {
+              const index2 = promises.indexOf(promise);
+              if (index2 > 0) {
+                promises.splice(index2, 1);
+              }
             }
-
-            runningMappersCount++; // Spawn if still below concurrency and backpressure limit
-
             trySpawn();
-
-            try {
-              const returnValue = await mapper(await value, index++);
-              runningMappersCount--;
-
-              if (returnValue === pMapSkip) {
-                const index = promises.indexOf(promise);
-
-                if (index > 0) {
-                  promises.splice(index, 1);
-                }
-              } // Spawn if still below backpressure limit and just dropped below concurrency limit
-
-
-              trySpawn();
-              return {
-                done: false,
-                value: returnValue
-              };
-            } catch (error) {
-              isDone = true;
-              return {
-                error
-              };
-            }
-          })();
-
-          promises.push(promise);
+            return { done: false, value: returnValue };
+          } catch (error) {
+            isDone = true;
+            return { error };
+          }
+        })();
+        promises.push(promise);
+      }
+      trySpawn();
+      while (promises.length > 0) {
+        const { error, done, value } = await promises[0];
+        promises.shift();
+        if (error) {
+          throw error;
+        }
+        if (done) {
+          return;
         }
-
         trySpawn();
-
-        while (promises.length > 0) {
-          const {
-            error,
-            done,
-            value
-          } = yield _awaitAsyncGenerator(promises[0]); // eslint-disable-line no-await-in-loop
-
-          promises.shift();
-
-          if (error) {
-            throw error;
-          }
-
-          if (done) {
-            return;
-          } // Spawn if just dropped below backpressure limit and below the concurrency limit
-
-
-          trySpawn();
-
-          if (value === pMapSkip) {
-            continue;
-          }
-
-          yield value;
+        if (value === pMapSkip) {
+          continue;
         }
-      })();
+        yield value;
+      }
     }
-
   };
 }
-const pMapSkip = Symbol('skip');
+const pMapSkip = Symbol("skip");
+
 
 /***/ })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fyn",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "fyn is the NPM for fynpo -- a zero setup monorepo tool",
   "main": "./bin/fyn.js",
   "homepage": "https://jchip.github.io/fynpo/",
@@ -10,7 +10,7 @@
     "debug-test": "node --inspect-brk node_modules/.bin/mocha --extension ts,js,tsx,jsx,cjs,mjs -c test/spec",
     "lint": "xrun xarc/lint",
     "compile-yarn": "babel yarn/src --out-dir yarn/lib",
-    "build": "xrun --serial fyn/create-tgz compile-yarn bundle",
+    "build": "tsx node_modules/.bin/xrun --serial fyn/create-tgz compile-yarn bundle",
     "analyze": "ANALYZE_BUNDLE=1 xrun compile-yarn bundle",
     "coverage": "xrun xarc/check",
     "ci:check": "xrun xarc/check",