@streamscloud/embeddable 2.1.1 → 2.1.3

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;
+}

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

@@ -0,0 +1,53 @@
+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 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);
+    }
+}

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

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

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

@@ -0,0 +1,13 @@
+export class UrlHelper {
+    static getRootDomain(url) {
+        let tokens = url.hostname.split('.');
+        if (tokens.length <= 2) {
+            return url.hostname;
+        }
+        tokens = tokens.slice(-3);
+        if (['co', 'com'].indexOf(tokens[1]) > -1) {
+            return tokens.join('.');
+        }
+        return tokens.slice(-2).join('.');
+    }
+}

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

@@ -0,0 +1,28 @@
+export declare class Utils {
+    static assertUnreachable(_x: never): never;
+    static clone<T>(value: T): T;
+    /**
+     * Find the greatest common divisor of 2 numbers
+     */
+    static gcd(a: number, b: number): number;
+    /**
+     * Find the least dividend and divisor by given quotient
+     */
+    static ldd(quotient: number, divisorLimit?: number): {
+        dividend: number;
+        divisor: number;
+    } | null;
+    /**
+     * Returns a function, that, as long as it continues to be invoked, will not
+     * be triggered. The function will be called after it stops being called for
+     * N milliseconds.
+     */
+    static debounce(func: (...args: any[]) => void, wait: number): (...args: unknown[]) => void;
+    static throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => ReturnType<T>;
+    static sleep: (s: number) => Promise<void>;
+    static nameof: <T>(name: keyof T) => keyof T;
+    static unsubscribe(sub: UnsubscribeMethod | UnsubscribeMethod[]): void;
+    static notNullValues(target: object): any[];
+}
+export type Without<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type UnsubscribeMethod = () => void;

package/dist/core/utils/utils.js

@@ -0,0 +1,100 @@
+export class Utils {
+    static assertUnreachable(_x) {
+        throw new Error("Didn't expect to get here");
+    }
+    static clone(value) {
+        return structuredClone(value);
+    }
+    /**
+     * Find the greatest common divisor of 2 numbers
+     */
+    static gcd(a, b) {
+        a = Math.abs(a);
+        b = Math.abs(b);
+        if (b > a) {
+            const temp = a;
+            a = b;
+            b = temp;
+        }
+        while (true) {
+            if (b === 0) {
+                return a;
+            }
+            a %= b;
+            if (a === 0) {
+                return b;
+            }
+            b %= a;
+        }
+    }
+    /**
+     * Find the least dividend and divisor by given quotient
+     */
+    static ldd(quotient, divisorLimit = 1000000) {
+        let divisor = 1;
+        while (divisor <= divisorLimit) {
+            const dividend = quotient * divisor;
+            if (dividend % 1 === 0) {
+                return { dividend, divisor };
+            }
+            divisor++;
+        }
+        return null;
+    }
+    /**
+     * Returns a function, that, as long as it continues to be invoked, will not
+     * be triggered. The function will be called after it stops being called for
+     * N milliseconds.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static debounce(func, wait) {
+        let timeout;
+        return (...args) => {
+            const later = () => {
+                func.apply(this, args);
+            };
+            clearTimeout(timeout);
+            timeout = window.setTimeout(later, wait);
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static throttle(func, wait) {
+        // Capture the current time
+        let time = Date.now();
+        return (...args) => {
+            if (time + wait - Date.now() <= 0) {
+                time = Date.now();
+                // Run the function we've passed to our throttler,
+                // and reset the `time` variable (so we can check again).
+                return func.apply(this, args);
+            }
+            return null;
+        };
+    }
+    static sleep = async (s) => {
+        await setTimeout(() => {
+            return;
+        }, s);
+    };
+    static nameof = (name) => name;
+    static unsubscribe(sub) {
+        if (!sub) {
+            return;
+        }
+        const unsubscribeSingle = (sub) => {
+            if (!sub) {
+                return;
+            }
+            sub();
+        };
+        if (sub instanceof Array) {
+            sub.forEach(unsubscribeSingle);
+        }
+        else {
+            unsubscribeSingle(sub);
+        }
+    }
+    static notNullValues(target) {
+        return Object.values(target).filter((x) => !!x);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { type ShortVideoViewerModel } from './short-videos/short-video-viewer';
+export * from './core/enums';

package/dist/index.js

@@ -0,0 +1,2 @@
+export {} from './short-videos/short-video-viewer';
+export * from './core/enums';

package/dist/products/price-helper.d.ts

@@ -0,0 +1,4 @@
+import { Currency } from '../core/enums';
+export declare const toPriceRepresentation: (amount: number, currency: Currency, includeCurrency?: boolean) => string;
+export declare const shouldUseSalePrice: (price: number, salePrice: number | null, effectiveDateFrom: string | null, effectiveDateTo: string | null) => boolean;
+export declare const isSalePriceEffective: (salePrice: number | null, effectiveDateFrom: string | null, effectiveDateTo: string | null) => boolean;