@naturalcycles/js-lib 14.255.0 → 14.257.0

package/dist/browser/imageFitter.d.ts

@@ -0,0 +1,60 @@
+export interface FitImagesCfg {
+    /**
+     * Container of the images
+     */
+    containerElement: HTMLElement;
+    /**
+     * Array of image metadatas (most notably: aspectRatio).
+     */
+    images: FitImage[];
+    /**
+     * Will be called on each layout change.
+     * Should be listened to to update the width/height of the images in your DOM.
+     */
+    onChange: (images: FitImage[]) => any;
+    /**
+     * Max image height in pixels.
+     *
+     * @default 300
+     */
+    maxHeight?: number;
+    /**
+     * Margin between images.
+     *
+     * @default 8
+     */
+    margin?: number;
+}
+export interface FitImage {
+    src: string;
+    /**
+     * width divided by height
+     */
+    aspectRatio: number;
+    /**
+     * Calculated image width to fit the layout.
+     */
+    fitWidth?: number;
+    /**
+     * Calculated image height to fit the layout.
+     */
+    fitHeight?: number;
+}
+/**
+ * Calculates the width/height of the images to fit in the layout.
+ *
+ * Currently does not mutate the cfg.images array, but DOES mutate individual images with .fitWidth, .fitHeight properties.
+ *
+ * @experimental
+ */
+export declare class ImageFitter {
+    constructor(cfg: FitImagesCfg);
+    cfg: Required<FitImagesCfg>;
+    resizeObserver: ResizeObserver;
+    containerWidth: number;
+    stop(): void;
+    private update;
+    private doLayout;
+    private getHeigth;
+    private setHeight;
+}

package/dist/browser/imageFitter.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageFitter = void 0;
+/**
+ * Calculates the width/height of the images to fit in the layout.
+ *
+ * Currently does not mutate the cfg.images array, but DOES mutate individual images with .fitWidth, .fitHeight properties.
+ *
+ * @experimental
+ */
+class ImageFitter {
+    constructor(cfg) {
+        this.containerWidth = -1;
+        this.cfg = {
+            maxHeight: 300,
+            margin: 8,
+            ...cfg,
+        };
+        this.resizeObserver = new ResizeObserver(entries => this.update(entries));
+        this.resizeObserver.observe(cfg.containerElement);
+    }
+    stop() {
+        this.resizeObserver.disconnect();
+    }
+    update(entries) {
+        const width = Math.floor(entries[0].contentRect.width);
+        if (width === this.containerWidth)
+            return; // we're only interested in width changes
+        this.containerWidth = width;
+        console.log(`resize ${width}`);
+        this.doLayout(this.cfg.images);
+        this.cfg.onChange(this.cfg.images);
+    }
+    doLayout(imgs) {
+        if (imgs.length === 0)
+            return; // nothing to do
+        const { maxHeight } = this.cfg;
+        let imgNodes = imgs.slice(0);
+        w: while (imgNodes.length > 0) {
+            let slice;
+            let h;
+            for (let i = 1; i <= imgNodes.length; i++) {
+                slice = imgNodes.slice(0, i);
+                h = this.getHeigth(slice);
+                if (h < maxHeight) {
+                    this.setHeight(slice, h);
+                    imgNodes = imgNodes.slice(i);
+                    continue w;
+                }
+            }
+            this.setHeight(slice, Math.min(maxHeight, h));
+            break;
+        }
+    }
+    getHeigth(images) {
+        const width = this.containerWidth - images.length * this.cfg.margin;
+        let r = 0;
+        images.forEach(img => (r += img.aspectRatio));
+        return width / r; // have to round down because Firefox will automatically roundup value with number of decimals > 3
+    }
+    // mutates/sets images' fitWidth, fitHeight properties
+    setHeight(images, height) {
+        images.forEach(img => {
+            img.fitWidth = Math.floor(height * img.aspectRatio);
+            img.fitHeight = Math.floor(height);
+        });
+    }
+}
+exports.ImageFitter = ImageFitter;

package/dist/browser/script.util.d.ts

@@ -0,0 +1,14 @@
+export type LoadScriptOptions = Partial<HTMLScriptElement>;
+export type LoadCSSOptions = Partial<HTMLLinkElement>;
+/**
+ * opt.async defaults to `true`.
+ * No other options are set by default.
+ */
+export declare function loadScript(src: string, opt?: LoadScriptOptions): Promise<void>;
+/**
+ * Default options:
+ * rel: 'stylesheet'
+ *
+ * No other options are set by default.
+ */
+export declare function loadCSS(href: string, opt?: LoadCSSOptions): Promise<void>;

package/dist/browser/script.util.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadScript = loadScript;
+exports.loadCSS = loadCSS;
+const env_1 = require("../env");
+const types_1 = require("../types");
+/**
+ * opt.async defaults to `true`.
+ * No other options are set by default.
+ */
+async function loadScript(src, opt) {
+    if ((0, env_1.isServerSide)())
+        return;
+    return await new Promise((resolve, reject) => {
+        const s = (0, types_1._objectAssign)(document.createElement('script'), {
+            src,
+            async: true,
+            ...opt,
+            onload: resolve,
+            onerror: (_event, _source, _lineno, _colno, err) => {
+                reject(err || new Error(`loadScript failed: ${src}`));
+            },
+        });
+        document.head.append(s);
+    });
+}
+/**
+ * Default options:
+ * rel: 'stylesheet'
+ *
+ * No other options are set by default.
+ */
+async function loadCSS(href, opt) {
+    if ((0, env_1.isServerSide)())
+        return;
+    return await new Promise((resolve, reject) => {
+        const link = (0, types_1._objectAssign)(document.createElement('link'), {
+            href,
+            rel: 'stylesheet',
+            // type seems to be unnecessary: https://stackoverflow.com/a/5409146/4919972
+            // type: 'text/css',
+            ...opt,
+            onload: resolve,
+            onerror: (_event, _source, _lineno, _colno, err) => {
+                reject(err || new Error(`loadCSS failed: ${href}`));
+            },
+        });
+        document.head.append(link);
+    });
+}

package/dist/browser/topbar.d.ts

@@ -0,0 +1,23 @@
+export interface TopBarOptions {
+    /**
+     * @default true
+     */
+    autoRun?: boolean;
+    /**
+     * @default 5
+     */
+    barThickness?: number;
+    barColors?: any;
+    shadowColor?: any;
+    /**
+     * @default 10
+     */
+    shadowBlur?: number;
+}
+export declare const topbar: {
+    config(opts: TopBarOptions): void;
+    set(show: boolean, opts?: TopBarOptions): void;
+    show(opts?: TopBarOptions): void;
+    progress(to: number | string): any;
+    hide(): void;
+};

package/dist/browser/topbar.js

@@ -0,0 +1,137 @@
+"use strict";
+// Modified version of topbar:
+// http://buunguyen.github.io/topbar
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topbar = void 0;
+const browser = typeof window !== 'undefined';
+let canvas;
+let progressTimerId;
+let fadeTimerId;
+let currentProgress;
+let showing;
+const addEvent = (elem, type, handler) => {
+    if (elem.addEventListener)
+        elem.addEventListener(type, handler, false);
+    else if (elem.attachEvent)
+        elem.attachEvent('on' + type, handler);
+    else
+        elem['on' + type] = handler;
+};
+const options = {
+    autoRun: true,
+    barThickness: 5,
+    barColors: {
+        '0': 'rgba(26,  188, 156, .9)',
+        '.25': 'rgba(52,  152, 219, .9)',
+        '.50': 'rgba(241, 196, 15,  .9)',
+        '.75': 'rgba(230, 126, 34,  .9)',
+        '1.0': 'rgba(211, 84,  0,   .9)',
+    },
+    shadowBlur: 10,
+    shadowColor: 'rgba(0,   0,   0,   .6)',
+};
+const repaint = () => {
+    canvas.width = window.innerWidth;
+    canvas.height = options.barThickness * 5; // need space for shadow
+    const ctx = canvas.getContext('2d');
+    ctx.shadowBlur = options.shadowBlur;
+    ctx.shadowColor = options.shadowColor;
+    const lineGradient = ctx.createLinearGradient(0, 0, canvas.width, 0);
+    for (const stop in options.barColors) {
+        // @ts-ignore
+        lineGradient.addColorStop(stop, options.barColors[stop]);
+    }
+    ctx.lineWidth = options.barThickness;
+    ctx.beginPath();
+    ctx.moveTo(0, options.barThickness / 2);
+    ctx.lineTo(Math.ceil(currentProgress * canvas.width), options.barThickness / 2);
+    ctx.strokeStyle = lineGradient;
+    ctx.stroke();
+};
+const createCanvas = () => {
+    canvas = document.createElement('canvas');
+    const style = canvas.style;
+    style.position = 'fixed';
+    style.top = style.left = style.right = style.margin = style.padding = 0;
+    style.zIndex = 100001;
+    style.display = 'none';
+    document.body.appendChild(canvas);
+    addEvent(window, 'resize', repaint);
+};
+exports.topbar = {
+    config(opts) {
+        for (const key in opts) {
+            if (options.hasOwnProperty(key)) {
+                // @ts-ignore
+                options[key] = opts[key];
+            }
+        }
+    },
+    set(show, opts) {
+        if (show) {
+            exports.topbar.show(opts);
+        }
+        else {
+            exports.topbar.hide();
+        }
+    },
+    show(opts) {
+        if (!browser)
+            return; // ssr protection
+        if (opts)
+            exports.topbar.config(opts);
+        if (showing)
+            return;
+        showing = true;
+        if (fadeTimerId !== null) {
+            window.cancelAnimationFrame(fadeTimerId);
+        }
+        if (!canvas)
+            createCanvas();
+        canvas.style.opacity = 1;
+        canvas.style.display = 'block';
+        exports.topbar.progress(0);
+        if (options.autoRun) {
+            ;
+            (function loop() {
+                progressTimerId = window.requestAnimationFrame(loop);
+                exports.topbar.progress('+' + 0.05 * (1 - Math.sqrt(currentProgress)) ** 2);
+            })();
+        }
+    },
+    progress(to) {
+        if (!browser)
+            return; // ssr protection
+        if (typeof to === 'undefined') {
+            return currentProgress;
+        }
+        if (typeof to === 'string') {
+            to = (to.indexOf('+') >= 0 || to.indexOf('-') >= 0 ? currentProgress : 0) + parseFloat(to);
+        }
+        currentProgress = to > 1 ? 1 : to;
+        repaint();
+        return currentProgress;
+    },
+    hide() {
+        if (!showing || !browser)
+            return;
+        showing = false;
+        if (progressTimerId != null) {
+            window.cancelAnimationFrame(progressTimerId);
+            progressTimerId = null;
+        }
+        ;
+        (function loop() {
+            if (exports.topbar.progress('+.1') >= 1) {
+                canvas.style.opacity -= 0.05;
+                if (canvas.style.opacity <= 0.05) {
+                    canvas.style.display = 'none';
+                    fadeTimerId = null;
+                    return;
+                }
+            }
+            fadeTimerId = window.requestAnimationFrame(loop);
+        })();
+    },
+};

package/dist/decorators/memo.util.d.ts

@@ -1,4 +1,5 @@
-import { MISS, UnixTimestampNumber } from '..';
+import type { UnixTimestampNumber } from '../types';
+import { MISS } from '../types';
 export type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
 export interface MemoCacheOptions {

package/dist/decorators/memo.util.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapAsyncMemoCache = exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
-const __1 = require("..");
+const is_util_1 = require("../is.util");
+const pDelay_1 = require("../promise/pDelay");
+const types_1 = require("../types");
 const jsonMemoSerializer = args => {
     if (args.length === 0)
         return undefined;
-    if (args.length === 1 && (0, __1._isPrimitive)(args[0]))
+    if (args.length === 1 && (0, is_util_1._isPrimitive)(args[0]))
         return args[0];
     return JSON.stringify(args);
 };
@@ -84,17 +86,17 @@ class MapAsyncMemoCache {
         this.m = new Map();
     }
     async get(k) {
-        await (0, __1.pDelay)(this.delay);
+        await (0, pDelay_1.pDelay)(this.delay);
         if (!this.m.has(k))
-            return __1.MISS;
+            return types_1.MISS;
         return this.m.get(k);
     }
     async set(k, v) {
-        await (0, __1.pDelay)(this.delay);
+        await (0, pDelay_1.pDelay)(this.delay);
         this.m.set(k, v);
     }
     async clear() {
-        await (0, __1.pDelay)(this.delay);
+        await (0, pDelay_1.pDelay)(this.delay);
         this.m.clear();
     }
 }

package/dist/decorators/swarmSafe.decorator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Prevents "swarm" of async calls to the same method.
+ * Allows max 1 in-flight promise to exist.
+ * If more calls appear, while Promise is not resolved yet - same Promise is returned.
+ *
+ * Does not support `cacheKey`.
+ * So, the same Promise is returned, regardless of the arguments.
+ */
+export declare const _SwarmSafe: () => MethodDecorator;

package/dist/decorators/swarmSafe.decorator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._SwarmSafe = void 0;
+const decorator_util_1 = require("./decorator.util");
+/**
+ * Prevents "swarm" of async calls to the same method.
+ * Allows max 1 in-flight promise to exist.
+ * If more calls appear, while Promise is not resolved yet - same Promise is returned.
+ *
+ * Does not support `cacheKey`.
+ * So, the same Promise is returned, regardless of the arguments.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const _SwarmSafe = () => (target, key, descriptor) => {
+    if (typeof descriptor.value !== 'function') {
+        throw new TypeError('@_SwarmSafe can be applied only to methods');
+    }
+    const originalFn = descriptor.value;
+    const keyStr = String(key);
+    const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
+    const instanceCache = new Map();
+    console.log('SwarmSafe constructor called', { key, methodSignature });
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    descriptor.value = function (...args) {
+        console.log('SwarmSafe method called', { key, methodSignature, args });
+        const ctx = this;
+        let inFlightPromise = instanceCache.get(ctx);
+        if (inFlightPromise) {
+            console.log(`SwarmSafe: returning in-flight promise`);
+            return inFlightPromise;
+        }
+        console.log(`SwarmSafe: first-time call, creating in-flight promise`);
+        inFlightPromise = originalFn.apply(ctx, args);
+        instanceCache.set(ctx, inFlightPromise);
+        void inFlightPromise.finally(() => {
+            console.log(`SwarmSafe: in-flight promise resolved`);
+            instanceCache.delete(ctx);
+        });
+        return inFlightPromise;
+    };
+};
+exports._SwarmSafe = _SwarmSafe;

package/dist/error/assert.d.ts

@@ -1,4 +1,5 @@
-import { BackendErrorResponseObject, Class, ErrorData, ErrorObject } from '..';
+import type { Class } from '../typeFest';
+import type { BackendErrorResponseObject, ErrorData, ErrorObject } from './error.model';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.

package/dist/error/assert.js

@@ -10,7 +10,9 @@ exports._assertIsBackendErrorResponseObject = _assertIsBackendErrorResponseObjec
 exports._assertIsString = _assertIsString;
 exports._assertIsNumber = _assertIsNumber;
 exports._assertTypeOf = _assertTypeOf;
-const __1 = require("..");
+const deepEquals_1 = require("../object/deepEquals");
+const stringify_1 = require("../string/stringify");
+const error_util_1 = require("./error.util");
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -30,7 +32,7 @@ const __1 = require("..");
 function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new __1.AssertionError(message || 'condition failed', {
+        throw new error_util_1.AssertionError(message || 'condition failed', {
             ...errorData,
         });
     }
@@ -44,10 +46,10 @@ message, errorData) {
 function _assertEquals(actual, expected, message, errorData) {
     if (actual !== expected) {
         const msg = message ||
-            ['not equal', `expected: ${(0, __1._stringify)(expected)}`, `got     : ${(0, __1._stringify)(actual)}`]
+            ['not equal', `expected: ${(0, stringify_1._stringify)(expected)}`, `got     : ${(0, stringify_1._stringify)(actual)}`]
                 .filter(Boolean)
                 .join('\n');
-        throw new __1.AssertionError(msg, {
+        throw new error_util_1.AssertionError(msg, {
             ...errorData,
         });
     }
@@ -59,19 +61,19 @@ function _assertEquals(actual, expected, message, errorData) {
  * Does DEEP equality via _deepEquals()
  */
 function _assertDeepEquals(actual, expected, message, errorData) {
-    if (!(0, __1._deepEquals)(actual, expected)) {
+    if (!(0, deepEquals_1._deepEquals)(actual, expected)) {
         const msg = message ||
-            ['not deeply equal', `expected: ${(0, __1._stringify)(expected)}`, `got     : ${(0, __1._stringify)(actual)}`]
+            ['not deeply equal', `expected: ${(0, stringify_1._stringify)(expected)}`, `got     : ${(0, stringify_1._stringify)(actual)}`]
                 .filter(Boolean)
                 .join('\n');
-        throw new __1.AssertionError(msg, {
+        throw new error_util_1.AssertionError(msg, {
             ...errorData,
         });
     }
 }
 function _assertIsError(err, errorClass = Error) {
     if (!(err instanceof errorClass)) {
-        throw new __1.AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`);
+        throw new error_util_1.AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`);
     }
 }
 /**
@@ -86,13 +88,13 @@ function _assertErrorClassOrRethrow(err, errorClass) {
     }
 }
 function _assertIsErrorObject(obj) {
-    if (!(0, __1._isErrorObject)(obj)) {
-        throw new __1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
+    if (!(0, error_util_1._isErrorObject)(obj)) {
+        throw new error_util_1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
 function _assertIsBackendErrorResponseObject(obj) {
-    if (!(0, __1._isBackendErrorResponseObject)(obj)) {
-        throw new __1.AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
+    if (!(0, error_util_1._isBackendErrorResponseObject)(obj)) {
+        throw new error_util_1.AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
     }
 }
 function _assertIsString(v, message) {
@@ -105,6 +107,6 @@ function _assertTypeOf(v, expectedType, message) {
     // biome-ignore lint/suspicious/useValidTypeof: ok
     if (typeof v !== expectedType) {
         const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
-        throw new __1.AssertionError(msg);
+        throw new error_util_1.AssertionError(msg);
     }
 }

package/dist/error/error.util.js

@@ -11,7 +11,10 @@ exports._isHttpRequestErrorObject = _isHttpRequestErrorObject;
 exports._isErrorObject = _isErrorObject;
 exports._isErrorLike = _isErrorLike;
 exports._errorDataAppend = _errorDataAppend;
-const __1 = require("..");
+const env_1 = require("../env");
+const json_util_1 = require("../string/json.util");
+const string_util_1 = require("../string/string.util");
+const stringify_1 = require("../string/stringify");
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).
@@ -51,7 +54,7 @@ function _anyToErrorObject(o, errorData) {
         eo = _errorLikeToErrorObject(o);
     }
     else {
-        o = (0, __1._jsonParseIfPossible)(o);
+        o = (0, json_util_1._jsonParseIfPossible)(o);
         if (_isBackendErrorResponseObject(o)) {
             eo = o.error;
         }
@@ -66,7 +69,7 @@ function _anyToErrorObject(o, errorData) {
             // so, fair to return `data: {}` in the end
             // Also we're sure it includes no "error name", e.g no `Error: ...`,
             // so, fair to include `name: 'Error'`
-            const message = (0, __1._stringify)(o);
+            const message = (0, stringify_1._stringify)(o);
             eo = {
                 name: 'Error',
                 message,
@@ -166,7 +169,7 @@ function _errorSnippet(err, opt = {}) {
         lines.push('Caused by ' + errorObjectToSnippet(cause));
         cause = cause.cause; // insert DiCaprio Inception meme
     }
-    return lines.map(line => (0, __1._truncate)(line, maxLineLength)).join('\n');
+    return lines.map(line => (0, string_util_1._truncate)(line, maxLineLength)).join('\n');
     function errorObjectToSnippet(e) {
         // Return snippet if it was already prepared
         if (e.data.snippet)
@@ -247,7 +250,7 @@ class AppError extends Error {
         super(message);
         // Here we default to `this.constructor.name` on Node, but to 'AppError' on the Frontend
         // because Frontend tends to minify class names, so `constructor.name` is not reliable
-        const { name = (0, __1.isServerSide)() ? this.constructor.name : 'AppError', cause } = opt;
+        const { name = (0, env_1.isServerSide)() ? this.constructor.name : 'AppError', cause } = opt;
         Object.defineProperties(this, {
             name: {
                 value: name,
@@ -324,7 +327,7 @@ class AssertionError extends AppError {
 exports.AssertionError = AssertionError;
 class JsonParseError extends AppError {
     constructor(data) {
-        const message = ['Failed to parse', data.text && (0, __1._truncateMiddle)(data.text, 200)]
+        const message = ['Failed to parse', data.text && (0, string_util_1._truncateMiddle)(data.text, 200)]
             .filter(Boolean)
             .join(': ');
         super(message, data, { name: 'JsonParseError' });

package/dist/index.d.ts

@@ -1,6 +1,14 @@
 export * from './abort';
 export * from './array/array.util';
 export * from './array/range';
+export * from './bot';
+export * from './browser/adminService';
+export * from './browser/analytics.util';
+export * from './browser/i18n/fetchTranslationLoader';
+export * from './browser/i18n/translation.service';
+export * from './browser/imageFitter';
+export * from './browser/script.util';
+export * from './browser/topbar';
 export * from './datetime/dateInterval';
 export * from './datetime/localDate';
 export * from './datetime/localTime';

package/dist/index.js

@@ -5,6 +5,14 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./abort"), exports);
 tslib_1.__exportStar(require("./array/array.util"), exports);
 tslib_1.__exportStar(require("./array/range"), exports);
+tslib_1.__exportStar(require("./bot"), exports);
+tslib_1.__exportStar(require("./browser/adminService"), exports);
+tslib_1.__exportStar(require("./browser/analytics.util"), exports);
+tslib_1.__exportStar(require("./browser/i18n/fetchTranslationLoader"), exports);
+tslib_1.__exportStar(require("./browser/i18n/translation.service"), exports);
+tslib_1.__exportStar(require("./browser/imageFitter"), exports);
+tslib_1.__exportStar(require("./browser/script.util"), exports);
+tslib_1.__exportStar(require("./browser/topbar"), exports);
 tslib_1.__exportStar(require("./datetime/dateInterval"), exports);
 tslib_1.__exportStar(require("./datetime/localDate"), exports);
 tslib_1.__exportStar(require("./datetime/localTime"), exports);

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

@@ -1,4 +1,4 @@
-import { ZodError, ZodIssue, ZodSchema } from 'zod';
+import { ZodError, type ZodIssue, type ZodSchema } from 'zod';
 export interface ZodErrorResult<T> {
     success: false;
     data?: T;