@naturalcycles/js-lib 14.256.0 → 14.258.0

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/deviceIdService.d.ts

@@ -0,0 +1,65 @@
+/// <reference lib="dom" preserve="true" />
+/**
+ * Service to generate, maintain, persist a stable "device id".
+ *
+ * It's called "device id" and not userId/visitorId, to indicate that it only identifies a device,
+ * and has nothing to do with user identification.
+ * User might be logged in or not.
+ * User id can be the same on multiple devices.
+ * DeviceId is unique per device, same User or not.
+ *
+ * Service provides methods to deterministically select fraction of devices.
+ * For example, select 10% of devices that visit the website to be tracked by Analytics
+ * (to reduce Analytics quota usage).
+ * DeviceId persistence will ensure that recurring visits from the same device will yield the same
+ * DeviceId, and same "selection assignment" (like an assignment in an AB test).
+ *
+ * @experimental
+ */
+export declare class DeviceIdService {
+    constructor(cfg?: DeviceIdServiceCfg);
+    cfg: Required<DeviceIdServiceCfg>;
+    /**
+     * `deviceId` is null only in anomalous cases, e.g when localStorage is not available (due to e.g "out of disk space" on device).
+     * In all other cases it should be defined and stable (persisted indefinitely between multiple visits).
+     *
+     * It is null if the service is run on the server side.
+     */
+    deviceId: string | null;
+    /**
+     * Selects this device based on "deterministic random selection", according to the defined `rate`.
+     * Rate is a floating number between 0 and 1.
+     * E.g rate of 0.1 means 10% chance of being selected.
+     *
+     * Selection is based on deviceId, which is generated random and persisted between visits.
+     * Persistence ensures that the selection (similar to an AB-test assignment) "sticks" to the device.
+     *
+     * If deviceId failed to be generated, e.g due to Device running out-of-space to save a string to localStorage,
+     * it will NOT be selected.
+     *
+     * @returns true if the device is selected.
+     */
+    select(rate: number): boolean;
+    /**
+     * Deletes the persisted deviceId.
+     * Keeps it in the service.
+     * To remove it from the service, assign deviceIdService.deviceId = null.
+     */
+    clearPersistence(): void;
+    /**
+     * Generates a stable Device id if it wasn't previously generated on this device.
+     * Otherwise, reads a Device id from persistent storage.
+     */
+    private init;
+    private debug;
+}
+export interface DeviceIdServiceCfg {
+    /**
+     * Default: deviceId
+     */
+    localStorageKey?: string;
+    /**
+     * Set to true to enable debug logging.
+     */
+    debug?: boolean;
+}

package/dist/deviceIdService.js

@@ -0,0 +1,109 @@
+"use strict";
+/// <reference lib="dom" preserve="true" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceIdService = void 0;
+const env_1 = require("./env");
+const nanoid_1 = require("./nanoid");
+const hash_util_1 = require("./string/hash.util");
+// This is in sync with the default length in Nanoid.
+const deviceIdLength = 21;
+/**
+ * Service to generate, maintain, persist a stable "device id".
+ *
+ * It's called "device id" and not userId/visitorId, to indicate that it only identifies a device,
+ * and has nothing to do with user identification.
+ * User might be logged in or not.
+ * User id can be the same on multiple devices.
+ * DeviceId is unique per device, same User or not.
+ *
+ * Service provides methods to deterministically select fraction of devices.
+ * For example, select 10% of devices that visit the website to be tracked by Analytics
+ * (to reduce Analytics quota usage).
+ * DeviceId persistence will ensure that recurring visits from the same device will yield the same
+ * DeviceId, and same "selection assignment" (like an assignment in an AB test).
+ *
+ * @experimental
+ */
+class DeviceIdService {
+    constructor(cfg = {}) {
+        this.cfg = {
+            localStorageKey: 'deviceId',
+            debug: false,
+            ...cfg,
+        };
+        this.init();
+    }
+    /**
+     * Selects this device based on "deterministic random selection", according to the defined `rate`.
+     * Rate is a floating number between 0 and 1.
+     * E.g rate of 0.1 means 10% chance of being selected.
+     *
+     * Selection is based on deviceId, which is generated random and persisted between visits.
+     * Persistence ensures that the selection (similar to an AB-test assignment) "sticks" to the device.
+     *
+     * If deviceId failed to be generated, e.g due to Device running out-of-space to save a string to localStorage,
+     * it will NOT be selected.
+     *
+     * @returns true if the device is selected.
+     */
+    select(rate) {
+        if (!this.deviceId) {
+            this.debug(`deviceId is null, skipping selection`);
+            return false;
+        }
+        const mod = Math.trunc(rate * 1000);
+        // console.log('hash: ', hashCode(this.deviceId)) // todo
+        return (0, hash_util_1.hashCode)(this.deviceId) % 1000 < mod;
+    }
+    /**
+     * Deletes the persisted deviceId.
+     * Keeps it in the service.
+     * To remove it from the service, assign deviceIdService.deviceId = null.
+     */
+    clearPersistence() {
+        try {
+            globalThis.localStorage.removeItem(this.cfg.localStorageKey);
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+    /**
+     * Generates a stable Device id if it wasn't previously generated on this device.
+     * Otherwise, reads a Device id from persistent storage.
+     */
+    init() {
+        this.deviceId = null;
+        if ((0, env_1.isServerSide)())
+            return;
+        try {
+            this.deviceId = globalThis.localStorage.getItem(this.cfg.localStorageKey);
+            if (this.deviceId)
+                this.debug(`loaded deviceId: ${this.deviceId}`);
+        }
+        catch (err) {
+            console.log(err);
+            this.deviceId = null;
+        }
+        if (this.deviceId && this.deviceId.length !== deviceIdLength) {
+            console.warn(`[DeviceIdService] unexpected deviceIdLength (${this.deviceId.length}), will re-generate the id`, { deviceId: this.deviceId });
+            this.deviceId = null;
+        }
+        if (!this.deviceId) {
+            try {
+                this.deviceId = (0, nanoid_1.nanoidBrowser)(deviceIdLength);
+                this.debug(`generated new deviceId: ${this.deviceId}`);
+                globalThis.localStorage.setItem(this.cfg.localStorageKey, this.deviceId);
+            }
+            catch (err) {
+                console.log(err);
+                this.deviceId = null;
+            }
+        }
+    }
+    debug(...args) {
+        if (this.cfg.debug)
+            console.log('[DeviceIdService]', ...args);
+    }
+}
+exports.DeviceIdService = DeviceIdService;

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

@@ -2,6 +2,13 @@ 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';
@@ -20,6 +27,7 @@ export * from './decorators/memoFnAsync';
 export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
 export * from './define';
+export * from './deviceIdService';
 export * from './enum.util';
 export * from './env';
 export * from './env/buildInfo';
@@ -45,6 +53,7 @@ export * from './log/commonLogger';
 export * from './math/math.util';
 export * from './math/sma';
 export * from './math/stack.util';
+export * from './nanoid';
 export * from './number/createDeterministicRandom';
 export * from './number/number.util';
 export * from './object/deepEquals';

package/dist/index.js

@@ -6,6 +6,13 @@ 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);
@@ -24,6 +31,7 @@ tslib_1.__exportStar(require("./decorators/memoFnAsync"), exports);
 tslib_1.__exportStar(require("./decorators/retry.decorator"), exports);
 tslib_1.__exportStar(require("./decorators/timeout.decorator"), exports);
 tslib_1.__exportStar(require("./define"), exports);
+tslib_1.__exportStar(require("./deviceIdService"), exports);
 tslib_1.__exportStar(require("./enum.util"), exports);
 tslib_1.__exportStar(require("./env"), exports);
 tslib_1.__exportStar(require("./env/buildInfo"), exports);
@@ -49,6 +57,7 @@ tslib_1.__exportStar(require("./log/commonLogger"), exports);
 tslib_1.__exportStar(require("./math/math.util"), exports);
 tslib_1.__exportStar(require("./math/sma"), exports);
 tslib_1.__exportStar(require("./math/stack.util"), exports);
+tslib_1.__exportStar(require("./nanoid"), exports);
 tslib_1.__exportStar(require("./number/createDeterministicRandom"), exports);
 tslib_1.__exportStar(require("./number/number.util"), exports);
 tslib_1.__exportStar(require("./object/deepEquals"), exports);

package/dist/nanoid.d.ts

@@ -0,0 +1,7 @@
+/// <reference lib="dom" preserve="true" />
+/**
+ * Function that takes a length (defaults to 21) and generates a random string id of that length.
+ */
+export type NanoidFunction = (length?: number) => string;
+export declare function nanoidBrowser(length?: number): string;
+export declare function nanoidBrowserCustomAlphabet(alphabet: string, length?: number): NanoidFunction;