fyn 1.1.46 → 2.0.0

package/dist/node_modules_f___cacache_20_0_1_cacache_node_modules_f___p-map_7_0_3_p-map_index_js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+"use strict";
+exports.id = "node_modules_f___cacache_20_0_1_cacache_node_modules_f___p-map_7_0_3_p-map_index_js";
+exports.ids = ["node_modules_f___cacache_20_0_1_cacache_node_modules_f___p-map_7_0_3_p-map_index_js"];
+exports.modules = {
+
+/***/ "./node_modules/.f/_/cacache/20.0.1/cacache/node_modules/.f/_/p-map/7.0.3/p-map/index.js":
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* 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) {
+      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 = 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 signalListener = () => {
+      reject(signal.reason);
+    };
+
+    const cleanup = () => {
+      signal === null || signal === void 0 ? 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 () => {
+      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.
+
+      if (nextItem.done) {
+        isIterableDone = true;
+
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors)); // eslint-disable-line unicorn/error-message
+
+            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) {
+              continue;
+            }
+
+            pureResult.push(value);
+          }
+
+          resolve(pureResult);
+        }
+
+        return;
+      }
+
+      resolvingCount++; // Intentionally detached
+
+      (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.
+
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value);
+          }
+
+          result[index] = value;
+          resolvingCount--;
+          await next();
+        } catch (error) {
+          if (stopOnError) {
+            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.
+
+            try {
+              await next();
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      })();
+    }; // 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;
+        }
+      }
+    })();
+  });
+}
+function pMapIterable(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  backpressure = concurrency
+} = {}) {
+  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    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 _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;
+          }
+
+          const promise = (async () => {
+            const {
+              done,
+              value
+            } = await iterator.next();
+
+            if (done) {
+              return {
+                done: true
+              };
+            }
+
+            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);
+        }
+
+        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;
+        }
+      })();
+    }
+
+  };
+}
+const pMapSkip = Symbol('skip');
+
+/***/ })
+
+};
+;

package/dist/node_modules_f___p-map_7_0_3_p-map_index_js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+"use strict";
+exports.id = "node_modules_f___p-map_7_0_3_p-map_index_js";
+exports.ids = ["node_modules_f___p-map_7_0_3_p-map_index_js"];
+exports.modules = {
+
+/***/ "./node_modules/.f/_/p-map/7.0.3/p-map/index.js":
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* 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) {
+      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 = 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 signalListener = () => {
+      reject(signal.reason);
+    };
+
+    const cleanup = () => {
+      signal === null || signal === void 0 ? 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 () => {
+      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.
+
+      if (nextItem.done) {
+        isIterableDone = true;
+
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors)); // eslint-disable-line unicorn/error-message
+
+            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) {
+              continue;
+            }
+
+            pureResult.push(value);
+          }
+
+          resolve(pureResult);
+        }
+
+        return;
+      }
+
+      resolvingCount++; // Intentionally detached
+
+      (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.
+
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value);
+          }
+
+          result[index] = value;
+          resolvingCount--;
+          await next();
+        } catch (error) {
+          if (stopOnError) {
+            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.
+
+            try {
+              await next();
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      })();
+    }; // 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;
+        }
+      }
+    })();
+  });
+}
+function pMapIterable(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  backpressure = concurrency
+} = {}) {
+  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    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 _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;
+          }
+
+          const promise = (async () => {
+            const {
+              done,
+              value
+            } = await iterator.next();
+
+            if (done) {
+              return {
+                done: true
+              };
+            }
+
+            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);
+        }
+
+        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;
+        }
+      })();
+    }
+
+  };
+}
+const pMapSkip = Symbol('skip');
+
+/***/ })
+
+};
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fyn",
-  "version": "1.1.46",
+  "version": "2.0.0",
   "description": "fyn is the NPM for fynpo -- a zero setup monorepo tool",
   "main": "./bin/fyn.js",
   "homepage": "https://jchip.github.io/fynpo/",
@@ -10,14 +10,18 @@
     "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 .setup-gyp fyn/create-tgz compile-yarn bundle",
+    "build": "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",
     "coveralls": "cat coverage/lcov.info | coveralls",
     "prepublishOnly": "xrun build",
     "postpack": "publish-util-postpack",
-    "blah": "exit 5"
+    "blah": "exit 5",
+    "test-npm-a": "npm run test-npm-b",
+    "test-npm-b": "env",
+    "hello1": "npm run hello -- from npm",
+    "hello": "echo hello"
   },
   "bin": {
     "0-npx-please-run-this-for-fyn": "./bin/fyn.js",
@@ -27,15 +31,13 @@
   "author": "Walmart GTP.js Team and Contributors",
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.com/"
+    "registry": "https://registry.npmjs.com/",
+    "tag": "v2"
   },
   "files": [
     "bin",
     "dist",
-    "gyp",
-    "src",
-    "node-gyp-bin",
-    "addon.gypi"
+    "src"
   ],
   "keywords": [
     "node",
@@ -73,11 +75,9 @@
     "Divya Karippath"
   ],
   "engines": {
-    "node": ">=8"
+    "node": ">=14.14"
   },
   "opfs": {
-    "mkdirp": true,
-    "rimraf": true,
     "bluebird": true
   }
 }