@streamscloud/embeddable 1.1.2

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

@@ -0,0 +1,23 @@
+export declare class ArrayHelper {
+    static distinct<T>(items: T[]): T[];
+    static distinctBy<T>(items: T[], keyFn: (elem: T) => unknown): T[];
+    static intersect<T>(arrays: T[][]): T[];
+    static assertHasValue<T>(value: T | null | undefined): value is T;
+    /**
+     * Find position ("from" and "to" indexes) of the element that was moved inside array (only one element should be moved)
+     */
+    static findMovedElement(initial: unknown[], modified: unknown[]): {
+        from: number;
+        to: number;
+    } | undefined;
+    static moveArrayItem<T>(arr: T[], from: number, to: number): T[];
+    static replaceArrayItem<T>(arr: T[], originalItem: T, newItem: T): T[];
+    static randomElement<T>(arr: T[]): T;
+    static randomElements<T>(arr: T[], count: number): T[];
+    static sortArray<T>(array: T[], propertyFunc: (elem: T) => unknown): T[];
+    static sortArrayDescending<T>(array: T[], propertyFunc: (elem: T) => unknown): T[];
+    static groupBy<T>(array: T[], keyResolver: (elem: T) => string): Record<string, T[]>;
+    static repeat<T>(itemFn: (i: number) => T, length: number): T[];
+    static areEqual<T>(array1?: T[] | null, array2?: T[] | null): boolean;
+    private static sortArrayInternal;
+}

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

@@ -0,0 +1,148 @@
+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/date-helper.d.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,40 @@
+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 pasteIntoInput(value: string, element: HTMLInputElement | HTMLTextAreaElement): void;
+}

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

@@ -0,0 +1,97 @@
+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 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

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

package/dist/core/utils/index.js

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

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,28 @@
+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

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

package/dist/core/utils/string-generator.js

@@ -0,0 +1,15 @@
+import { nanoid } from 'nanoid';
+const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+export function generateString(length) {
+    let result = '';
+    const charactersLength = characters.length;
+    let counter = 0;
+    while (counter < length) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        counter += 1;
+    }
+    return result;
+}
+export const randomNanoid = (size = 15) => {
+    return nanoid(size);
+};

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

@@ -0,0 +1,10 @@
+export declare class StringHelper {
+    static isBlobUrl(val: string | null | undefined): boolean;
+    static isEmail(val: string): boolean;
+    static isNumeric(n: string): boolean;
+    static isUrl(val: string): boolean;
+    static toKebabCase(str: string): string;
+    static toSnakeCase(str: string): string;
+    static truncate(str: string, length: number): string;
+    static capitalizeFirstLetter(word: string): string;
+}