@naturalcycles/nodejs-lib 15.33.0 → 15.35.0

package/dist/cache/lruMemoCache.d.ts

@@ -5,7 +5,7 @@ export type LRUMemoCacheOptions<KEY, VALUE> = Partial<LRUCache.Options<KEY, VALU
  * @example
  * Use it like this:
  *
- * @_Memo({ cacheFactory: () => new LRUMemoCache({...}) })
+ * `@_Memo({ cacheFactory: () => new LRUMemoCache({...}) })`
  * method1 ()
  */
 export declare class LRUMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {

package/dist/cache/lruMemoCache.js

@@ -3,7 +3,7 @@ import { LRUCache } from 'lru-cache';
  * @example
  * Use it like this:
  *
- * @_Memo({ cacheFactory: () => new LRUMemoCache({...}) })
+ * `@_Memo({ cacheFactory: () => new LRUMemoCache({...}) })`
  * method1 ()
  */
 export class LRUMemoCache {

package/dist/csv/csvReader.js

@@ -21,7 +21,7 @@ export function csvStringParse(str, cfg = {}) {
     }
     _assert(header, `firstRowIsHeader or columns is required`);
     return arr.map(row => {
-        // eslint-disable-next-line unicorn/no-array-reduce
+        // oxlint-disable-next-line unicorn/no-array-reduce
         return header.reduce((obj, col, i) => {
             ;
             obj[col] = row[i];

package/dist/exec2/exec2.js

@@ -111,6 +111,7 @@ class Exec2 {
                 process.stdout.write(err.stdout);
             }
             this.logFinish(cmd, opt, started, false);
+            // oxlint-disable-next-line preserve-caught-error
             throw new Error(`exec exited with code ${err.status}: ${cmd}`);
         }
     }

package/dist/infra/process.util.js

@@ -67,7 +67,7 @@ class ProcessUtil {
         });
     }
     getCPUInfo() {
-        // eslint-disable-next-line unicorn/no-array-reduce
+        // oxlint-disable-next-line unicorn/no-array-reduce
         return os.cpus().reduce((r, cpu) => {
             r['idle'] += cpu.times.idle;
             Object.values(cpu.times).forEach(m => (r['total'] += m));

package/dist/slack/slack.service.model.d.ts

@@ -42,7 +42,7 @@ export interface SlackMessage<CTX = any> extends SlackMessageProps {
      */
     kv?: AnyObject;
     /**
-     * If specified - adds @name1, @name2 in the end of the message
+     * If specified - adds `@name1`, `@name2` in the end of the message
      */
     mentions?: string[];
     /**

package/dist/stream/ndjson/ndjson.model.js

@@ -9,7 +9,7 @@ export class NDJsonStats {
         return new NDJsonStats();
     }
     static createCombined(stats) {
-        // eslint-disable-next-line unicorn/no-array-reduce
+        // oxlint-disable-next-line unicorn/no-array-reduce
         return stats.reduce((statsTotal, stats) => statsTotal.add(stats), new NDJsonStats());
     }
     tookMillis = 0;

package/dist/stream/pipeline.js

@@ -1,7 +1,6 @@
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import { createUnzip } from 'node:zlib';
-import { createGzip } from 'node:zlib';
+import { createGzip, createUnzip } from 'node:zlib';
 import { createAbortableSignal } from '@naturalcycles/js-lib';
 import { _passthroughPredicate, } from '@naturalcycles/js-lib/types';
 import { fs2 } from '../fs/fs2.js';

package/dist/stream/readable/createReadable.js

@@ -1,5 +1,4 @@
-import { Transform } from 'node:stream';
-import { Readable } from 'node:stream';
+import { Readable, Transform } from 'node:stream';
 /**
  * Convenience function to create a Readable that can be pushed into (similar to RxJS Subject).
  * Push `null` to it to complete (similar to RxJS `.complete()`).

package/dist/stream/transform/transformThrottle.js

@@ -32,8 +32,8 @@ export function transformThrottle(opt) {
         async transform(item, _, cb) {
             // console.log('incoming', item, { paused: !!paused, count })
             if (!start) {
-                start = Date.now();
-                timeout = setTimeout(() => onInterval(this), interval * 1000);
+                start = localTime.nowUnixMillis();
+                timeout = setTimeout(() => onInterval(), interval * 1000);
                 logger.log(`${localTime.now().toPretty()} transformThrottle started with`, {
                     throughput,
                     interval,
@@ -56,7 +56,7 @@ export function transformThrottle(opt) {
             cb();
         },
     });
-    function onInterval(transform) {
+    function onInterval() {
         if (lock) {
             logger.log(`${localTime.now().toPretty()} transformThrottle resumed`);
             lock.resolve();
@@ -67,6 +67,6 @@ export function transformThrottle(opt) {
         }
         count = 0;
         start = localTime.nowUnixMillis();
-        timeout = setTimeout(() => onInterval(transform), interval * 1000);
+        timeout = setTimeout(() => onInterval(), interval * 1000);
     }
 }

package/dist/util/env.util.js

@@ -7,7 +7,7 @@ import { fs2 } from '../fs/fs2.js';
  * Will throw if any of the passed keys is not defined.
  */
 export function requireEnvKeys(...keys) {
-    // eslint-disable-next-line unicorn/no-array-reduce
+    // oxlint-disable-next-line unicorn/no-array-reduce
     return keys.reduce((r, k) => {
         const v = process.env[k];
         if (!v)

package/dist/validation/ajv/ajvSchema.d.ts

@@ -1,8 +1,10 @@
 import { type ValidationFunction, type ValidationFunctionResult } from '@naturalcycles/js-lib';
 import type { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib/json-schema';
+import type { AnyObject } from '@naturalcycles/js-lib/types';
 import { ZodType } from '@naturalcycles/js-lib/zod';
 import type { Ajv } from 'ajv';
 import { AjvValidationError } from './ajvValidationError.js';
+export type SchemaHandledByAjv<T> = JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T> | ZodType<T>;
 export interface AjvValidationOptions {
     /**
      * Defaults to true,
@@ -63,11 +65,15 @@ export declare class AjvSchema<T = unknown> {
      * Implementation note: JsonSchemaBuilder goes first in the union type, otherwise TypeScript fails to infer <T> type
      * correctly for some reason.
      */
-    static create<T>(schema: JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T> | ZodType<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
+    static create<T>(schema: SchemaHandledByAjv<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
     /**
-     * @experimental
+     * @deprecated
+     *
+     * Use `AjvSchema.create`
      */
     static createFromZod<T>(zodSchema: ZodType<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
+    static isJsonSchemaBuilder<T>(schema: unknown): schema is JsonSchemaBuilder<T>;
+    static isZodSchema<T>(schema: unknown): schema is ZodType<T>;
     readonly cfg: AjvSchemaCfg;
     /**
      * It returns the original object just for convenience.
@@ -81,12 +87,12 @@ export declare class AjvSchema<T = unknown> {
     isValid(input: T, opt?: AjvValidationOptions): boolean;
     getValidationResult(input: T, opt?: AjvValidationOptions): ValidationFunctionResult<T, AjvValidationError>;
     getValidationFunction(): ValidationFunction<T, AjvValidationError>;
-    static isZodSchemaWithAjvSchema<T>(schema: ZodType<T>): schema is ZodTypeWithAjvSchema<T>;
-    static cacheAjvSchemaInZodSchema<T>(zodSchema: ZodType<T>, ajvSchema: AjvSchema<T>): ZodTypeWithAjvSchema<T>;
-    static requireCachedAjvSchemaFromZodSchema<T>(zodSchema: ZodTypeWithAjvSchema<T>): AjvSchema<T>;
+    static isSchemaWithCachedAjvSchema<Base, T>(schema: Base): schema is WithCachedAjvSchema<Base, T>;
+    static cacheAjvSchema<Base extends AnyObject, T>(schema: Base, ajvSchema: AjvSchema<T>): WithCachedAjvSchema<Base, T>;
+    static requireCachedAjvSchema<Base, T>(schema: WithCachedAjvSchema<Base, T>): AjvSchema<T>;
     private getAJVValidateFunction;
 }
 export declare const HIDDEN_AJV_SCHEMA: unique symbol;
-export interface ZodTypeWithAjvSchema<T> extends ZodType<T> {
+export type WithCachedAjvSchema<Base, T> = Base & {
     [HIDDEN_AJV_SCHEMA]: AjvSchema<T>;
-}
+};

package/dist/validation/ajv/ajvSchema.js

@@ -46,24 +46,36 @@ export class AjvSchema {
     static create(schema, cfg) {
         if (schema instanceof AjvSchema)
             return schema;
-        if (schema instanceof JsonSchemaAnyBuilder) {
-            return new AjvSchema(schema.build(), cfg);
+        if (AjvSchema.isSchemaWithCachedAjvSchema(schema)) {
+            return AjvSchema.requireCachedAjvSchema(schema);
         }
-        if (schema instanceof ZodType)
-            return AjvSchema.createFromZod(schema);
-        return new AjvSchema(schema, cfg);
+        let jsonSchema;
+        if (AjvSchema.isJsonSchemaBuilder(schema)) {
+            jsonSchema = schema.build();
+        }
+        else if (AjvSchema.isZodSchema(schema)) {
+            jsonSchema = z.toJSONSchema(schema, { target: 'draft-7' });
+        }
+        else {
+            jsonSchema = schema;
+        }
+        const ajvSchema = new AjvSchema(jsonSchema, cfg);
+        AjvSchema.cacheAjvSchema(schema, ajvSchema);
+        return ajvSchema;
     }
     /**
-     * @experimental
+     * @deprecated
+     *
+     * Use `AjvSchema.create`
      */
     static createFromZod(zodSchema, cfg) {
-        if (AjvSchema.isZodSchemaWithAjvSchema(zodSchema)) {
-            return AjvSchema.requireCachedAjvSchemaFromZodSchema(zodSchema);
-        }
-        const jsonSchema = z.toJSONSchema(zodSchema, { target: 'draft-7' });
-        const ajvSchema = new AjvSchema(jsonSchema, cfg);
-        AjvSchema.cacheAjvSchemaInZodSchema(zodSchema, ajvSchema);
-        return ajvSchema;
+        return AjvSchema.create(zodSchema, cfg);
+    }
+    static isJsonSchemaBuilder(schema) {
+        return schema instanceof JsonSchemaAnyBuilder;
+    }
+    static isZodSchema(schema) {
+        return schema instanceof ZodType;
     }
     cfg;
     /**
@@ -121,14 +133,14 @@ export class AjvSchema {
             });
         };
     }
-    static isZodSchemaWithAjvSchema(schema) {
-        return !!schema[HIDDEN_AJV_SCHEMA];
+    static isSchemaWithCachedAjvSchema(schema) {
+        return !!schema?.[HIDDEN_AJV_SCHEMA];
     }
-    static cacheAjvSchemaInZodSchema(zodSchema, ajvSchema) {
-        return Object.assign(zodSchema, { [HIDDEN_AJV_SCHEMA]: ajvSchema });
+    static cacheAjvSchema(schema, ajvSchema) {
+        return Object.assign(schema, { [HIDDEN_AJV_SCHEMA]: ajvSchema });
     }
-    static requireCachedAjvSchemaFromZodSchema(zodSchema) {
-        return zodSchema[HIDDEN_AJV_SCHEMA];
+    static requireCachedAjvSchema(schema) {
+        return schema[HIDDEN_AJV_SCHEMA];
     }
     getAJVValidateFunction = _lazyValue(() => this.cfg.ajv.compile(this.schema));
 }

package/dist/validation/ajv/getAjv.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
+/* eslint-disable unicorn/prefer-code-point */
 import { _lazyValue } from '@naturalcycles/js-lib';
 import { Ajv } from 'ajv';
 import ajvFormats from 'ajv-formats';
@@ -66,6 +68,7 @@ const TS_2500 = 16725225600; // 2500-01-01
 const TS_2500_MILLIS = TS_2500 * 1000;
 const TS_2000 = 946684800; // 2000-01-01
 const TS_2000_MILLIS = TS_2000 * 1000;
+const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 function addCustomAjvFormats(ajv) {
     return (ajv
         .addFormat('id', /^[a-z0-9_]{6,64}$/)
@@ -116,5 +119,131 @@ function addCustomAjvFormats(ajv) {
             // multipleOf 15 (minutes)
             return n >= -14 && n <= 14 && Number.isInteger(n);
         },
+    })
+        .addFormat('IsoDate', {
+        type: 'string',
+        validate: isIsoDateValid,
+    })
+        .addFormat('IsoDateTime', {
+        type: 'string',
+        validate: isIsoDateTimeValid,
     }));
 }
+const DASH_CODE = '-'.charCodeAt(0);
+const ZERO_CODE = '0'.charCodeAt(0);
+const PLUS_CODE = '+'.charCodeAt(0);
+const COLON_CODE = ':'.charCodeAt(0);
+/**
+ * This is a performance optimized correct validation
+ * for ISO dates formatted as YYYY-MM-DD.
+ *
+ * - Slightly more performant than using `localDate`.
+ * - More performant than string splitting and `Number()` conversions
+ * - Less performant than regex, but it does not allow invalid dates.
+ */
+function isIsoDateValid(s) {
+    // must be exactly "YYYY-MM-DD"
+    if (s.length !== 10)
+        return false;
+    if (s.charCodeAt(4) !== DASH_CODE || s.charCodeAt(7) !== DASH_CODE)
+        return false;
+    // fast parse numbers without substrings/Number()
+    const year = (s.charCodeAt(0) - ZERO_CODE) * 1000 +
+        (s.charCodeAt(1) - ZERO_CODE) * 100 +
+        (s.charCodeAt(2) - ZERO_CODE) * 10 +
+        (s.charCodeAt(3) - ZERO_CODE);
+    const month = (s.charCodeAt(5) - ZERO_CODE) * 10 + (s.charCodeAt(6) - ZERO_CODE);
+    const day = (s.charCodeAt(8) - ZERO_CODE) * 10 + (s.charCodeAt(9) - ZERO_CODE);
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    if (month !== 2) {
+        return day <= monthLengths[month];
+    }
+    const isLeap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return day <= (isLeap ? 29 : 28);
+}
+/**
+ * This is a performance optimized correct validation
+ * for ISO datetimes formatted as "YYYY-MM-DDTHH:MM:SS" followed by
+ * nothing, "Z" or "+hh:mm" or "-hh:mm".
+ *
+ * - Slightly more performant than using `localTime`.
+ * - More performant than string splitting and `Number()` conversions
+ * - Less performant than regex, but it does not allow invalid dates.
+ */
+function isIsoDateTimeValid(s) {
+    if (s.length < 19 || s.length > 25)
+        return false;
+    if (s.charCodeAt(10) !== 84)
+        return false; // 'T'
+    const datePart = s.slice(0, 10); // YYYY-MM-DD
+    if (!isIsoDateValid(datePart))
+        return false;
+    const timePart = s.slice(11, 19); // HH:MM:SS
+    if (!isIsoTimeValid(timePart))
+        return false;
+    const zonePart = s.slice(19); // nothing or Z or +/-hh:mm
+    if (!isIsoTimezoneValid(zonePart))
+        return false;
+    return true;
+}
+/**
+ * This is a performance optimized correct validation
+ * for ISO times formatted as "HH:MM:SS".
+ *
+ * - Slightly more performant than using `localTime`.
+ * - More performant than string splitting and `Number()` conversions
+ * - Less performant than regex, but it does not allow invalid dates.
+ */
+function isIsoTimeValid(s) {
+    if (s.length !== 8)
+        return false;
+    if (s.charCodeAt(2) !== COLON_CODE || s.charCodeAt(5) !== COLON_CODE)
+        return false;
+    const hour = (s.charCodeAt(0) - ZERO_CODE) * 10 + (s.charCodeAt(1) - ZERO_CODE);
+    if (hour < 0 || hour > 23)
+        return false;
+    const minute = (s.charCodeAt(3) - ZERO_CODE) * 10 + (s.charCodeAt(4) - ZERO_CODE);
+    if (minute < 0 || minute > 59)
+        return false;
+    const second = (s.charCodeAt(6) - ZERO_CODE) * 10 + (s.charCodeAt(7) - ZERO_CODE);
+    if (second < 0 || second > 59)
+        return false;
+    return true;
+}
+/**
+ * This is a performance optimized correct validation
+ * for the timezone suffix of ISO times
+ * formatted as "Z" or "+HH:MM" or "-HH:MM".
+ *
+ * It also accepts an empty string.
+ */
+function isIsoTimezoneValid(s) {
+    if (s === '')
+        return true;
+    if (s === 'Z')
+        return true;
+    if (s.length !== 6)
+        return false;
+    if (s.charCodeAt(0) !== PLUS_CODE && s.charCodeAt(0) !== DASH_CODE)
+        return false;
+    if (s.charCodeAt(3) !== COLON_CODE)
+        return false;
+    const isWestern = s[0] === '-';
+    const isEastern = s[0] === '+';
+    const hour = (s.charCodeAt(1) - ZERO_CODE) * 10 + (s.charCodeAt(2) - ZERO_CODE);
+    if (hour < 0)
+        return false;
+    if (isWestern && hour > 12)
+        return false;
+    if (isEastern && hour > 14)
+        return false;
+    const minute = (s.charCodeAt(4) - ZERO_CODE) * 10 + (s.charCodeAt(5) - ZERO_CODE);
+    if (minute < 0 || minute > 59)
+        return false;
+    if (isEastern && hour === 14 && minute > 0)
+        return false; // max is +14:00
+    if (isWestern && hour === 12 && minute > 0)
+        return false; // min is -12:00
+    return true;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.33.0",
+  "version": "15.35.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

package/src/cache/lruMemoCache.ts

@@ -8,7 +8,7 @@ export type LRUMemoCacheOptions<KEY, VALUE> = Partial<LRUCache.Options<KEY, VALU
  * @example
  * Use it like this:
  *
- * @_Memo({ cacheFactory: () => new LRUMemoCache({...}) })
+ * `@_Memo({ cacheFactory: () => new LRUMemoCache({...}) })`
  * method1 ()
  */
 export class LRUMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {

package/src/csv/csvReader.ts

@@ -48,7 +48,7 @@ export function csvStringParse<T extends AnyObject = any>(
   _assert(header, `firstRowIsHeader or columns is required`)
 
   return arr.map(row => {
-    // eslint-disable-next-line unicorn/no-array-reduce
+    // oxlint-disable-next-line unicorn/no-array-reduce
     return header.reduce((obj, col, i) => {
       ;(obj as any)[col] = row[i]
       return obj

package/src/exec2/exec2.ts

@@ -129,6 +129,7 @@ class Exec2 {
         process.stdout.write((err as any).stdout)
       }
       this.logFinish(cmd, opt, started, false)
+      // oxlint-disable-next-line preserve-caught-error
       throw new Error(`exec exited with code ${(err as any).status}: ${cmd}`)
     }
   }

package/src/infra/process.util.ts

@@ -96,7 +96,7 @@ class ProcessUtil {
     idle: number
     total: number
   } {
-    // eslint-disable-next-line unicorn/no-array-reduce
+    // oxlint-disable-next-line unicorn/no-array-reduce
     return os.cpus().reduce(
       (r, cpu) => {
         r['idle'] += cpu.times.idle

package/src/slack/slack.service.model.ts

@@ -51,7 +51,7 @@ export interface SlackMessage<CTX = any> extends SlackMessageProps {
   kv?: AnyObject
 
   /**
-   * If specified - adds @name1, @name2 in the end of the message
+   * If specified - adds `@name1`, `@name2` in the end of the message
    */
   mentions?: string[]
 

package/src/stream/ndjson/ndjson.model.ts

@@ -12,7 +12,7 @@ export class NDJsonStats {
   }
 
   static createCombined(stats: NDJsonStats[]): NDJsonStats {
-    // eslint-disable-next-line unicorn/no-array-reduce
+    // oxlint-disable-next-line unicorn/no-array-reduce
     return stats.reduce((statsTotal, stats) => statsTotal.add(stats), new NDJsonStats())
   }
 

package/src/stream/pipeline.ts

@@ -1,8 +1,7 @@
 import { Readable, type Transform } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import type { ReadableStream as WebReadableStream } from 'node:stream/web'
-import { createUnzip, type ZlibOptions } from 'node:zlib'
-import { createGzip } from 'node:zlib'
+import { createGzip, createUnzip, type ZlibOptions } from 'node:zlib'
 import { createAbortableSignal } from '@naturalcycles/js-lib'
 import {
   _passthroughPredicate,

package/src/stream/readable/createReadable.ts

@@ -1,5 +1,4 @@
-import { type ReadableOptions, Transform } from 'node:stream'
-import { Readable } from 'node:stream'
+import { Readable, type ReadableOptions, Transform } from 'node:stream'
 import type { ReadableTyped } from '../stream.model.js'
 
 /**

package/src/stream/stream.model.ts

@@ -49,11 +49,11 @@ export interface ReadableTyped<T = unknown> extends Readable {
   drop: (limit: number, opt?: ReadableSignalOptions) => ReadableTyped<T>
 }
 
-// biome-ignore lint/correctness/noUnusedVariables: ok
+// oxlint-disable no-unused-vars
 export interface WritableTyped<T> extends Writable {}
 
-// biome-ignore lint/correctness/noUnusedVariables: ok
 export interface TransformTyped<IN = unknown, OUT = unknown> extends Transform {}
+// oxlint-enable
 
 export interface TransformOptions {
   /**

package/src/stream/transform/transformThrottle.ts

@@ -54,8 +54,8 @@ export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTy
     async transform(item: T, _, cb) {
       // console.log('incoming', item, { paused: !!paused, count })
       if (!start) {
-        start = Date.now() as UnixTimestampMillis
-        timeout = setTimeout(() => onInterval(this), interval * 1000)
+        start = localTime.nowUnixMillis()
+        timeout = setTimeout(() => onInterval(), interval * 1000)
         logger.log(`${localTime.now().toPretty()} transformThrottle started with`, {
           throughput,
           interval,
@@ -84,7 +84,7 @@ export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTy
     },
   })
 
-  function onInterval(transform: Transform): void {
+  function onInterval(): void {
     if (lock) {
       logger.log(`${localTime.now().toPretty()} transformThrottle resumed`)
       lock.resolve()
@@ -97,6 +97,6 @@ export function transformThrottle<T>(opt: TransformThrottleOptions): TransformTy
 
     count = 0
     start = localTime.nowUnixMillis()
-    timeout = setTimeout(() => onInterval(transform), interval * 1000)
+    timeout = setTimeout(() => onInterval(), interval * 1000)
   }
 }

package/src/util/env.util.ts

@@ -11,7 +11,7 @@ import { fs2 } from '../fs/fs2.js'
 export function requireEnvKeys<T extends readonly string[]>(
   ...keys: T
 ): { [k in ValuesOf<T>]: string } {
-  // eslint-disable-next-line unicorn/no-array-reduce
+  // oxlint-disable-next-line unicorn/no-array-reduce
   return keys.reduce(
     (r, k) => {
       const v = process.env[k]

package/src/validation/ajv/ajvSchema.ts

@@ -8,12 +8,15 @@ import type { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib/json-s
 import { JsonSchemaAnyBuilder } from '@naturalcycles/js-lib/json-schema'
 import { _deepCopy, _filterNullishValues } from '@naturalcycles/js-lib/object'
 import { _substringBefore } from '@naturalcycles/js-lib/string'
+import type { AnyObject } from '@naturalcycles/js-lib/types'
 import { z, ZodType } from '@naturalcycles/js-lib/zod'
 import type { Ajv } from 'ajv'
 import { _inspect } from '../../string/inspect.js'
 import { AjvValidationError } from './ajvValidationError.js'
 import { getAjv } from './getAjv.js'
 
+export type SchemaHandledByAjv<T> = JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T> | ZodType<T>
+
 export interface AjvValidationOptions {
   /**
    * Defaults to true,
@@ -104,32 +107,44 @@ export class AjvSchema<T = unknown> {
    * Implementation note: JsonSchemaBuilder goes first in the union type, otherwise TypeScript fails to infer <T> type
    * correctly for some reason.
    */
-  static create<T>(
-    schema: JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T> | ZodType<T>,
-    cfg?: Partial<AjvSchemaCfg>,
-  ): AjvSchema<T> {
+  static create<T>(schema: SchemaHandledByAjv<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T> {
     if (schema instanceof AjvSchema) return schema
-    if (schema instanceof JsonSchemaAnyBuilder) {
-      return new AjvSchema<T>(schema.build(), cfg)
+
+    if (AjvSchema.isSchemaWithCachedAjvSchema<typeof schema, T>(schema)) {
+      return AjvSchema.requireCachedAjvSchema<typeof schema, T>(schema)
     }
-    if (schema instanceof ZodType) return AjvSchema.createFromZod(schema)
-    return new AjvSchema<T>(schema as JsonSchema<T>, cfg)
+
+    let jsonSchema: JsonSchema<T>
+
+    if (AjvSchema.isJsonSchemaBuilder(schema)) {
+      jsonSchema = schema.build()
+    } else if (AjvSchema.isZodSchema(schema)) {
+      jsonSchema = z.toJSONSchema(schema, { target: 'draft-7' }) as JsonSchema<T>
+    } else {
+      jsonSchema = schema
+    }
+
+    const ajvSchema = new AjvSchema<T>(jsonSchema, cfg)
+    AjvSchema.cacheAjvSchema(schema, ajvSchema)
+
+    return ajvSchema
   }
 
   /**
-   * @experimental
+   * @deprecated
+   *
+   * Use `AjvSchema.create`
    */
   static createFromZod<T>(zodSchema: ZodType<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T> {
-    if (AjvSchema.isZodSchemaWithAjvSchema(zodSchema)) {
-      return AjvSchema.requireCachedAjvSchemaFromZodSchema(zodSchema)
-    }
-
-    const jsonSchema = z.toJSONSchema(zodSchema, { target: 'draft-7' })
-    const ajvSchema = new AjvSchema<T>(jsonSchema as JsonSchema<T>, cfg)
+    return AjvSchema.create(zodSchema, cfg)
+  }
 
-    AjvSchema.cacheAjvSchemaInZodSchema(zodSchema, ajvSchema)
+  static isJsonSchemaBuilder<T>(schema: unknown): schema is JsonSchemaBuilder<T> {
+    return schema instanceof JsonSchemaAnyBuilder
+  }
 
-    return ajvSchema
+  static isZodSchema<T>(schema: unknown): schema is ZodType<T> {
+    return schema instanceof ZodType
   }
 
   readonly cfg: AjvSchemaCfg
@@ -208,19 +223,21 @@ export class AjvSchema<T = unknown> {
     }
   }
 
-  static isZodSchemaWithAjvSchema<T>(schema: ZodType<T>): schema is ZodTypeWithAjvSchema<T> {
-    return !!(schema as any)[HIDDEN_AJV_SCHEMA]
+  static isSchemaWithCachedAjvSchema<Base, T>(
+    schema: Base,
+  ): schema is WithCachedAjvSchema<Base, T> {
+    return !!(schema as any)?.[HIDDEN_AJV_SCHEMA]
   }
 
-  static cacheAjvSchemaInZodSchema<T>(
-    zodSchema: ZodType<T>,
+  static cacheAjvSchema<Base extends AnyObject, T>(
+    schema: Base,
     ajvSchema: AjvSchema<T>,
-  ): ZodTypeWithAjvSchema<T> {
-    return Object.assign(zodSchema, { [HIDDEN_AJV_SCHEMA]: ajvSchema })
+  ): WithCachedAjvSchema<Base, T> {
+    return Object.assign(schema, { [HIDDEN_AJV_SCHEMA]: ajvSchema })
   }
 
-  static requireCachedAjvSchemaFromZodSchema<T>(zodSchema: ZodTypeWithAjvSchema<T>): AjvSchema<T> {
-    return zodSchema[HIDDEN_AJV_SCHEMA]
+  static requireCachedAjvSchema<Base, T>(schema: WithCachedAjvSchema<Base, T>): AjvSchema<T> {
+    return schema[HIDDEN_AJV_SCHEMA]
   }
 
   private getAJVValidateFunction = _lazyValue(() => this.cfg.ajv.compile<T>(this.schema))
@@ -230,6 +247,6 @@ const separator = '\n'
 
 export const HIDDEN_AJV_SCHEMA = Symbol('HIDDEN_AJV_SCHEMA')
 
-export interface ZodTypeWithAjvSchema<T> extends ZodType<T> {
+export type WithCachedAjvSchema<Base, T> = Base & {
   [HIDDEN_AJV_SCHEMA]: AjvSchema<T>
 }

package/src/validation/ajv/getAjv.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
+/* eslint-disable unicorn/prefer-code-point */
 import { _lazyValue } from '@naturalcycles/js-lib'
 import type { Options } from 'ajv'
 import { Ajv } from 'ajv'
@@ -79,6 +81,8 @@ const TS_2500_MILLIS = TS_2500 * 1000
 const TS_2000 = 946684800 // 2000-01-01
 const TS_2000_MILLIS = TS_2000 * 1000
 
+const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
 function addCustomAjvFormats(ajv: Ajv): Ajv {
   return (
     ajv
@@ -131,5 +135,131 @@ function addCustomAjvFormats(ajv: Ajv): Ajv {
           return n >= -14 && n <= 14 && Number.isInteger(n)
         },
       })
+      .addFormat('IsoDate', {
+        type: 'string',
+        validate: isIsoDateValid,
+      })
+      .addFormat('IsoDateTime', {
+        type: 'string',
+        validate: isIsoDateTimeValid,
+      })
   )
 }
+
+const DASH_CODE = '-'.charCodeAt(0)
+const ZERO_CODE = '0'.charCodeAt(0)
+const PLUS_CODE = '+'.charCodeAt(0)
+const COLON_CODE = ':'.charCodeAt(0)
+
+/**
+ * This is a performance optimized correct validation
+ * for ISO dates formatted as YYYY-MM-DD.
+ *
+ * - Slightly more performant than using `localDate`.
+ * - More performant than string splitting and `Number()` conversions
+ * - Less performant than regex, but it does not allow invalid dates.
+ */
+function isIsoDateValid(s: string): boolean {
+  // must be exactly "YYYY-MM-DD"
+  if (s.length !== 10) return false
+  if (s.charCodeAt(4) !== DASH_CODE || s.charCodeAt(7) !== DASH_CODE) return false
+
+  // fast parse numbers without substrings/Number()
+  const year =
+    (s.charCodeAt(0) - ZERO_CODE) * 1000 +
+    (s.charCodeAt(1) - ZERO_CODE) * 100 +
+    (s.charCodeAt(2) - ZERO_CODE) * 10 +
+    (s.charCodeAt(3) - ZERO_CODE)
+
+  const month = (s.charCodeAt(5) - ZERO_CODE) * 10 + (s.charCodeAt(6) - ZERO_CODE)
+  const day = (s.charCodeAt(8) - ZERO_CODE) * 10 + (s.charCodeAt(9) - ZERO_CODE)
+
+  if (month < 1 || month > 12 || day < 1) return false
+
+  if (month !== 2) {
+    return day <= monthLengths[month]!
+  }
+
+  const isLeap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0
+  return day <= (isLeap ? 29 : 28)
+}
+
+/**
+ * This is a performance optimized correct validation
+ * for ISO datetimes formatted as "YYYY-MM-DDTHH:MM:SS" followed by
+ * nothing, "Z" or "+hh:mm" or "-hh:mm".
+ *
+ * - Slightly more performant than using `localTime`.
+ * - More performant than string splitting and `Number()` conversions
+ * - Less performant than regex, but it does not allow invalid dates.
+ */
+function isIsoDateTimeValid(s: string): boolean {
+  if (s.length < 19 || s.length > 25) return false
+  if (s.charCodeAt(10) !== 84) return false // 'T'
+
+  const datePart = s.slice(0, 10) // YYYY-MM-DD
+  if (!isIsoDateValid(datePart)) return false
+
+  const timePart = s.slice(11, 19) // HH:MM:SS
+  if (!isIsoTimeValid(timePart)) return false
+
+  const zonePart = s.slice(19) // nothing or Z or +/-hh:mm
+  if (!isIsoTimezoneValid(zonePart)) return false
+
+  return true
+}
+
+/**
+ * This is a performance optimized correct validation
+ * for ISO times formatted as "HH:MM:SS".
+ *
+ * - Slightly more performant than using `localTime`.
+ * - More performant than string splitting and `Number()` conversions
+ * - Less performant than regex, but it does not allow invalid dates.
+ */
+function isIsoTimeValid(s: string): boolean {
+  if (s.length !== 8) return false
+  if (s.charCodeAt(2) !== COLON_CODE || s.charCodeAt(5) !== COLON_CODE) return false
+
+  const hour = (s.charCodeAt(0) - ZERO_CODE) * 10 + (s.charCodeAt(1) - ZERO_CODE)
+  if (hour < 0 || hour > 23) return false
+
+  const minute = (s.charCodeAt(3) - ZERO_CODE) * 10 + (s.charCodeAt(4) - ZERO_CODE)
+  if (minute < 0 || minute > 59) return false
+
+  const second = (s.charCodeAt(6) - ZERO_CODE) * 10 + (s.charCodeAt(7) - ZERO_CODE)
+  if (second < 0 || second > 59) return false
+
+  return true
+}
+
+/**
+ * This is a performance optimized correct validation
+ * for the timezone suffix of ISO times
+ * formatted as "Z" or "+HH:MM" or "-HH:MM".
+ *
+ * It also accepts an empty string.
+ */
+function isIsoTimezoneValid(s: string): boolean {
+  if (s === '') return true
+  if (s === 'Z') return true
+  if (s.length !== 6) return false
+  if (s.charCodeAt(0) !== PLUS_CODE && s.charCodeAt(0) !== DASH_CODE) return false
+  if (s.charCodeAt(3) !== COLON_CODE) return false
+
+  const isWestern = s[0] === '-'
+  const isEastern = s[0] === '+'
+
+  const hour = (s.charCodeAt(1) - ZERO_CODE) * 10 + (s.charCodeAt(2) - ZERO_CODE)
+  if (hour < 0) return false
+  if (isWestern && hour > 12) return false
+  if (isEastern && hour > 14) return false
+
+  const minute = (s.charCodeAt(4) - ZERO_CODE) * 10 + (s.charCodeAt(5) - ZERO_CODE)
+  if (minute < 0 || minute > 59) return false
+
+  if (isEastern && hour === 14 && minute > 0) return false // max is +14:00
+  if (isWestern && hour === 12 && minute > 0) return false // min is -12:00
+
+  return true
+}