@streamscloud/kit 0.0.1-1770364570820

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

@@ -0,0 +1,244 @@
+export class DateHelper {
+    static toDate(date, resetTime = false) {
+        date = new Date(date);
+        if (resetTime) {
+            date.setHours(0, 0, 0, 0);
+        }
+        return date;
+    }
+    static addMonths(date, months = 1) {
+        const newDate = new Date(date);
+        newDate.setMonth(newDate.getMonth() + months);
+        return newDate;
+    }
+    static addDays(date, days) {
+        date = DateHelper.toDate(date);
+        date.setDate(date.getDate() + days);
+        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 getDiffInDays(date1, date2) {
+        date1 = DateHelper.toDate(date1);
+        date2 = DateHelper.toDate(date2);
+        const diffTime = Math.abs(date2.getTime() - date1.getTime());
+        return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    }
+    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) {
+        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;
+    }
+    static toDefaultDateTimeRepresentation = (val, locale, alwaysIncludeYear = false) => {
+        const dateTime = DateHelper.toDate(val);
+        const sameYear = dateTime.getFullYear() === new Date().getFullYear();
+        const formatNumber = (n) => n.toString().padStart(2, '0');
+        const date = `${formatNumber(dateTime.getDate())}`;
+        const monthName = DateHelper.getMonthName(dateTime, locale, !sameYear);
+        const year = sameYear && !alwaysIncludeYear ? '' : ' ' + dateTime.getFullYear();
+        const time = `${formatNumber(dateTime.getHours())}:${formatNumber(dateTime.getMinutes())}`;
+        return `${date}. ${monthName}${year} - ${time}`;
+    };
+    static addYears(dateToModify, yearsToAdd, resetTime = true) {
+        const date = new Date(dateToModify);
+        date.setFullYear(date.getFullYear() + yearsToAdd);
+        if (resetTime) {
+            date.setHours(0, 0, 0, 0);
+        }
+        return date;
+    }
+    static startOfLastWeek() {
+        const now = new Date();
+        const day = now.getDay();
+        const diffToMonday = (day === 0 ? 7 : day) - 1;
+        const lastMonday = new Date(now);
+        lastMonday.setDate(now.getDate() - diffToMonday - 7);
+        lastMonday.setHours(0, 0, 0, 0);
+        return lastMonday.toISOString().slice(0, 10);
+    }
+    static endOfLastWeek() {
+        const now = new Date();
+        const day = now.getDay();
+        const lastSunday = new Date(now);
+        lastSunday.setDate(now.getDate() - (day === 0 ? 0 : day));
+        lastSunday.setHours(23, 59, 59, 999);
+        lastSunday.setDate(lastSunday.getDate() - 1);
+        return lastSunday.toISOString().slice(0, 10);
+    }
+    static startOfLastMonth() {
+        const now = new Date();
+        const firstDayOfThisMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+        const firstDayOfLastMonth = new Date(firstDayOfThisMonth);
+        firstDayOfLastMonth.setMonth(firstDayOfThisMonth.getMonth() - 1);
+        return firstDayOfLastMonth.toISOString().slice(0, 10);
+    }
+    static endOfLastMonth() {
+        const now = new Date();
+        const firstDayOfThisMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+        const lastDayOfLastMonth = new Date(firstDayOfThisMonth);
+        lastDayOfLastMonth.setDate(0);
+        lastDayOfLastMonth.setHours(23, 59, 59, 999);
+        return lastDayOfLastMonth.toISOString().slice(0, 10);
+    }
+    static startOfLastYear() {
+        const now = new Date();
+        const firstDayOfLastYear = new Date(now.getFullYear() - 1, 0, 1);
+        return firstDayOfLastYear.toISOString().slice(0, 10);
+    }
+    static endOfLastYear() {
+        const now = new Date();
+        const lastDayOfLastYear = new Date(now.getFullYear() - 1, 11, 31);
+        lastDayOfLastYear.setHours(23, 59, 59, 999);
+        return lastDayOfLastYear.toISOString().slice(0, 10);
+    }
+    static startOfRollingDays(days) {
+        const now = new Date();
+        const start = new Date(now);
+        start.setDate(now.getDate() - (days - 1));
+        start.setHours(0, 0, 0, 0);
+        return start.toISOString().slice(0, 10);
+    }
+    static endOfRollingDays() {
+        const now = new Date();
+        now.setHours(23, 59, 59, 999);
+        return now.toISOString().slice(0, 10);
+    }
+    static startOfCurrentMonthToNow() {
+        const now = new Date();
+        const from = new Date(now.getFullYear(), now.getMonth(), 1);
+        return { from: DateHelper.getDateOnlyString(from), to: DateHelper.getDateOnlyString(now) };
+    }
+    static startOfCurrentYearToNow() {
+        const now = new Date();
+        const from = new Date(now.getFullYear(), 0, 1);
+        return { from: DateHelper.getDateOnlyString(from), to: DateHelper.getDateOnlyString(now) };
+    }
+}
+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 dateNumericFormat = { day: '2-digit', month: '2-digit', 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,10 @@
+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 calcHeightBasedOnRows(element: HTMLElement, rows: number): string;
+}

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

@@ -0,0 +1,34 @@
+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 calcHeightBasedOnRows(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`;
+    }
+}

package/dist/core/utils/href-validator.d.ts

@@ -0,0 +1,22 @@
+export declare enum ValidationError {
+    NotString = 0,
+    Empty = 1,
+    ControlChars = 2,
+    DisallowedScheme = 3,
+    MissingHost = 4,
+    EmbeddedCredentials = 5,
+    Relative = 6,
+    BareRelative = 7
+}
+type DetailedResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: ValidationError;
+};
+export type ValidateOptions = {
+    allowRelative?: 'all' | 'prefixed';
+    allowedSchemes?: Set<string>;
+};
+export declare const validateHref: (input: unknown, opts?: ValidateOptions) => DetailedResult;
+export {};

package/dist/core/utils/href-validator.js

@@ -0,0 +1,52 @@
+export var ValidationError;
+(function (ValidationError) {
+    ValidationError[ValidationError["NotString"] = 0] = "NotString";
+    ValidationError[ValidationError["Empty"] = 1] = "Empty";
+    ValidationError[ValidationError["ControlChars"] = 2] = "ControlChars";
+    ValidationError[ValidationError["DisallowedScheme"] = 3] = "DisallowedScheme";
+    ValidationError[ValidationError["MissingHost"] = 4] = "MissingHost";
+    ValidationError[ValidationError["EmbeddedCredentials"] = 5] = "EmbeddedCredentials";
+    ValidationError[ValidationError["Relative"] = 6] = "Relative";
+    ValidationError[ValidationError["BareRelative"] = 7] = "BareRelative";
+})(ValidationError || (ValidationError = {}));
+const DEFAULT_ALLOWED_SCHEMES = new Set(['http:', 'https:', 'mailto:', 'tel:']);
+export const validateHref = (input, opts = {}) => {
+    if (typeof input !== 'string') {
+        return { valid: false, error: ValidationError.NotString };
+    }
+    const s = input.trim();
+    if (s.length === 0) {
+        return { valid: false, error: ValidationError.Empty };
+    }
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if ((code >= 0 && code <= 31) || code === 127) {
+            return { valid: false, error: ValidationError.ControlChars };
+        }
+    }
+    try {
+        const u = new URL(s);
+        const proto = u.protocol.toLowerCase();
+        if (!(opts.allowedSchemes ?? DEFAULT_ALLOWED_SCHEMES).has(proto)) {
+            return { valid: false, error: ValidationError.DisallowedScheme };
+        }
+        if ((proto === 'http:' || proto === 'https:') && !u.hostname) {
+            return { valid: false, error: ValidationError.MissingHost };
+        }
+        if (u.username || u.password) {
+            return { valid: false, error: ValidationError.EmbeddedCredentials };
+        }
+        return { valid: true };
+    }
+    catch {
+        // Not an absolute URL, continue with relative checks
+    }
+    if (!opts.allowRelative) {
+        return { valid: false, error: ValidationError.Relative };
+    }
+    const hasAllowedRelativePrefix = s.startsWith('/') || s.startsWith('./') || s.startsWith('../') || s.startsWith('#') || s.startsWith('?') || s.startsWith('//');
+    if (hasAllowedRelativePrefix) {
+        return { valid: true };
+    }
+    return opts.allowRelative === 'all' ? { valid: true } : { valid: false, error: ValidationError.BareRelative };
+};

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

@@ -0,0 +1,12 @@
+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;
+    static pasteIntoInput(value: string, element: HTMLInputElement | HTMLTextAreaElement): void;
+    static sanitizeSvg(svg: string): string;
+    static sanitizeHtml(html: string): string;
+    static stripHtml(html: string, lineBreaksReplacer?: string | null, trimResult?: boolean): string;
+}

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

@@ -0,0 +1,104 @@
+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;');
+    }
+    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();
+    }
+    static sanitizeSvg(svg) {
+        return dp.sanitize(svg, { USE_PROFILES: { svg: true, svgFilters: true }, ADD_ATTR: ['dominant-baseline'] });
+    }
+    static sanitizeHtml(html) {
+        return HtmlSanitizer.sanitize(html);
+    }
+    static stripHtml(html, lineBreaksReplacer = null, trimResult = true) {
+        if (!html) {
+            return '';
+        }
+        html = HtmlHelper.sanitizeHtml(html);
+        const tmp = document.createElement('div');
+        tmp.innerHTML = html;
+        // move element out of visible area
+        tmp.style.position = 'fixed';
+        tmp.style.left = '200%';
+        // element should be appended into the DOM otherwise element.innerText doesn't contain line breaks (\n) (at least at Chrome)
+        document.body.appendChild(tmp);
+        let result = tmp.innerText || tmp.textContent || '';
+        result = result.replace(/\n\n/g, '\n');
+        if (trimResult) {
+            result = result.trim();
+        }
+        if (lineBreaksReplacer !== null) {
+            result = result.replace(/\n/g, lineBreaksReplacer);
+        }
+        tmp.remove();
+        return result;
+    }
+}
+class HtmlSanitizer {
+    static initialized = false;
+    static sanitize(html) {
+        HtmlSanitizer.ensureInitialized();
+        return dp.sanitize(html, {
+            ADD_ATTR: ['target']
+        });
+    }
+    static ensureInitialized() {
+        if (!HtmlSanitizer.initialized) {
+            dp.addHook('afterSanitizeAttributes', (node) => {
+                if (node.tagName === 'A' && node.hasAttribute('target')) {
+                    node.setAttribute('rel', 'noopener noreferrer');
+                }
+            });
+            HtmlSanitizer.initialized = true;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+export * from './array-helper';
+export * from './base64-serializer';
+export * from './browser';
+export * from './date-helper';
+export * from './dom-helper';
+export * from './href-validator';
+export * from './html-helper';
+export * from './lazy-init';
+export * from './number-helper';
+export * from './string-generator';
+export * from './string-helper';
+export * from './url-helper';
+export * from './utils';

package/dist/core/utils/index.js

@@ -0,0 +1,13 @@
+export * from './array-helper';
+export * from './base64-serializer';
+export * from './browser';
+export * from './date-helper';
+export * from './dom-helper';
+export * from './href-validator';
+export * from './html-helper';
+export * from './lazy-init';
+export * from './number-helper';
+export * from './string-generator';
+export * from './string-helper';
+export * from './url-helper';
+export * from './utils';

package/dist/core/utils/lazy-init.d.ts

@@ -0,0 +1 @@
+export declare const lazyInit: <T>(factory: () => T) => (() => T);

package/dist/core/utils/lazy-init.js

@@ -0,0 +1,7 @@
+export const lazyInit = (factory) => {
+    let instance = null;
+    return () => {
+        instance ??= factory();
+        return instance;
+    };
+};

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

@@ -0,0 +1,5 @@
+export declare class NumberHelper {
+    static formatNumber: (n: number | string) => string;
+    static formatCompactNumber: (num: number, locale?: string) => string;
+    static randomIntFromInterval: (min: number, max: number) => number;
+}

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

@@ -0,0 +1,32 @@
+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 formatCompactNumber = (num, locale) => {
+        if (num < 1000) {
+            return num.toString();
+        }
+        return new Intl.NumberFormat(locale, {
+            notation: 'compact',
+            compactDisplay: 'short',
+            maximumFractionDigits: 1
+        }).format(num);
+    };
+    static randomIntFromInterval = (min, max) => {
+        // min and max included
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    };
+}

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

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

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

@@ -0,0 +1,5 @@
+import { customAlphabet } from 'nanoid';
+const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+const alphanumeric = letters + '0123456789';
+export const randomString = (size = 15) => customAlphabet(letters, size)();
+export const randomNanoid = (size = 15) => customAlphabet(alphanumeric, size)();

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

@@ -0,0 +1,12 @@
+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 isNullOrEmpty(str: string | null | undefined): boolean;
+    static toKebabCase(str: string): string;
+    static toSnakeCase(str: string): string;
+    static truncate(str: string, length: number): string;
+    static capitalizeFirstLetter(word: string): string;
+    static toFileSizeString(sizeBytes: number): string;
+}

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

@@ -0,0 +1,75 @@
+export class StringHelper {
+    static isBlobUrl(val) {
+        return !!val && val.startsWith('blob:');
+    }
+    static isEmail(val) {
+        if (!val) {
+            return false;
+        }
+        const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+        return re.test(String(val).toLowerCase());
+    }
+    static isNumeric(n) {
+        const parsed = parseFloat(n);
+        return !isNaN(parsed) && isFinite(parsed);
+    }
+    static isUrl(val) {
+        if (!val) {
+            return false;
+        }
+        try {
+            const url = new URL(val);
+            return (val.startsWith('http://') || val.startsWith('https://')) && url && ['http:', 'https:'].includes(url.protocol);
+        }
+        catch {
+            return false;
+        }
+    }
+    static isNullOrEmpty(str) {
+        return !str || str.trim().length === 0;
+    }
+    static toKebabCase(str) {
+        return (str
+            .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+            ?.join('-')
+            .toLowerCase() || str);
+    }
+    static toSnakeCase(str) {
+        if (!str) {
+            return str;
+        }
+        return str
+            .split(/(?=[A-Z])/)
+            .join('_')
+            .toLowerCase();
+    }
+    static truncate(str, length) {
+        if (str.length <= length) {
+            return str;
+        }
+        str = str.slice(0, length) + '...';
+        return str;
+    }
+    static capitalizeFirstLetter(word) {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    }
+    static toFileSizeString(sizeBytes) {
+        const kilobytes = Math.round((sizeBytes / 1000) * 10) / 10;
+        const megabytes = Math.round((sizeBytes / Math.pow(1000, 2)) * 10) / 10;
+        const gigabytes = Math.round((sizeBytes / Math.pow(1000, 3)) * 10) / 10;
+        const terabytes = Math.round((sizeBytes / Math.pow(1000, 4)) * 10) / 10;
+        if (kilobytes < 1000) {
+            return `${kilobytes} KB`;
+        }
+        if (megabytes < 1000) {
+            return `${megabytes} MB`;
+        }
+        if (gigabytes < 1000) {
+            return `${gigabytes} GB`;
+        }
+        if (terabytes < 1000) {
+            return `${terabytes} TB`;
+        }
+        return `${megabytes} MB`;
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare class UrlHelper {
+    static getRootDomain(url: URL | Location): string;
+}