@streamscloud/embeddable 15.1.0 → 16.0.1

package/dist/core/utils/array-helper.js

@@ -1,148 +0,0 @@
-export class ArrayHelper {
-    static distinct(items) {
-        return Array.from(new Set(items));
-    }
-    static distinctBy(items, keyFn) {
-        return Array.from(new Map(items.map((item) => [keyFn(item), item])).values());
-    }
-    static intersect(arrays) {
-        if (!arrays?.length) {
-            return [];
-        }
-        return arrays.reduce((result, current) => result.filter((item) => current.includes(item)));
-    }
-    static assertHasValue(value) {
-        return value !== null && value !== undefined;
-    }
-    /**
-     * Find position ("from" and "to" indexes) of the element that was moved inside array (only one element should be moved)
-     */
-    static findMovedElement(initial, modified) {
-        if (initial.length !== modified.length) {
-            throw new Error('Arrays should have the same number of elements.');
-        }
-        if (initial.length !== new Set(initial).size || modified.length !== new Set(modified).size) {
-            throw new Error("Arrays shouldn't have duplicates.");
-        }
-        const res = { from: -1, to: -1 };
-        let i = 0;
-        for (i; i < initial.length; i++) {
-            if (initial[i] !== modified[i]) {
-                if (initial[i] === modified[i + 1]) {
-                    res.to = i;
-                }
-                else {
-                    res.from = i;
-                }
-                break;
-            }
-        }
-        if (i === initial.length) {
-            return;
-        }
-        let j = initial.length;
-        for (j; j > i; j--) {
-            if (initial[j] !== modified[j]) {
-                if (res.from === -1) {
-                    res.from = j;
-                }
-                else {
-                    res.to = j;
-                }
-                break;
-            }
-        }
-        return res;
-    }
-    static moveArrayItem(arr, from, to) {
-        if (!arr?.length || from < 0 || from >= arr.length || to < 0 || to >= arr.length || from === to) {
-            return arr;
-        }
-        arr.splice(to, 0, arr.splice(from, 1)[0]);
-        return arr;
-    }
-    static replaceArrayItem(arr, originalItem, newItem) {
-        const index = arr.indexOf(originalItem);
-        if (index < 0) {
-            return arr;
-        }
-        arr.splice(index, 1, newItem);
-        return arr;
-    }
-    static randomElement(arr) {
-        if (!Array.isArray(arr)) {
-            throw new Error('Parameter is not an array.');
-        }
-        return arr[Math.floor(Math.random() * arr.length)];
-    }
-    static randomElements(arr, count) {
-        const result = [];
-        for (let i = 0; i < count; i++) {
-            let newItem = null;
-            while (!newItem) {
-                const item = ArrayHelper.randomElement(arr);
-                if (!result.includes(item)) {
-                    newItem = item;
-                }
-            }
-            result.push(newItem);
-        }
-        return result;
-    }
-    static sortArray(array, propertyFunc) {
-        return ArrayHelper.sortArrayInternal(array, true, propertyFunc);
-    }
-    static sortArrayDescending(array, propertyFunc) {
-        return ArrayHelper.sortArrayInternal(array, false, propertyFunc);
-    }
-    static groupBy(array, keyResolver) {
-        return array.reduce((resultValue, value) => {
-            const groupKey = keyResolver(value);
-            (resultValue[groupKey] = resultValue[groupKey] || []).push(value);
-            return resultValue;
-        }, {});
-    }
-    static repeat(itemFn, length) {
-        return [...Array(length)].map((_, i) => itemFn(i));
-    }
-    static areEqual(array1, array2) {
-        if (array1 === array2) {
-            return true;
-        }
-        if (!array1 && !array2) {
-            return true;
-        }
-        if (!array1 || !array2) {
-            return false;
-        }
-        return array1.length === array2.length && array1.every((element, index) => element === array2[index]);
-    }
-    static sortArrayInternal(array, ascending, propertyFunc) {
-        const clone = [...array];
-        return clone.sort((val1, val2) => {
-            const a = propertyFunc(val1);
-            const b = propertyFunc(val2);
-            const left = ascending ? a : b;
-            const right = ascending ? b : a;
-            if (!left && !right) {
-                return 0;
-            }
-            if (!left) {
-                return -1;
-            }
-            if (!right) {
-                return 1;
-            }
-            if (typeof left === 'string' && typeof right === 'string') {
-                return left.localeCompare(right);
-            }
-            if (left < right) {
-                return -1;
-            }
-            if (left > right) {
-                return 1;
-            }
-            return 0;
-        });
-    }
-}

package/dist/core/utils/compact-number.d.ts

@@ -1,8 +0,0 @@
-import type { Locale } from '../locale';
-type CompactOptions = {
-    decimals?: number;
-    trimZeros?: boolean;
-    locale?: Locale;
-};
-export declare const compactNumber: (value: number, options?: CompactOptions) => string;
-export {};

package/dist/core/utils/compact-number.js

@@ -1,48 +0,0 @@
-// Fixed thresholds (constants)
-const THOUSAND = 1_000;
-const MILLION = 1_000_000;
-const BILLION = 1_000_000_000;
-const TRILLION = 1_000_000_000_000;
-export const compactNumber = (value, options = {}) => {
-    const { decimals = 1, trimZeros = true, locale = 'en' } = options;
-    const abs = Math.abs(value);
-    const formatter = makeNumberFormatter(locale, decimals, trimZeros);
-    if (abs >= TRILLION) {
-        return `${formatter.format(value / TRILLION)}${loc.T[locale]}`;
-    }
-    if (abs >= BILLION) {
-        return `${formatter.format(value / BILLION)}${loc.B[locale]}`;
-    }
-    if (abs >= MILLION) {
-        return `${formatter.format(value / MILLION)}${loc.M[locale]}`;
-    }
-    if (abs >= THOUSAND) {
-        return `${formatter.format(value / THOUSAND)}${loc.K[locale]}`;
-    }
-    // Below 1000 — plain localized number
-    return formatter.format(value);
-};
-const makeNumberFormatter = (locale, decimals, trimZeros) => new Intl.NumberFormat(loc.numberLocale[locale], {
-    minimumFractionDigits: trimZeros ? 0 : decimals,
-    maximumFractionDigits: decimals,
-    useGrouping: false // grouping with suffixes like "1_234K" is noisy
-});
-const loc = {
-    K: {
-        en: 'K',
-        no: 'K'
-    },
-    M: {
-        en: 'M',
-        no: 'M'
-    },
-    B: {
-        en: 'B',
-        no: 'B'
-    },
-    T: {
-        en: 'T',
-        no: 'T'
-    },
-    numberLocale: { en: 'nb-NO', no: 'nb-NO' }
-};

package/dist/core/utils/date-helper.d.ts

@@ -1,29 +0,0 @@
-export declare class DateHelper {
-    static toDate(date: LikeDate, resetTime?: boolean): Date;
-    static secondsToTimeRepresentation(seconds: number, duration: number): string;
-    static getDate(date: LikeDate): number;
-    static getYear(date: LikeDate): number;
-    static getMonthName(date: LikeDate, locale: string, short?: boolean): string;
-    static getWeekdayName(date: LikeDate, locale: string, short?: boolean): string;
-    static getMonthRange(date: LikeDate): MonthRange;
-    static daysInMonth(date: LikeDate): number;
-    static getDayOfWeek(date: LikeDate): number;
-    static getShiftedDate(date: LikeDate, daysShift: number): Date;
-    static getDateOnlyString(date?: LikeDate): string | null;
-    static formatDateRange(startDate: LikeDate, endDate: LikeDate, locale: string): string;
-    static dateRangeDescriptionString(startDate: LikeDate, endDate: LikeDate | null | undefined, locale: string): string;
-}
-export declare class DateFormatOptions {
-    static dateTimeFormat: Intl.DateTimeFormatOptions;
-    static dateTimeWithoutYearFormat: Intl.DateTimeFormatOptions;
-    static timeFormat: Intl.DateTimeFormatOptions;
-    static dateFormat: Intl.DateTimeFormatOptions;
-    static dateFormatWithoutYear: Intl.DateTimeFormatOptions;
-    static dateFullMonthFormat: Intl.DateTimeFormatOptions;
-}
-export type MonthRange = {
-    firstDay: Date;
-    lastDay: Date;
-};
-type LikeDate = string | number | Date;
-export {};

package/dist/core/utils/date-helper.js

@@ -1,146 +0,0 @@
-export class DateHelper {
-    static toDate(date, resetTime = false) {
-        date = new Date(date);
-        if (resetTime) {
-            date.setHours(0, 0, 0, 0);
-        }
-        return date;
-    }
-    static secondsToTimeRepresentation(seconds, duration) {
-        const longerThanHour = Math.floor(duration / 3600) > 0;
-        if (!seconds) {
-            return longerThanHour ? '0:00:00' : '0:00';
-        }
-        const hours = Math.floor(seconds / 3600);
-        const mins = Math.floor((seconds - hours * 3600) / 60);
-        seconds = seconds - hours * 3600 - mins * 60;
-        let res = '';
-        if (longerThanHour) {
-            if (hours) {
-                res += `${hours}:`;
-            }
-            else {
-                res += '0:';
-            }
-            if (mins < 10) {
-                res += '0';
-            }
-        }
-        res += `${mins}:`;
-        if (seconds < 10) {
-            res += '0';
-        }
-        res += seconds;
-        return res;
-    }
-    static getDate(date) {
-        date = DateHelper.toDate(date);
-        return date.getDate();
-    }
-    static getYear(date) {
-        date = DateHelper.toDate(date);
-        return date.getFullYear();
-    }
-    static getMonthName(date, locale, short = false) {
-        date = DateHelper.toDate(date);
-        return date.toLocaleString(locale, { month: short ? 'short' : 'long' });
-    }
-    static getWeekdayName(date, locale, short = false) {
-        date = DateHelper.toDate(date);
-        return date.toLocaleString(locale, { weekday: short ? 'short' : 'long' });
-    }
-    static getMonthRange(date) {
-        date = DateHelper.toDate(date);
-        const fullYear = date.getFullYear();
-        const month = date.getMonth();
-        const firstDay = new Date(fullYear, month, 1);
-        const lastDay = new Date(fullYear, month + 1, 1);
-        lastDay.setMilliseconds(-1);
-        return { firstDay, lastDay };
-    }
-    static daysInMonth(date) {
-        date = DateHelper.toDate(date);
-        return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
-    }
-    static getDayOfWeek(date) {
-        date = DateHelper.toDate(date);
-        const day = date.getDay();
-        return day === 0 ? 7 : day;
-    }
-    static getShiftedDate(date, daysShift) {
-        date = DateHelper.toDate(date);
-        date.setDate(date.getDate() + daysShift);
-        return date;
-    }
-    static getDateOnlyString(date) {
-        if (!date) {
-            return null;
-        }
-        date = DateHelper.toDate(date);
-        const year = date.getFullYear();
-        const month = date.getMonth() + 1;
-        const day = date.getDate();
-        return `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')}`;
-    }
-    static formatDateRange(startDate, endDate, locale) {
-        const startTime = DateHelper.toDate(startDate);
-        const endTime = DateHelper.toDate(endDate);
-        const startMonthName = DateHelper.getMonthName(startDate, locale).toLocaleLowerCase();
-        const endMonthName = DateHelper.getMonthName(endDate, locale).toLocaleLowerCase();
-        const isSameDateWithStart = startTime.getDate() === endTime.getDate() && startTime.getMonth() === endTime.getMonth() && startTime.getFullYear() === endTime.getFullYear();
-        const isSameMonth = startTime.getMonth() === endTime.getMonth();
-        if (isSameDateWithStart) {
-            return `${startTime.getDate()}. ${startMonthName}`;
-        }
-        if (isSameMonth) {
-            return `${startTime.getDate()}. –${endTime.getDate()}. ${startMonthName}`;
-        }
-        return `${startTime.getDate()}. ${startMonthName} – ${endTime.getDate()}. ${endMonthName}`;
-    }
-    static dateRangeDescriptionString(startDate, endDate, locale) {
-        let eventTime;
-        const currentDate = new Date();
-        const startTime = DateHelper.toDate(startDate);
-        const getFormattedDate = (d) => {
-            const month = DateHelper.getMonthName(d, locale, false);
-            const date = d.getDate();
-            const year = d.getFullYear() === currentDate.getFullYear() ? '' : d.getFullYear().toString();
-            const dateString = [month, date, year].join(' ');
-            return dateString;
-        };
-        const getFormattedTime = (d) => {
-            return `${d.getHours().toString().padStart(2, '0')}:${d.getMinutes().toString().padStart(2, '0')}`;
-        };
-        const getWeekday = (d) => DateHelper.getWeekdayName(d, locale, false);
-        if (!endDate) {
-            eventTime = [getWeekday(startTime), getFormattedDate(startTime), getFormattedTime(startTime)].join(' · ');
-        }
-        else {
-            const endTime = DateHelper.toDate(endDate);
-            const isSameDateWithStart = startTime.getDate() === endTime.getDate() && startTime.getMonth() === endTime.getMonth() && startTime.getFullYear() === endTime.getFullYear();
-            if (isSameDateWithStart) {
-                eventTime = [getWeekday(startTime), getFormattedDate(startTime), `${getFormattedTime(startTime)}-${getFormattedTime(endTime)}`].join(' · ');
-            }
-            else {
-                const getFormattedDateWithTime = (d) => [getFormattedDate(d), getFormattedTime(d)].join(' · ');
-                eventTime = `${getFormattedDateWithTime(startTime)} - ${getFormattedDateWithTime(endTime)}`;
-            }
-        }
-        return eventTime;
-    }
-}
-export class DateFormatOptions {
-    static dateTimeFormat = {
-        day: '2-digit',
-        month: 'short',
-        year: 'numeric',
-        hour: '2-digit',
-        minute: '2-digit',
-        hour12: false
-    };
-    static dateTimeWithoutYearFormat = { day: '2-digit', month: 'short', hour: '2-digit', minute: '2-digit', hour12: false };
-    static timeFormat = { hour: '2-digit', minute: '2-digit', hour12: false };
-    static dateFormat = { day: '2-digit', month: 'short', year: 'numeric' };
-    static dateFormatWithoutYear = { day: '2-digit', month: 'short' };
-    static dateFullMonthFormat = { day: '2-digit', month: 'long' };
-}

package/dist/core/utils/dom-helper.d.ts

@@ -1,12 +0,0 @@
-export declare class DomHelper {
-    /**
-     * Checks whether initial object is located inside specified boundaries
-     * @param  {HTMLElement} element The initial element
-     * @param  {HTMLElement[]} boundaryElements Parent elements concerned to be valid boundaries
-     * @return {boolean} true if initial element is located inside specified boundaries, otherwise false
-     */
-    static checkElementOutsideSpecifiedBoundaries(element: Element | EventTarget | null, boundaryElements: Array<Element | EventTarget>): boolean;
-    static calsHeightBasedOnRows(element: HTMLElement, rows: number): string;
-    static scaleFontSize(el: HTMLElement, text: string, minFontSize?: number, maxFontSize?: number): void;
-    private static measureText;
-}

package/dist/core/utils/dom-helper.js

@@ -1,76 +0,0 @@
-export class DomHelper {
-    /**
-     * Checks whether initial object is located inside specified boundaries
-     * @param  {HTMLElement} element The initial element
-     * @param  {HTMLElement[]} boundaryElements Parent elements concerned to be valid boundaries
-     * @return {boolean} true if initial element is located inside specified boundaries, otherwise false
-     */
-    static checkElementOutsideSpecifiedBoundaries(element, boundaryElements) {
-        let node = element;
-        boundaryElements = boundaryElements || [];
-        while (node) {
-            if (boundaryElements.includes(node)) {
-                return false;
-            }
-            node = node.parentElement;
-        }
-        return true;
-    }
-    static calsHeightBasedOnRows(element, rows) {
-        const computed = window.getComputedStyle(element);
-        const paddingTop = parseFloat(computed.getPropertyValue('padding-top'));
-        const paddingBottom = parseFloat(computed.getPropertyValue('padding-bottom'));
-        const lineHeightPx = computed.getPropertyValue('line-height');
-        let lineHeight;
-        if (lineHeightPx === 'normal') {
-            lineHeight = parseFloat(computed.getPropertyValue('font-size')) * 1.2;
-        }
-        else {
-            lineHeight = parseFloat(lineHeightPx);
-        }
-        const computedHeight = paddingBottom + paddingTop + lineHeight * rows;
-        return `${computedHeight}px`;
-    }
-    static scaleFontSize(el, text, minFontSize = 12, maxFontSize = 150) {
-        el.style.fontSize = ``;
-        window.setTimeout(() => {
-            let fontSize = minFontSize;
-            const fontFamily = window.getComputedStyle(el).fontFamily;
-            const fontWeight = window.getComputedStyle(el).fontWeight;
-            const maxHeight = el.clientHeight;
-            const maxWidth = el.clientWidth;
-            let attempts = maxFontSize - minFontSize;
-            let measured = this.measureText(text, fontSize, fontFamily, fontWeight, maxWidth);
-            if (measured.height < maxHeight) {
-                let adjusted = false;
-                while (measured.height <= maxHeight && measured.width <= maxWidth && attempts > 0) {
-                    attempts--;
-                    measured = this.measureText(text, ++fontSize, fontFamily, fontWeight, maxWidth);
-                    adjusted = true;
-                }
-                if (adjusted) {
-                    el.style.fontSize = `${--fontSize}px`;
-                }
-            }
-        });
-    }
-    static measureText(pText, pFontSize, pFamily, pWeight, width) {
-        const tempDiv = document.createElement('div');
-        document.body.appendChild(tempDiv);
-        tempDiv.style.fontFamily = pFamily;
-        tempDiv.style.fontWeight = pWeight;
-        tempDiv.style.fontSize = `${pFontSize}px`;
-        tempDiv.style.position = 'absolute';
-        tempDiv.style.left = '-1000';
-        tempDiv.style.top = '-1000';
-        tempDiv.style.width = `${width}px`;
-        tempDiv.innerHTML = pText;
-        const lResult = {
-            width: tempDiv.scrollWidth,
-            height: tempDiv.clientHeight
-        };
-        document.body.removeChild(tempDiv);
-        tempDiv.remove();
-        return lResult;
-    }
-}

package/dist/core/utils/html-helper.d.ts

@@ -1,42 +0,0 @@
-export declare class HtmlHelper {
-    static clearSelection(): void;
-    static elementFromString(html: string): Element;
-    /**
-     * Replaces reserved html characters with html entities e.g. '<' with '&lt;'
-     */
-    static escapeSpecialChars(s: string): string;
-    /**
-     * Inserts new element into DOM before specified sibling
-     * @param  newElement   Element to be inserted
-     * @param  siblingElement     Anchor element to determine new element position
-     * @return Returns nothing
-     *
-     * Usage
-     * DomHelper.insertBefore(siblingElement, newContentField);
-     */
-    static insertBefore(newElement: Element, siblingElement: Element): void;
-    /**
-     * Inserts new element into DOM after specified sibling
-     * @param  newElement   Element to be inserted
-     * @param  siblingElement     Anchor element to determine new element position
-     * @return Returns nothing
-     *
-     * Usage
-     * DomHelper.insertAfter(siblingElement, newContentField);
-     */
-    static insertAfter(newElement: Element, siblingElement: Element): void;
-    /**
-     * Inserts new element into DOM after/before specified sibling
-     * @param  newElement   Element to be inserted
-     * @param  siblingElement     Anchor element to determine new element position
-     * @param  insertBefore   Mark new position
-     * @return Returns nothing
-     *
-     * Usage
-     * DomHelper.insert(siblingElement, newContentField, false);
-     */
-    static insert(newElement: Element, siblingElement: Element, insertBefore?: boolean): void;
-    static sanitizeHtml(html: string): string;
-    static sanitizeSvg(svg: string): string;
-    static pasteIntoInput(value: string, element: HTMLInputElement | HTMLTextAreaElement): void;
-}

package/dist/core/utils/html-helper.js

@@ -1,104 +0,0 @@
-import dp from 'dompurify';
-export class HtmlHelper {
-    static clearSelection() {
-        if (window.getSelection) {
-            const selection = window.getSelection();
-            if (!selection) {
-                return;
-            }
-            if (selection.empty) {
-                // Chrome
-                selection.empty();
-            }
-            else if (selection.removeAllRanges) {
-                // Firefox
-                selection.removeAllRanges();
-            }
-        }
-    }
-    static elementFromString(html) {
-        const wrapper = document.createElement('div');
-        wrapper.innerHTML = html;
-        const result = wrapper.firstElementChild;
-        wrapper.remove();
-        return result;
-    }
-    /**
-     * Replaces reserved html characters with html entities e.g. '<' with '&lt;'
-     */
-    static escapeSpecialChars(s) {
-        return s.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#039;');
-    }
-    /**
-     * Inserts new element into DOM before specified sibling
-     * @param  newElement   Element to be inserted
-     * @param  siblingElement     Anchor element to determine new element position
-     * @return Returns nothing
-     *
-     * Usage
-     * DomHelper.insertBefore(siblingElement, newContentField);
-     */
-    static insertBefore(newElement, siblingElement) {
-        siblingElement.parentNode?.insertBefore(newElement, siblingElement);
-    }
-    /**
-     * Inserts new element into DOM after specified sibling
-     * @param  newElement   Element to be inserted
-     * @param  siblingElement     Anchor element to determine new element position
-     * @return Returns nothing
-     *
-     * Usage
-     * DomHelper.insertAfter(siblingElement, newContentField);
-     */
-    static insertAfter(newElement, siblingElement) {
-        siblingElement.parentNode?.insertBefore(newElement, siblingElement.nextSibling);
-    }
-    /**
-     * Inserts new element into DOM after/before specified sibling
-     * @param  newElement   Element to be inserted
-     * @param  siblingElement     Anchor element to determine new element position
-     * @param  insertBefore   Mark new position
-     * @return Returns nothing
-     *
-     * Usage
-     * DomHelper.insert(siblingElement, newContentField, false);
-     */
-    static insert(newElement, siblingElement, insertBefore = false) {
-        if (insertBefore) {
-            HtmlHelper.insertBefore(newElement, siblingElement);
-        }
-        else {
-            HtmlHelper.insertAfter(newElement, siblingElement);
-        }
-    }
-    static sanitizeHtml(html) {
-        return dp.sanitize(html);
-    }
-    static sanitizeSvg(svg) {
-        return dp.sanitize(svg, { USE_PROFILES: { svg: true, svgFilters: true }, ADD_ATTR: ['dominant-baseline'] });
-    }
-    static pasteIntoInput(value, element) {
-        if (element.selectionStart || element.selectionStart === 0) {
-            const startPos = element.selectionStart;
-            const endPos = element.selectionEnd;
-            if (endPos === null) {
-                element.value = value;
-            }
-            else {
-                const beforeSelection = element.value.substring(0, startPos);
-                const afterSelection = element.value.substring(endPos, element.value.length);
-                element.value = `${beforeSelection}${value}${afterSelection}`;
-            }
-            const newCursor = startPos + value.length;
-            element.setSelectionRange(newCursor, newCursor);
-        }
-        else {
-            element.value += value;
-        }
-        element.dispatchEvent(new Event('input', {
-            bubbles: true,
-            cancelable: true
-        }));
-        element.focus();
-    }
-}

package/dist/core/utils/index.d.ts

@@ -1,3 +0,0 @@
-export * from './utils';
-export * from './string-helper';
-export * from './number-helper';

package/dist/core/utils/index.js

@@ -1,3 +0,0 @@
-export * from './utils';
-export * from './string-helper';
-export * from './number-helper';

package/dist/core/utils/number-helper.d.ts

@@ -1,6 +0,0 @@
-export declare class NumberHelper {
-    static formatNumber: (n: number | string) => string;
-    static randomIntFromInterval: (min: number, max: number) => number;
-    static quotient: (number: number, denominator: number) => number;
-    static remainder: (number: number, denominator: number) => number;
-}

package/dist/core/utils/number-helper.js

@@ -1,28 +0,0 @@
-export class NumberHelper {
-    static formatNumber = (n) => {
-        if (!n) {
-            return '0';
-        }
-        if (typeof n === 'string') {
-            n = parseInt(n);
-        }
-        const isNegative = n < 0;
-        let modulo = isNegative ? 0 - n : n;
-        const output = [];
-        for (; modulo >= 1000; modulo = Math.floor(n / 1000)) {
-            output.unshift(String(modulo % 1000).padStart(3, '0'));
-        }
-        output.unshift(modulo);
-        return `${isNegative ? '-' : ''}${output.join(' ')}`;
-    };
-    static randomIntFromInterval = (min, max) => {
-        // min and max included
-        return Math.floor(Math.random() * (max - min + 1) + min);
-    };
-    static quotient = (number, denominator) => {
-        return Math.floor(number / denominator);
-    };
-    static remainder = (number, denominator) => {
-        return number % denominator;
-    };
-}

package/dist/core/utils/string-generator.d.ts

@@ -1,2 +0,0 @@
-export declare function generateString(length: number): string;
-export declare const randomNanoid: (size?: number) => string;