@naturalcycles/js-lib 15.62.0 → 15.64.0

package/dist/array/sort.d.ts

@@ -1,29 +1,29 @@
-import { type Comparator, type Mapper, type SortDirection, type SortOptions, type StringMap } from '../types.js';
+import type { Comparator, Mapper, SortDirection, SortOptions, StringMap } from '../types.js';
 declare class Comparators {
     /**
      * Good for numbers.
      */
-    numericAsc(a: number, b: number): number;
-    numericDesc(a: number, b: number): number;
-    localeAsc(a: string, b: string): number;
-    localeDesc(a: string, b: string): number;
-    by<T, COMPARE_TYPE extends string | number>(mapper: Mapper<T, COMPARE_TYPE>, opt?: ComparatorByOptions): Comparator<T>;
-    updatedAsc(a: {
+    numericAsc(this: void, a: number, b: number): number;
+    numericDesc(this: void, a: number, b: number): number;
+    localeAsc(this: void, a: string, b: string): number;
+    localeDesc(this: void, a: string, b: string): number;
+    by<T, COMPARE_TYPE extends string | number>(this: void, mapper: Mapper<T, COMPARE_TYPE>, opt?: ComparatorByOptions): Comparator<T>;
+    updatedAsc(this: void, a: {
         updated: number;
     }, b: {
         updated: number;
     }): number;
-    updatedDesc(a: {
+    updatedDesc(this: void, a: {
         updated: number;
     }, b: {
         updated: number;
     }): number;
-    createdAsc(a: {
+    createdAsc(this: void, a: {
         created: number;
     }, b: {
         created: number;
     }): number;
-    createdDesc(a: {
+    createdDesc(this: void, a: {
         created: number;
     }, b: {
         created: number;

package/dist/array/sort.js

@@ -1,4 +1,4 @@
-import { _stringMapValues, } from '../types.js';
+import { _stringMapValues } from '../types.js';
 class Comparators {
     /**
      * Good for numbers.

package/dist/bot.model.js

@@ -1,4 +1,5 @@
-export var BotReason;
+export { BotReason };
+var BotReason;
 (function (BotReason) {
     BotReason[BotReason["NoNavigator"] = 1] = "NoNavigator";
     BotReason[BotReason["NoUserAgent"] = 2] = "NoUserAgent";

package/dist/browser/adminService.js

@@ -43,6 +43,7 @@ export class AdminService {
     stopListening() {
         if (isServerSide())
             return;
+        // oxlint-disable-next-line typescript/unbound-method
         document.removeEventListener('keydown', this.keydownListener);
         this.listening = false;
     }

package/dist/browser/analytics.util.js

@@ -8,7 +8,6 @@ export async function loadGTag(gtagId, enabled = true) {
         return;
     globalThis.dataLayer ||= [];
     globalThis.gtag ||= function gtag() {
-        // biome-ignore lint/complexity/noArguments: ok
         globalThis.dataLayer.push(arguments);
     };
     globalThis.gtag('js', new Date());
@@ -30,14 +29,16 @@ export async function loadGTM(gtmId, enabled = true) {
     await loadScript(`https://www.googletagmanager.com/gtm.js?id=${gtmId}`);
 }
 export function loadHotjar(hjid) {
-    if (isServerSide())
+    if (isServerSide()) {
         return;
+    }
+    /* eslint-disable */
+    // oxfmt-ignore
     ;
     ((h, o, t, j, a, r) => {
         h.hj =
             h.hj ||
                 function hj() {
-                    // biome-ignore lint/complexity/noArguments: ok
                     ;
                     (h.hj.q = h.hj.q || []).push(arguments);
                 };

package/dist/browser/i18n/translation.service.js

@@ -35,7 +35,7 @@ export class TranslationService {
      */
     async loadLocale(locale) {
         const locales = Array.isArray(locale) ? locale : [locale];
-        await pMap(locales, async (locale) => {
+        await pMap(locales, async locale => {
             if (this.locales[locale])
                 return; // already loaded
             this.locales[locale] = await this.cfg.translationLoader.load(locale);

package/dist/browser/topbar.d.ts

@@ -16,8 +16,8 @@ export interface TopBarOptions {
 }
 export declare const topbar: {
     config(opts: TopBarOptions): void;
-    set(show: boolean, opts?: TopBarOptions): void;
-    show(opts?: TopBarOptions): void;
-    progress(to: number | string): any;
+    set(show: boolean, opts?: TopBarOptions | undefined): void;
+    show(opts?: TopBarOptions | undefined): void;
+    progress(to: string | number): any;
     hide(): void;
 };

package/dist/datetime/localTime.d.ts

@@ -208,6 +208,15 @@ export declare class LocalTime {
      * `1984-06-21 17:56`
      */
     toPretty(seconds?: boolean): IsoDateTime;
+    /**
+     * Returns e.g: `1984-06-21T17:56:21Z`
+     *
+     * IsoDateTime "format" is ambiguous.
+     * Normally what we mean by it is `1984-06-21T17:56:21` (without Z).
+     * But sometimes you need Z.
+     * So, when you need Z - use this function.
+     */
+    toISODateTimeWithZ(): IsoDateTime;
     /**
      * Returns e.g: `1984-06-21T17:56:21`
      */

package/dist/datetime/localTime.js

@@ -2,7 +2,8 @@ import { _assert } from '../error/assert.js';
 import { localDate } from './localDate.js';
 import { _ms } from './time.util.js';
 import { WallTime } from './wallTime.js';
-export var ISODayOfWeek;
+export { ISODayOfWeek };
+var ISODayOfWeek;
 (function (ISODayOfWeek) {
     ISODayOfWeek[ISODayOfWeek["MONDAY"] = 1] = "MONDAY";
     ISODayOfWeek[ISODayOfWeek["TUESDAY"] = 2] = "TUESDAY";
@@ -568,6 +569,17 @@ export class LocalTime {
         // const s = this.$date.toISOString()
         // return s.slice(0, 10) + ' ' + s.slice(11, seconds ? 19 : 16)
     }
+    /**
+     * Returns e.g: `1984-06-21T17:56:21Z`
+     *
+     * IsoDateTime "format" is ambiguous.
+     * Normally what we mean by it is `1984-06-21T17:56:21` (without Z).
+     * But sometimes you need Z.
+     * So, when you need Z - use this function.
+     */
+    toISODateTimeWithZ() {
+        return (this.toISODateTime() + 'Z');
+    }
     /**
      * Returns e.g: `1984-06-21T17:56:21`
      */

package/dist/decorators/asyncMemo.decorator.js

@@ -46,7 +46,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
             // console.log('return promise', promiseCache.size)
             return promise;
         }
-        promise = cache.get(cacheKey).then(async (value) => {
+        promise = cache.get(cacheKey).then(async value => {
             if (value !== MISS) {
                 // console.log('hit', promiseCache.size)
                 promiseCache.delete(cacheKey);
@@ -55,7 +55,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
             // Miss
             // console.log('miss', promiseCache.size)
             return await onMiss();
-        }, async (err) => {
+        }, async err => {
             // Log the cache error and proceed "as cache Miss"
             logger.error(err);
             return await onMiss();

package/dist/error/assert.d.ts

@@ -16,8 +16,7 @@ import type { BackendErrorResponseObject, ErrorData, ErrorObject } from './error
  *
  * Since 2024-07-10 it no longer sets `userFriendly: true` by default.
  */
-export declare function _assert(condition: any, // will be evaluated as Boolean
-message?: string, errorData?: ErrorData): asserts condition;
+export declare function _assert(condition: any, message?: string, errorData?: ErrorData): asserts condition;
 /**
  * Like _assert(), but prints more helpful error message.
  * API is similar to Node's assert.equals().

package/dist/error/errorMode.js

@@ -1,9 +1,10 @@
+export { ErrorMode };
 /**
  * Allows to define error-controlling behaviour for batch operations.
  *
  * @default is THROW_IMMEDIATELY in most cases
  */
-export var ErrorMode;
+var ErrorMode;
 (function (ErrorMode) {
     /**
      * Usually a default behaviour, similar as "exit early".

package/dist/promise/pGradualQueue.d.ts

@@ -1,5 +1,5 @@
 import { ErrorMode } from '../error/errorMode.js';
-import { type CommonLogger, type CommonLogLevel } from '../log/commonLogger.js';
+import type { CommonLogger, CommonLogLevel } from '../log/commonLogger.js';
 import type { AsyncFunction, PositiveInteger } from '../types.js';
 export interface PGradualQueueCfg {
     concurrency: PositiveInteger;

package/dist/promise/pGradualQueue.js

@@ -1,5 +1,5 @@
 import { ErrorMode } from '../error/errorMode.js';
-import { createCommonLoggerAtLevel, } from '../log/commonLogger.js';
+import { createCommonLoggerAtLevel } from '../log/commonLogger.js';
 import { pDefer } from './pDefer.js';
 /**
  * A queue similar to PQueue that gradually increases concurrency from 1 to the configured

package/dist/promise/pMap.d.ts

@@ -1,6 +1,6 @@
 import { ErrorMode } from '../error/errorMode.js';
 import type { CommonLogger } from '../log/commonLogger.js';
-import { type AbortableAsyncMapper } from '../types.js';
+import type { AbortableAsyncMapper } from '../types.js';
 export interface PMapOptions {
     /**
      * Number of concurrently pending promises returned by `mapper`.

package/dist/promise/pMap.js

@@ -77,7 +77,7 @@ export async function pMap(iterable, mapper, opt = {}) {
             }
             resolvingCount++;
             Promise.resolve(nextItem)
-                .then(async (element) => await mapper(element, i))
+                .then(async element => await mapper(element, i))
                 .then(value => {
                 if (value === END) {
                     isSettled = true;

package/dist/promise/pQueue.d.ts

@@ -1,5 +1,5 @@
 import { ErrorMode } from '../error/errorMode.js';
-import { type CommonLogger, type CommonLogLevel } from '../log/commonLogger.js';
+import type { CommonLogger, CommonLogLevel } from '../log/commonLogger.js';
 import type { AsyncFunction, PositiveInteger } from '../types.js';
 export interface PQueueCfg {
     concurrency: PositiveInteger;

package/dist/promise/pQueue.js

@@ -1,5 +1,5 @@
 import { ErrorMode } from '../error/errorMode.js';
-import { createCommonLoggerAtLevel, } from '../log/commonLogger.js';
+import { createCommonLoggerAtLevel } from '../log/commonLogger.js';
 import { pDefer } from './pDefer.js';
 /**
  * Inspired by: https://github.com/sindresorhus/p-queue

package/dist/promise/pTimeout.js

@@ -29,7 +29,6 @@ export async function pTimeout(fn, opt) {
     }
     const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt;
     const fakeError = opt.fakeError || new Error('TimeoutError');
-    // biome-ignore lint/suspicious/noAsyncPromiseExecutor: ok
     return await new Promise(async (resolve, reject) => {
         // Prepare the timeout timer
         const timer = setTimeout(() => {

package/dist/typeFest.d.ts

@@ -12,7 +12,7 @@ export type Simplify<T> = {
  @link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
  @link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
  */
-export type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => (G extends U ? 1 : 2) ? true : false;
 /**
  * Filter out keys from an object.
  * Returns `never` if `Exclude` is strictly equal to `Key`.

package/dist/validation/validation.d.ts

@@ -14,7 +14,7 @@ import type { AppError } from '../error/error.util.js';
  *
  * @experimental
  */
-export type ValidationFunction<IN, OUT, ERR extends AppError> = (input: IN, opt?: ValidationFunctionOptions) => ValidationFunctionResult<OUT, ERR>;
+export type ValidationFunction<OUT, ERR extends AppError> = (input: unknown, opt?: ValidationFunctionOptions) => ValidationFunctionResult<OUT, ERR>;
 export type ValidationFunctionResult<OUT, ERR extends AppError> = [err: ERR | null, output: OUT];
 export interface ValidationFunctionOptions {
     /**

package/dist/zod/zod.util.d.ts

@@ -2,10 +2,10 @@ import type { ZodError, ZodType } from 'zod';
 import type { ErrorData } from '../error/error.model.js';
 import { AppError } from '../error/error.util.js';
 import type { ValidationFunction, ValidationFunctionResult } from '../validation/validation.js';
-export declare function getZodValidationFunction<T>(schema: ZodType<T>): ValidationFunction<T, T, ZodValidationError>;
-export declare function zIsValid<T>(value: T, schema: ZodType<T>): boolean;
-export declare function zValidate<T>(value: T, schema: ZodType<T>): T;
-export declare function zSafeValidate<T>(input: T, schema: ZodType<T>): ValidationFunctionResult<T, ZodValidationError>;
+export declare function getZodValidationFunction<T>(schema: ZodType<T>): ValidationFunction<T, ZodValidationError>;
+export declare function zIsValid<T>(value: unknown, schema: ZodType<T>): boolean;
+export declare function zValidate<T>(value: unknown, schema: ZodType<T>): T;
+export declare function zSafeValidate<T>(input: unknown, schema: ZodType<T>): ValidationFunctionResult<T, ZodValidationError>;
 export interface ZodValidationErrorData extends ErrorData {
 }
 export declare class ZodValidationError extends AppError<ZodValidationErrorData> {

package/dist/zod/zod.util.js

@@ -17,7 +17,9 @@ export function zValidate(value, schema) {
         throw err;
     return data;
 }
-export function zSafeValidate(input, schema) {
+export function zSafeValidate(input, schema
+// inputName?: string,
+) {
     const r = schema.safeParse(input);
     if (r.success) {
         return [null, r.data];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.62.0",
+  "version": "15.64.0",
   "dependencies": {
     "tslib": "^2"
   },
@@ -21,9 +21,10 @@
     "@types/crypto-js": "^4",
     "@types/node": "^25",
     "@types/semver": "^7",
+    "@typescript/native-preview": "7.0.0-dev.20260201.1",
     "crypto-js": "^4",
     "dayjs": "^1",
-    "@naturalcycles/dev-lib": "20.26.0"
+    "@naturalcycles/dev-lib": "18.4.2"
   },
   "exports": {
     ".": "./dist/index.js",

package/src/array/sort.ts

@@ -1,33 +1,28 @@
-import {
-  _stringMapValues,
-  type Comparator,
-  type Mapper,
-  type SortDirection,
-  type SortOptions,
-  type StringMap,
-} from '../types.js'
+import { _stringMapValues } from '../types.js'
+import type { Comparator, Mapper, SortDirection, SortOptions, StringMap } from '../types.js'
 
 class Comparators {
   /**
    * Good for numbers.
    */
-  numericAsc(a: number, b: number): number {
+  numericAsc(this: void, a: number, b: number): number {
     return a - b
   }
 
-  numericDesc(a: number, b: number): number {
+  numericDesc(this: void, a: number, b: number): number {
     return b - a
   }
 
-  localeAsc(a: string, b: string): number {
+  localeAsc(this: void, a: string, b: string): number {
     return a.localeCompare(b)
   }
 
-  localeDesc(a: string, b: string): number {
+  localeDesc(this: void, a: string, b: string): number {
     return -a.localeCompare(b)
   }
 
   by<T, COMPARE_TYPE extends string | number>(
+    this: void,
     mapper: Mapper<T, COMPARE_TYPE>,
     opt: ComparatorByOptions = {},
   ): Comparator<T> {
@@ -43,19 +38,19 @@ class Comparators {
     }
   }
 
-  updatedAsc(a: { updated: number }, b: { updated: number }): number {
+  updatedAsc(this: void, a: { updated: number }, b: { updated: number }): number {
     return a.updated - b.updated
   }
 
-  updatedDesc(a: { updated: number }, b: { updated: number }): number {
+  updatedDesc(this: void, a: { updated: number }, b: { updated: number }): number {
     return b.updated - a.updated
   }
 
-  createdAsc(a: { created: number }, b: { created: number }): number {
+  createdAsc(this: void, a: { created: number }, b: { created: number }): number {
     return a.created - b.created
   }
 
-  createdDesc(a: { created: number }, b: { created: number }): number {
+  createdDesc(this: void, a: { created: number }, b: { created: number }): number {
     return b.created - a.created
   }
 }

package/src/browser/adminService.ts

@@ -103,6 +103,7 @@ export class AdminService {
 
   stopListening(): void {
     if (isServerSide()) return
+    // oxlint-disable-next-line typescript/unbound-method
     document.removeEventListener('keydown', this.keydownListener)
     this.listening = false
   }

package/src/browser/analytics.util.ts

@@ -17,7 +17,6 @@ export async function loadGTag(gtagId: string, enabled = true): Promise<void> {
 
   globalThis.dataLayer ||= []
   globalThis.gtag ||= function gtag() {
-    // biome-ignore lint/complexity/noArguments: ok
     globalThis.dataLayer.push(arguments)
   }
   globalThis.gtag('js', new Date())
@@ -43,16 +42,16 @@ export async function loadGTM(gtmId: string, enabled = true): Promise<void> {
 }
 
 export function loadHotjar(hjid: number): void {
-  if (isServerSide()) return
+  if (isServerSide()) {
+    return
+  }
 
   /* eslint-disable */
-  // prettier-ignore
-  ;
+  // oxfmt-ignore
   ;((h: any, o, t, j, a?: any, r?: any) => {
     h.hj =
       h.hj ||
       function hj() {
-        // biome-ignore lint/complexity/noArguments: ok
         ;(h.hj.q = h.hj.q || []).push(arguments)
       }
     h._hjSettings = { hjid, hjsv: 6 }

package/src/datetime/localTime.ts

@@ -686,6 +686,18 @@ export class LocalTime {
     // return s.slice(0, 10) + ' ' + s.slice(11, seconds ? 19 : 16)
   }
 
+  /**
+   * Returns e.g: `1984-06-21T17:56:21Z`
+   *
+   * IsoDateTime "format" is ambiguous.
+   * Normally what we mean by it is `1984-06-21T17:56:21` (without Z).
+   * But sometimes you need Z.
+   * So, when you need Z - use this function.
+   */
+  toISODateTimeWithZ(): IsoDateTime {
+    return (this.toISODateTime() + 'Z') as IsoDateTime
+  }
+
   /**
    * Returns e.g: `1984-06-21T17:56:21`
    */

package/src/promise/pGradualQueue.ts

@@ -1,9 +1,6 @@
 import { ErrorMode } from '../error/errorMode.js'
-import {
-  type CommonLogger,
-  type CommonLogLevel,
-  createCommonLoggerAtLevel,
-} from '../log/commonLogger.js'
+import { createCommonLoggerAtLevel } from '../log/commonLogger.js'
+import type { CommonLogger, CommonLogLevel } from '../log/commonLogger.js'
 import type { AsyncFunction, PositiveInteger } from '../types.js'
 import type { DeferredPromise } from './pDefer.js'
 import { pDefer } from './pDefer.js'

package/src/promise/pMap.ts

@@ -1,6 +1,7 @@
 import { ErrorMode } from '../error/errorMode.js'
 import type { CommonLogger } from '../log/commonLogger.js'
-import { type AbortableAsyncMapper, END, SKIP } from '../types.js'
+import { END, SKIP } from '../types.js'
+import type { AbortableAsyncMapper } from '../types.js'
 
 export interface PMapOptions {
   /**

package/src/promise/pQueue.ts

@@ -1,9 +1,6 @@
 import { ErrorMode } from '../error/errorMode.js'
-import {
-  type CommonLogger,
-  type CommonLogLevel,
-  createCommonLoggerAtLevel,
-} from '../log/commonLogger.js'
+import { createCommonLoggerAtLevel } from '../log/commonLogger.js'
+import type { CommonLogger, CommonLogLevel } from '../log/commonLogger.js'
 import type { AsyncFunction, PositiveInteger } from '../types.js'
 import type { DeferredPromise } from './pDefer.js'
 import { pDefer } from './pDefer.js'

package/src/promise/pTimeout.ts

@@ -73,7 +73,6 @@ export async function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions)
   const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt
   const fakeError = opt.fakeError || new Error('TimeoutError')
 
-  // biome-ignore lint/suspicious/noAsyncPromiseExecutor: ok
   return await new Promise(async (resolve, reject) => {
     // Prepare the timeout timer
     const timer = setTimeout(() => {

package/src/validation/validation.ts

@@ -15,8 +15,8 @@ import type { AppError } from '../error/error.util.js'
  *
  * @experimental
  */
-export type ValidationFunction<IN, OUT, ERR extends AppError> = (
-  input: IN,
+export type ValidationFunction<OUT, ERR extends AppError> = (
+  input: unknown,
   opt?: ValidationFunctionOptions,
 ) => ValidationFunctionResult<OUT, ERR>
 

package/src/zod/zod.util.ts

@@ -7,26 +7,26 @@ import type { ValidationFunction, ValidationFunctionResult } from '../validation
 
 export function getZodValidationFunction<T>(
   schema: ZodType<T>,
-): ValidationFunction<T, T, ZodValidationError> {
+): ValidationFunction<T, ZodValidationError> {
   return (input, opt) => {
     _assert(!opt?.mutateInput, 'mutateInput=true is not yet supported with Zod')
     return zSafeValidate(input, schema)
   }
 }
 
-export function zIsValid<T>(value: T, schema: ZodType<T>): boolean {
+export function zIsValid<T>(value: unknown, schema: ZodType<T>): boolean {
   const { success } = schema.safeParse(value)
   return success
 }
 
-export function zValidate<T>(value: T, schema: ZodType<T>): T {
+export function zValidate<T>(value: unknown, schema: ZodType<T>): T {
   const [err, data] = zSafeValidate(value, schema)
   if (err) throw err
   return data
 }
 
 export function zSafeValidate<T>(
-  input: T,
+  input: unknown,
   schema: ZodType<T>,
   // inputName?: string,
 ): ValidationFunctionResult<T, ZodValidationError> {
@@ -35,7 +35,7 @@ export function zSafeValidate<T>(
     return [null, r.data]
   }
 
-  return [new ZodValidationError(r.error, input, schema), r.data ?? input]
+  return [new ZodValidationError(r.error, input, schema), r.data ?? (input as T)]
 }
 
 export interface ZodValidationErrorData extends ErrorData {}