@naturalcycles/js-lib 15.31.0 → 15.33.0

package/dist/iter/asyncIterable2.d.ts

@@ -1,4 +1,4 @@
-import type { AbortableAsyncMapper, AbortableAsyncPredicate, Promisable } from '../types.js';
+import type { AbortableAsyncMapper, AbortableAsyncPredicate, AbortableMapper, AbortablePredicate, Promisable } from '../types.js';
 import { END } from '../types.js';
 /**
  * Similar to Iterable2, but for AsyncIterable.
@@ -20,8 +20,13 @@ export declare class AsyncIterable2<T> implements AsyncIterable<T> {
     toArray(): Promise<T[]>;
     forEach(cb: (v: T, i: number) => Promisable<any | typeof END>): Promise<void>;
     some(cb: AbortableAsyncPredicate<T>): Promise<boolean>;
+    someSync(cb: AbortablePredicate<T>): Promise<boolean>;
     every(cb: AbortableAsyncPredicate<T>): Promise<boolean>;
+    everySync(cb: AbortablePredicate<T>): Promise<boolean>;
     find(cb: AbortableAsyncPredicate<T>): Promise<T | undefined>;
+    findSync(cb: AbortablePredicate<T>): Promise<T | undefined>;
     filter(cb: AbortableAsyncPredicate<T>): AsyncIterable2<T>;
+    filterSync(cb: AbortablePredicate<T>): AsyncIterable2<T>;
     map<OUT>(mapper: AbortableAsyncMapper<T, OUT>): AsyncIterable2<OUT>;
+    mapSync<OUT>(mapper: AbortableMapper<T, OUT>): AsyncIterable2<OUT>;
 }

package/dist/iter/asyncIterable2.js

@@ -51,6 +51,9 @@ export class AsyncIterable2 {
     async some(cb) {
         return !!(await this.find(cb));
     }
+    async someSync(cb) {
+        return !!(await this.findSync(cb));
+    }
     async every(cb) {
         let i = 0;
         for await (const v of this.it) {
@@ -60,6 +63,15 @@ export class AsyncIterable2 {
         }
         return true;
     }
+    async everySync(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            const r = cb(v, i++);
+            if (r === END || !r)
+                return false;
+        }
+        return true;
+    }
     async find(cb) {
         let i = 0;
         for await (const v of this.it) {
@@ -70,6 +82,16 @@ export class AsyncIterable2 {
                 return v;
         }
     }
+    async findSync(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            const r = cb(v, i++);
+            if (r === END)
+                return;
+            if (r)
+                return v;
+        }
+    }
     filter(cb) {
         const { it } = this;
         return new AsyncIterable2({
@@ -85,6 +107,21 @@ export class AsyncIterable2 {
             },
         });
     }
+    filterSync(cb) {
+        const { it } = this;
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                let i = 0;
+                for await (const v of it) {
+                    const r = cb(v, i++);
+                    if (r === END)
+                        return;
+                    if (r)
+                        yield v;
+                }
+            },
+        });
+    }
     map(mapper) {
         const { it } = this;
         return new AsyncIterable2({
@@ -101,4 +138,20 @@ export class AsyncIterable2 {
             },
         });
     }
+    mapSync(mapper) {
+        const { it } = this;
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                let i = 0;
+                for await (const v of it) {
+                    const r = mapper(v, i++);
+                    if (r === END)
+                        return;
+                    if (r === SKIP)
+                        continue;
+                    yield r;
+                }
+            },
+        });
+    }
 }

package/dist/log/commonLogger.d.ts

@@ -3,13 +3,17 @@ import type { MutateOptions } from '../array/array.util.js';
  * These levels follow console.* naming,
  * so you can use console[level] safely.
  *
- * `log` is considered default level.
+ * `debug` is not enabled by default, and is useful when debugging is needed.
  *
- * For simplicity - only these 3 levels are kept.
+ * `log` is considered default level, and is enabled by default.
+ *
+ * `warn` is for warnings - things that are not super-severe to be an error, but should not happen
+ *
+ * `error` level would only log errors
  *
  * @experimental
  */
-export type CommonLogLevel = 'log' | 'warn' | 'error';
+export type CommonLogLevel = 'debug' | 'log' | 'warn' | 'error';
 export declare const commonLogLevelNumber: Record<CommonLogLevel, number>;
 /**
  * Function that takes any number of arguments and logs them all.
@@ -26,20 +30,19 @@ export type CommonLogWithLevelFunction = (level: CommonLogLevel, args: any[]) =>
  * @experimental
  */
 export interface CommonLogger {
+    debug: CommonLogFunction;
     log: CommonLogFunction;
     warn: CommonLogFunction;
     error: CommonLogFunction;
 }
 /**
  * SimpleLogger that does nothing (noop).
- *
- * @experimental
  */
 export declare const commonLoggerNoop: CommonLogger;
 /**
  * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
  */
-export declare function commonLoggerMinLevel(logger: CommonLogger, minLevel: CommonLogLevel, opt?: MutateOptions): CommonLogger;
+export declare function createCommonLoggerAtLevel(logger?: CommonLogger, minLevel?: CommonLogLevel, opt?: MutateOptions): CommonLogger;
 /**
  * Creates a "proxy" CommonLogger that pipes log messages to all provided sub-loggers.
  */

package/dist/log/commonLogger.js

@@ -1,15 +1,16 @@
+// copy-pasted to avoid weird circular dependency
 const _noop = (..._args) => undefined;
 export const commonLogLevelNumber = {
-    log: 10,
+    debug: 10,
+    log: 20,
     warn: 20,
     error: 30,
 };
 /**
  * SimpleLogger that does nothing (noop).
- *
- * @experimental
  */
 export const commonLoggerNoop = {
+    debug: _noop,
     log: _noop,
     warn: _noop,
     error: _noop,
@@ -17,21 +18,24 @@ export const commonLoggerNoop = {
 /**
  * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
  */
-export function commonLoggerMinLevel(logger, minLevel, opt = {}) {
+export function createCommonLoggerAtLevel(logger = console, minLevel = 'log', opt = {}) {
     const level = commonLogLevelNumber[minLevel];
     if (opt.mutate) {
-        if (level > commonLogLevelNumber['log']) {
-            logger.log = _noop;
-            if (level > commonLogLevelNumber['warn']) {
-                logger.warn = _noop;
-                if (level > commonLogLevelNumber['error']) {
-                    logger.error = _noop;
+        if (level > commonLogLevelNumber['debug']) {
+            logger.debug = _noop;
+            if (level > commonLogLevelNumber['log']) {
+                logger.log = _noop;
+                if (level > commonLogLevelNumber['warn']) {
+                    logger.warn = _noop;
+                    if (level > commonLogLevelNumber['error']) {
+                        logger.error = _noop;
+                    }
                 }
             }
         }
         return logger;
     }
-    if (level <= commonLogLevelNumber['log']) {
+    if (level <= commonLogLevelNumber['debug']) {
         // All levels are kept
         return logger;
     }
@@ -40,7 +44,8 @@ export function commonLoggerMinLevel(logger, minLevel, opt = {}) {
         return commonLoggerNoop;
     }
     return {
-        log: _noop, // otherwise it is "log everything" logger (same logger as input)
+        debug: _noop, // otherwise it is "log everything" logger (same logger as input)
+        log: level <= commonLogLevelNumber['log'] ? logger.log.bind(logger) : _noop,
         warn: level <= commonLogLevelNumber['warn'] ? logger.warn.bind(logger) : _noop,
         error: logger.error.bind(logger), // otherwise it's "log nothing" logger (same as noopLogger)
     };
@@ -50,6 +55,7 @@ export function commonLoggerMinLevel(logger, minLevel, opt = {}) {
  */
 export function commonLoggerPipe(loggers) {
     return {
+        debug: (...args) => loggers.forEach(logger => logger.debug(...args)),
         log: (...args) => loggers.forEach(logger => logger.log(...args)),
         warn: (...args) => loggers.forEach(logger => logger.warn(...args)),
         error: (...args) => loggers.forEach(logger => logger.error(...args)),
@@ -60,6 +66,7 @@ export function commonLoggerPipe(loggers) {
  */
 export function commonLoggerPrefix(logger, ...prefixes) {
     return {
+        debug: (...args) => logger.debug(...prefixes, ...args),
         log: (...args) => logger.log(...prefixes, ...args),
         warn: (...args) => logger.warn(...prefixes, ...args),
         error: (...args) => logger.error(...prefixes, ...args),
@@ -70,6 +77,7 @@ export function commonLoggerPrefix(logger, ...prefixes) {
  */
 export function commonLoggerCreate(fn) {
     return {
+        debug: (...args) => fn('debug', args),
         log: (...args) => fn('log', args),
         warn: (...args) => fn('warn', args),
         error: (...args) => fn('error', args),

package/dist/types.d.ts

@@ -114,10 +114,10 @@ export declare const SKIP: unique symbol;
  */
 export declare const MISS: unique symbol;
 /**
- * Function which is called for every item in `input`. Expected to return a `Promise` or value.
+ * Function which is called for every item in `input`. Expected to return a `Promise`.
  */
-export type AsyncMapper<IN = any, OUT = any> = (input: IN) => OUT | PromiseLike<OUT>;
-export type AsyncIndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => OUT | PromiseLike<OUT>;
+export type AsyncMapper<IN = any, OUT = any> = (input: IN) => PromiseLike<OUT>;
+export type AsyncIndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => PromiseLike<OUT>;
 export type Mapper<IN = any, OUT = any> = (input: IN) => OUT;
 export type IndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => OUT;
 export declare const _passthroughMapper: IndexedMapper;
@@ -127,11 +127,11 @@ export declare const _passUndefinedMapper: IndexedMapper<any, void>;
  */
 export declare const _noop: (..._args: any[]) => undefined;
 export type Predicate<T> = (item: T, index: number) => boolean;
-export type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>;
+export type AsyncPredicate<T> = (item: T, index: number) => PromiseLike<boolean>;
 export type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END;
-export type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>;
+export type AbortableAsyncPredicate<T> = (item: T, i: number) => PromiseLike<boolean | typeof END>;
 export type AbortableMapper<IN = any, OUT = any> = (input: IN, i: number) => OUT | typeof SKIP | typeof END;
-export type AbortableAsyncMapper<IN = any, OUT = any> = (input: IN, i: number) => Promisable<OUT | typeof SKIP | typeof END>;
+export type AbortableAsyncMapper<IN = any, OUT = any> = (input: IN, i: number) => PromiseLike<OUT | typeof SKIP | typeof END>;
 export declare const _passthroughPredicate: Predicate<any>;
 export declare const _passNothingPredicate: Predicate<any>;
 export interface BatchResult<RES = any, ERR = Error> {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.31.0",
+  "version": "15.33.0",
   "dependencies": {
     "tslib": "^2",
     "undici": "^7",
@@ -13,7 +13,7 @@
     "@types/semver": "^7",
     "crypto-js": "^4",
     "dayjs": "^1",
-    "@naturalcycles/dev-lib": "18.4.2"
+    "@naturalcycles/dev-lib": "19.37.0"
   },
   "exports": {
     ".": "./dist/index.js",

package/src/iter/asyncIterable2.ts

@@ -1,4 +1,10 @@
-import type { AbortableAsyncMapper, AbortableAsyncPredicate, Promisable } from '../types.js'
+import type {
+  AbortableAsyncMapper,
+  AbortableAsyncPredicate,
+  AbortableMapper,
+  AbortablePredicate,
+  Promisable,
+} from '../types.js'
 import { END, SKIP } from '../types.js'
 
 /**
@@ -58,6 +64,10 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     return !!(await this.find(cb))
   }
 
+  async someSync(cb: AbortablePredicate<T>): Promise<boolean> {
+    return !!(await this.findSync(cb))
+  }
+
   async every(cb: AbortableAsyncPredicate<T>): Promise<boolean> {
     let i = 0
     for await (const v of this.it) {
@@ -67,6 +77,15 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     return true
   }
 
+  async everySync(cb: AbortablePredicate<T>): Promise<boolean> {
+    let i = 0
+    for await (const v of this.it) {
+      const r = cb(v, i++)
+      if (r === END || !r) return false
+    }
+    return true
+  }
+
   async find(cb: AbortableAsyncPredicate<T>): Promise<T | undefined> {
     let i = 0
     for await (const v of this.it) {
@@ -76,6 +95,15 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     }
   }
 
+  async findSync(cb: AbortablePredicate<T>): Promise<T | undefined> {
+    let i = 0
+    for await (const v of this.it) {
+      const r = cb(v, i++)
+      if (r === END) return
+      if (r) return v
+    }
+  }
+
   filter(cb: AbortableAsyncPredicate<T>): AsyncIterable2<T> {
     const { it } = this
 
@@ -91,6 +119,21 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     })
   }
 
+  filterSync(cb: AbortablePredicate<T>): AsyncIterable2<T> {
+    const { it } = this
+
+    return new AsyncIterable2<T>({
+      async *[Symbol.asyncIterator]() {
+        let i = 0
+        for await (const v of it) {
+          const r = cb(v, i++)
+          if (r === END) return
+          if (r) yield v
+        }
+      },
+    })
+  }
+
   map<OUT>(mapper: AbortableAsyncMapper<T, OUT>): AsyncIterable2<OUT> {
     const { it } = this
 
@@ -106,4 +149,20 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
       },
     })
   }
+
+  mapSync<OUT>(mapper: AbortableMapper<T, OUT>): AsyncIterable2<OUT> {
+    const { it } = this
+
+    return new AsyncIterable2<OUT>({
+      async *[Symbol.asyncIterator]() {
+        let i = 0
+        for await (const v of it) {
+          const r = mapper(v, i++)
+          if (r === END) return
+          if (r === SKIP) continue
+          yield r
+        }
+      },
+    })
+  }
 }

package/src/log/commonLogger.ts

@@ -1,22 +1,27 @@
-// copy-pasted to avoid weird circular dependency
 import type { MutateOptions } from '../array/array.util.js'
 
+// copy-pasted to avoid weird circular dependency
 const _noop = (..._args: any[]): undefined => undefined
 
 /**
  * These levels follow console.* naming,
  * so you can use console[level] safely.
  *
- * `log` is considered default level.
+ * `debug` is not enabled by default, and is useful when debugging is needed.
+ *
+ * `log` is considered default level, and is enabled by default.
  *
- * For simplicity - only these 3 levels are kept.
+ * `warn` is for warnings - things that are not super-severe to be an error, but should not happen
+ *
+ * `error` level would only log errors
  *
  * @experimental
  */
-export type CommonLogLevel = 'log' | 'warn' | 'error'
+export type CommonLogLevel = 'debug' | 'log' | 'warn' | 'error'
 
 export const commonLogLevelNumber: Record<CommonLogLevel, number> = {
-  log: 10,
+  debug: 10,
+  log: 20,
   warn: 20,
   error: 30,
 }
@@ -37,6 +42,7 @@ export type CommonLogWithLevelFunction = (level: CommonLogLevel, args: any[]) =>
  * @experimental
  */
 export interface CommonLogger {
+  debug: CommonLogFunction
   log: CommonLogFunction
   warn: CommonLogFunction
   error: CommonLogFunction
@@ -44,10 +50,9 @@ export interface CommonLogger {
 
 /**
  * SimpleLogger that does nothing (noop).
- *
- * @experimental
  */
 export const commonLoggerNoop: CommonLogger = {
+  debug: _noop,
   log: _noop,
   warn: _noop,
   error: _noop,
@@ -56,26 +61,29 @@ export const commonLoggerNoop: CommonLogger = {
 /**
  * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
  */
-export function commonLoggerMinLevel(
-  logger: CommonLogger,
-  minLevel: CommonLogLevel,
+export function createCommonLoggerAtLevel(
+  logger: CommonLogger = console,
+  minLevel: CommonLogLevel = 'log',
   opt: MutateOptions = {},
 ): CommonLogger {
   const level = commonLogLevelNumber[minLevel]
   if (opt.mutate) {
-    if (level > commonLogLevelNumber['log']) {
-      logger.log = _noop
-      if (level > commonLogLevelNumber['warn']) {
-        logger.warn = _noop
-        if (level > commonLogLevelNumber['error']) {
-          logger.error = _noop
+    if (level > commonLogLevelNumber['debug']) {
+      logger.debug = _noop
+      if (level > commonLogLevelNumber['log']) {
+        logger.log = _noop
+        if (level > commonLogLevelNumber['warn']) {
+          logger.warn = _noop
+          if (level > commonLogLevelNumber['error']) {
+            logger.error = _noop
+          }
         }
       }
     }
     return logger
   }
 
-  if (level <= commonLogLevelNumber['log']) {
+  if (level <= commonLogLevelNumber['debug']) {
     // All levels are kept
     return logger
   }
@@ -86,7 +94,8 @@ export function commonLoggerMinLevel(
   }
 
   return {
-    log: _noop, // otherwise it is "log everything" logger (same logger as input)
+    debug: _noop, // otherwise it is "log everything" logger (same logger as input)
+    log: level <= commonLogLevelNumber['log'] ? logger.log.bind(logger) : _noop,
     warn: level <= commonLogLevelNumber['warn'] ? logger.warn.bind(logger) : _noop,
     error: logger.error.bind(logger), // otherwise it's "log nothing" logger (same as noopLogger)
   }
@@ -97,6 +106,7 @@ export function commonLoggerMinLevel(
  */
 export function commonLoggerPipe(loggers: CommonLogger[]): CommonLogger {
   return {
+    debug: (...args) => loggers.forEach(logger => logger.debug(...args)),
     log: (...args) => loggers.forEach(logger => logger.log(...args)),
     warn: (...args) => loggers.forEach(logger => logger.warn(...args)),
     error: (...args) => loggers.forEach(logger => logger.error(...args)),
@@ -108,6 +118,7 @@ export function commonLoggerPipe(loggers: CommonLogger[]): CommonLogger {
  */
 export function commonLoggerPrefix(logger: CommonLogger, ...prefixes: any[]): CommonLogger {
   return {
+    debug: (...args) => logger.debug(...prefixes, ...args),
     log: (...args) => logger.log(...prefixes, ...args),
     warn: (...args) => logger.warn(...prefixes, ...args),
     error: (...args) => logger.error(...prefixes, ...args),
@@ -119,6 +130,7 @@ export function commonLoggerPrefix(logger: CommonLogger, ...prefixes: any[]): Co
  */
 export function commonLoggerCreate(fn: CommonLogWithLevelFunction): CommonLogger {
   return {
+    debug: (...args) => fn('debug', args),
     log: (...args) => fn('log', args),
     warn: (...args) => fn('warn', args),
     error: (...args) => fn('error', args),

package/src/types.ts

@@ -141,13 +141,10 @@ export const SKIP = Symbol('SKIP')
 export const MISS = Symbol('MISS')
 
 /**
- * Function which is called for every item in `input`. Expected to return a `Promise` or value.
+ * Function which is called for every item in `input`. Expected to return a `Promise`.
  */
-export type AsyncMapper<IN = any, OUT = any> = (input: IN) => OUT | PromiseLike<OUT>
-export type AsyncIndexedMapper<IN = any, OUT = any> = (
-  input: IN,
-  index: number,
-) => OUT | PromiseLike<OUT>
+export type AsyncMapper<IN = any, OUT = any> = (input: IN) => PromiseLike<OUT>
+export type AsyncIndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => PromiseLike<OUT>
 export type Mapper<IN = any, OUT = any> = (input: IN) => OUT
 export type IndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => OUT
 
@@ -160,10 +157,10 @@ export const _passUndefinedMapper: IndexedMapper<any, void> = () => undefined
 export const _noop = (..._args: any[]): undefined => undefined
 
 export type Predicate<T> = (item: T, index: number) => boolean
-export type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>
+export type AsyncPredicate<T> = (item: T, index: number) => PromiseLike<boolean>
 
 export type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END
-export type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>
+export type AbortableAsyncPredicate<T> = (item: T, i: number) => PromiseLike<boolean | typeof END>
 export type AbortableMapper<IN = any, OUT = any> = (
   input: IN,
   i: number,
@@ -171,7 +168,7 @@ export type AbortableMapper<IN = any, OUT = any> = (
 export type AbortableAsyncMapper<IN = any, OUT = any> = (
   input: IN,
   i: number,
-) => Promisable<OUT | typeof SKIP | typeof END>
+) => PromiseLike<OUT | typeof SKIP | typeof END>
 
 export const _passthroughPredicate: Predicate<any> = () => true
 export const _passNothingPredicate: Predicate<any> = () => false