@wener/utils 1.1.19 → 1.1.20

package/lib/asyncs/firstOfAsyncIterator.js

@@ -0,0 +1,13 @@
+import { isPromise } from './isPromise.js';
+import { nextOfAsyncIterator } from './nextOfAsyncIterator.js';
+
+function firstOfAsyncIterator(it) {
+  const next = nextOfAsyncIterator(it);
+  if (isPromise(next)) {
+    return next.then((v) => v[0]);
+  }
+  return next[0];
+}
+
+export { firstOfAsyncIterator };
+//# sourceMappingURL=firstOfAsyncIterator.js.map

package/lib/asyncs/firstOfAsyncIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firstOfAsyncIterator.js","sources":["../../src/asyncs/firstOfAsyncIterator.ts"],"sourcesContent":["import { MaybePromise } from './MaybePromise';\nimport { isPromise } from './isPromise';\nimport { nextOfAsyncIterator } from './nextOfAsyncIterator';\n\nexport function firstOfAsyncIterator<T>(it: MaybePromise<AsyncIterator<T> | Iterator<T> | T>): MaybePromise<T> {\n  const next = nextOfAsyncIterator(it);\n  if (isPromise(next)) {\n    return next.then((v) => v[0]);\n  }\n  return next[0];\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,qBAAwB,EAAuE,EAAA;AAC7G,EAAM,MAAA,IAAA,GAAO,oBAAoB,EAAE,CAAA,CAAA;AACnC,EAAI,IAAA,SAAA,CAAU,IAAI,CAAG,EAAA;AACnB,IAAA,OAAO,KAAK,IAAK,CAAA,CAAC,CAAM,KAAA,CAAA,CAAE,CAAC,CAAC,CAAA,CAAA;AAAA,GAC9B;AACA,EAAA,OAAO,KAAK,CAAC,CAAA,CAAA;AACf;;;;"}

package/lib/asyncs/isIterator.js

@@ -0,0 +1,6 @@
+function isIterator(it) {
+  return typeof (it == null ? void 0 : it.next) === "function";
+}
+
+export { isIterator };
+//# sourceMappingURL=isIterator.js.map

package/lib/asyncs/isIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIterator.js","sources":["../../src/asyncs/isIterator.ts"],"sourcesContent":["export function isIterator<T>(it: any): it is Iterator<T> | AsyncIterator<T> {\n  return typeof it?.next === 'function';\n}\n"],"names":[],"mappings":"AAAO,SAAS,WAAc,EAA+C,EAAA;AAC3E,EAAO,OAAA,QAAO,yBAAI,IAAS,CAAA,KAAA,UAAA,CAAA;AAC7B;;;;"}

package/lib/asyncs/nextOfAsyncIterator.js

@@ -0,0 +1,19 @@
+import { isIterator } from './isIterator.js';
+import { isPromise } from './isPromise.js';
+
+function nextOfAsyncIterator(it) {
+  if (isPromise(it)) {
+    return it.then((v) => nextOfAsyncIterator(v));
+  }
+  if (isIterator(it)) {
+    let next = it.next();
+    if (isPromise(next)) {
+      return next.then((v) => [v.value, v.done]);
+    }
+    return [next.value, next.done];
+  }
+  return [it];
+}
+
+export { nextOfAsyncIterator };
+//# sourceMappingURL=nextOfAsyncIterator.js.map

package/lib/asyncs/nextOfAsyncIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextOfAsyncIterator.js","sources":["../../src/asyncs/nextOfAsyncIterator.ts"],"sourcesContent":["import { MaybePromise } from './MaybePromise';\nimport { isIterator } from './isIterator';\nimport { isPromise } from './isPromise';\n\nexport function nextOfAsyncIterator<T>(\n  it: MaybePromise<AsyncIterator<T> | Iterator<T> | T>,\n): MaybePromise<[value: T, done?: boolean]> {\n  if (isPromise(it)) {\n    return it.then((v) => nextOfAsyncIterator(v));\n  }\n  if (isIterator(it)) {\n    let next = it.next();\n    if (isPromise(next)) {\n      return next.then((v) => [v.value, v.done]);\n    }\n    return [next.value, next.done];\n  }\n  return [it];\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,oBACd,EAC0C,EAAA;AAC1C,EAAI,IAAA,SAAA,CAAU,EAAE,CAAG,EAAA;AACjB,IAAA,OAAO,GAAG,IAAK,CAAA,CAAC,CAAM,KAAA,mBAAA,CAAoB,CAAC,CAAC,CAAA,CAAA;AAAA,GAC9C;AACA,EAAI,IAAA,UAAA,CAAW,EAAE,CAAG,EAAA;AAClB,IAAI,IAAA,IAAA,GAAO,GAAG,IAAK,EAAA,CAAA;AACnB,IAAI,IAAA,SAAA,CAAU,IAAI,CAAG,EAAA;AACnB,MAAO,OAAA,IAAA,CAAK,KAAK,CAAC,CAAA,KAAM,CAAC,CAAE,CAAA,KAAA,EAAO,CAAE,CAAA,IAAI,CAAC,CAAA,CAAA;AAAA,KAC3C;AACA,IAAA,OAAO,CAAC,IAAA,CAAK,KAAO,EAAA,IAAA,CAAK,IAAI,CAAA,CAAA;AAAA,GAC/B;AACA,EAAA,OAAO,CAAC,EAAE,CAAA,CAAA;AACZ;;;;"}

package/lib/index.js

@@ -7,6 +7,8 @@ export { merge } from './objects/merge/merge.js';
 export { createLazyPromise } from './asyncs/createLazyPromise.js';
 export { clearAsyncInterval, setAsyncInterval } from './asyncs/AsyncInterval.js';
 export { createAsyncIterator } from './asyncs/createAsyncIterator.js';
+export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator.js';
+export { isIterator } from './asyncs/isIterator.js';
 export { sleep } from './asyncs/sleep.js';
 export { TimeoutError, timeout } from './asyncs/timeout.js';
 export { isPromise } from './asyncs/isPromise.js';
@@ -54,4 +56,5 @@ export { createFetchWithLogging } from './fetch/createFetchWithLogging.js';
 export { dumpRequest } from './fetch/dumpRequest.js';
 export { dumpResponse } from './fetch/dumpResponse.js';
 export { default as ms } from './libs/ms.js';
+export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator.js';
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {

package/src/asyncs/firstOfAsyncIterator.ts

@@ -0,0 +1,11 @@
+import { MaybePromise } from './MaybePromise';
+import { isPromise } from './isPromise';
+import { nextOfAsyncIterator } from './nextOfAsyncIterator';
+
+export function firstOfAsyncIterator<T>(it: MaybePromise<AsyncIterator<T> | Iterator<T> | T>): MaybePromise<T> {
+  const next = nextOfAsyncIterator(it);
+  if (isPromise(next)) {
+    return next.then((v) => v[0]);
+  }
+  return next[0];
+}

package/src/asyncs/isIterator.ts

@@ -0,0 +1,3 @@
+export function isIterator<T>(it: any): it is Iterator<T> | AsyncIterator<T> {
+  return typeof it?.next === 'function';
+}

package/src/asyncs/nextOfAsyncIterator.ts

@@ -0,0 +1,19 @@
+import { MaybePromise } from './MaybePromise';
+import { isIterator } from './isIterator';
+import { isPromise } from './isPromise';
+
+export function nextOfAsyncIterator<T>(
+  it: MaybePromise<AsyncIterator<T> | Iterator<T> | T>,
+): MaybePromise<[value: T, done?: boolean]> {
+  if (isPromise(it)) {
+    return it.then((v) => nextOfAsyncIterator(v));
+  }
+  if (isIterator(it)) {
+    let next = it.next();
+    if (isPromise(next)) {
+      return next.then((v) => [v.value, v.done]);
+    }
+    return [next.value, next.done];
+  }
+  return [it];
+}

package/src/index.ts

@@ -19,6 +19,8 @@ export { createLazyPromise, type LazyPromise } from './asyncs/createLazyPromise'
 export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';
 export { type MaybePromise } from './asyncs/MaybePromise';
 export { createAsyncIterator } from './asyncs/createAsyncIterator';
+export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator';
+export { isIterator } from './asyncs/isIterator';
 
 export { sleep } from './asyncs/sleep';
 export { timeout, TimeoutError } from './asyncs/timeout';
@@ -94,3 +96,4 @@ export { type FetchLike, createFetchWith, createFetchWithLogging, dumpResponse,
 
 // bundled
 export { default as ms } from './libs/ms';
+export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator';