@coras-io/embed 0.1.0

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

@@ -0,0 +1,6 @@
+export type { Category } from "./category.js";
+export type { SupportedCurrencies } from "./currency.js";
+export type { SupportedLocales } from "./locale.js";
+export type { Rating } from "./rating.js";
+export type { CalculateRewardPointsData, CalculateRewardPoints, } from "./points.js";
+export type { Sorting } from "./sorting.js";

package/dist/core/types/core/index.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/core/locale.d.ts

@@ -0,0 +1,2 @@
+import { allLocales } from "../../i18n/locale-codes.js";
+export type SupportedLocales = (typeof allLocales)[number];

package/dist/core/types/core/locale.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/core/points.d.ts

@@ -0,0 +1,4 @@
+export interface CalculateRewardPointsData {
+    price: number;
+}
+export type CalculateRewardPoints = (data: CalculateRewardPointsData) => number;

package/dist/core/types/core/points.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/core/rating.d.ts

@@ -0,0 +1 @@
+export type Rating = 0 | 0.5 | 1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 4.5 | 5;

package/dist/core/types/core/rating.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/core/sorting.d.ts

@@ -0,0 +1,2 @@
+import { components } from "../api-schema.js";
+export type Sorting = components["schemas"]["SortingGetResponse"]["value"];

package/dist/core/types/core/sorting.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/currencies.d.ts

@@ -0,0 +1,2 @@
+import { supportedCurrencies } from "../currency/constants.js";
+export type Currency = (typeof supportedCurrencies)[number];

package/dist/core/types/currencies.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+export type { Basket, BasketItem, Ticket } from "./basket.js";
+export * from "./core/index.js";
+export type { Currency } from "./currencies.js";
+export type { Locale } from "./locales.js";
+export type { CalculateRewardPointsData } from "../../core/types/core/points.js";
+export type { CorasPaymentStatusDetail, CorasReservationCreatedDetail, } from "../../sdk/types.js";

package/dist/core/types/index.js

@@ -0,0 +1 @@
+export * from "./core/index.js";

package/dist/core/types/locales.d.ts

@@ -0,0 +1,4 @@
+import { allLocales } from "../i18n/locale-codes.js";
+import { SupportedLocales } from "./core/index.js";
+export type Locale = (typeof allLocales)[number];
+export type LocalePrefix = SupportedLocales extends `${infer P}-${string}` ? P : never;

package/dist/core/types/locales.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/seats-config.d.ts

@@ -0,0 +1,13 @@
+import { components } from "./api-schema.js";
+export interface SeatsIoConfig {
+    workspaceKey: string;
+    region: string;
+}
+type ConfigResponse = components["schemas"]["GetConfigSuccessfulResponse"];
+/**
+ * Reads the seats.io workspace key + region from `/config`. Returns null when
+ * seats.io is not configured, which keeps seated selection disabled and falls
+ * back to the section picker.
+ */
+export declare const readSeatsIoConfig: (config: ConfigResponse | undefined) => SeatsIoConfig | null;
+export {};

package/dist/core/types/seats-config.js

@@ -0,0 +1,9 @@
+/**
+ * Reads the seats.io workspace key + region from `/config`. Returns null when
+ * seats.io is not configured, which keeps seated selection disabled and falls
+ * back to the section picker.
+ */
+export const readSeatsIoConfig = (config) => {
+    const workspaceKey = config?.seatsio_public_workspace_key;
+    return workspaceKey ? { workspaceKey, region: config.seatsio_region } : null;
+};

package/dist/core/types/shared.d.ts

@@ -0,0 +1 @@
+export type PageName = "details" | "landing" | "search" | "payment" | "help";

package/dist/core/types/shared.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,77 @@
+import { SupportedLocales } from "../types/index.js";
+/**
+ * Configuration for date/time formatting from API response
+ */
+export interface DateTimeApiData {
+    /** The date/time string as received from API */
+    dateTime: string;
+    /** The timezone string from API */
+    timezone?: string;
+    /** The user's locale from API */
+    locale?: SupportedLocales;
+}
+/**
+ * Options for formatting date/time for display
+ */
+export interface DateTimeDisplayOptions {
+    /** Whether to include time in the output */
+    includeTime?: boolean;
+    /** Whether to include year in the output */
+    includeYear?: boolean;
+    /** Custom format string for date-fns */
+    customFormat?: string;
+    /** Whether to use short format (abbreviated month names, etc.) */
+    shortFormat?: boolean;
+}
+/**
+ * Formats a date/time from API data for display to users
+ * This function handles locale and timezone conversion for proper user display
+ *
+ * @param apiData - The date/time data from API response
+ * @param options - Display formatting options
+ * @returns Formatted date/time string for display
+ */
+export declare const formatDateTimeForDisplay: (apiData: DateTimeApiData, options?: DateTimeDisplayOptions) => string;
+/**
+ * Formats a date/time for display using date-fns-tz (legacy compatibility)
+ * This maintains compatibility with existing formatDateWithTimezone function
+ *
+ * @param dateString - ISO date string
+ * @param timezone - Timezone string
+ * @param formatString - Format string for date-fns
+ * @param includeTime - Whether to include time
+ * @returns Formatted date/time string
+ */
+export declare const formatDateTimeWithTimezone: ({ dateString, timezone, formatString, timeFormatString, includeTime, }: {
+    dateString: string;
+    timezone?: string;
+    formatString?: string;
+    timeFormatString?: string;
+    includeTime?: boolean;
+}) => string;
+/**
+ * Formats time only from API data for display
+ *
+ * @param apiData - The date/time data from API response
+ * @param format12Hour - Whether to use 12-hour format (default: auto-detect based on locale)
+ * @returns Formatted time string
+ */
+export declare const formatTimeForDisplay: (apiData: DateTimeApiData, format12Hour?: boolean) => string;
+/**
+ * Groups availability items by time for display
+ *
+ * @param items - Array of items with start_datetime and timezone
+ * @param locale - User's locale
+ * @returns Map of time strings to grouped items
+ */
+export declare const groupItemsByTime: <T extends {
+    start_datetime?: string;
+    timezone?: string;
+}>(items: T[], locale?: SupportedLocales) => Map<string, T[]>;
+/**
+ * Sorts time strings in chronological order
+ *
+ * @param times - Array of time strings
+ * @returns Sorted array of time strings
+ */
+export declare const sortTimeStrings: (times: string[]) => string[];

package/dist/core/utils/datetime.js

@@ -0,0 +1,153 @@
+import { parseISO } from "date-fns";
+import { format as formatTZ, toZonedTime } from "date-fns-tz";
+import { intlFormat } from "date-fns";
+/**
+ * Formats a date/time from API data for display to users
+ * This function handles locale and timezone conversion for proper user display
+ *
+ * @param apiData - The date/time data from API response
+ * @param options - Display formatting options
+ * @returns Formatted date/time string for display
+ */
+export const formatDateTimeForDisplay = (apiData, options = {}) => {
+    const { includeTime = false, includeYear = false, customFormat, shortFormat = true, } = options;
+    if (!apiData.dateTime) {
+        return "";
+    }
+    try {
+        const date = parseISO(apiData.dateTime);
+        // If custom format is provided, use date-fns-tz for timezone support
+        if (customFormat) {
+            if (apiData.timezone) {
+                const zonedDate = toZonedTime(date, apiData.timezone);
+                return formatTZ(zonedDate, customFormat, {
+                    timeZone: apiData.timezone,
+                });
+            }
+            return formatTZ(date, customFormat);
+        }
+        // Use Intl.DateTimeFormat for locale-aware formatting
+        const formatOptions = {
+            year: includeYear ? "numeric" : undefined,
+            month: shortFormat ? "short" : "long",
+            day: "numeric",
+            ...(includeTime && {
+                hour: "numeric",
+                minute: "2-digit",
+            }),
+            ...(apiData.timezone && { timeZone: apiData.timezone }),
+        };
+        return intlFormat(date, formatOptions, {
+            locale: apiData.locale || "en-GB",
+        });
+    }
+    catch (error) {
+        console.error("Error formatting date for display:", error);
+        return apiData.dateTime; // Fallback to original string
+    }
+};
+/**
+ * Formats a date/time for display using date-fns-tz (legacy compatibility)
+ * This maintains compatibility with existing formatDateWithTimezone function
+ *
+ * @param dateString - ISO date string
+ * @param timezone - Timezone string
+ * @param formatString - Format string for date-fns
+ * @param includeTime - Whether to include time
+ * @returns Formatted date/time string
+ */
+export const formatDateTimeWithTimezone = ({ dateString, timezone, formatString = "d MMM yyyy", timeFormatString = "d MMM yyyy HH:mm", includeTime = false, }) => {
+    if (!dateString) {
+        return "";
+    }
+    try {
+        const date = parseISO(dateString);
+        if (timezone) {
+            const zonedDate = toZonedTime(date, timezone);
+            return formatTZ(zonedDate, includeTime ? timeFormatString : formatString, {
+                timeZone: timezone,
+            });
+        }
+        return formatTZ(date, includeTime ? timeFormatString : formatString);
+    }
+    catch (error) {
+        console.error("Error formatting date with timezone:", error);
+        return dateString; // Fallback to original string
+    }
+};
+/**
+ * Formats time only from API data for display
+ *
+ * @param apiData - The date/time data from API response
+ * @param format12Hour - Whether to use 12-hour format (default: auto-detect based on locale)
+ * @returns Formatted time string
+ */
+export const formatTimeForDisplay = (apiData, format12Hour) => {
+    if (!apiData.dateTime) {
+        return "";
+    }
+    try {
+        const date = parseISO(apiData.dateTime);
+        const locale = apiData.locale || "en-GB";
+        const formatOptions = {
+            hour: "numeric",
+            minute: "2-digit",
+            ...(apiData.timezone && { timeZone: apiData.timezone }),
+        };
+        // If format12Hour is explicitly provided, use it
+        // Otherwise, let the locale determine the format (auto-detect)
+        if (format12Hour !== undefined) {
+            formatOptions.hour12 = format12Hour;
+        }
+        return date.toLocaleTimeString(locale, formatOptions);
+    }
+    catch (error) {
+        console.error("Error formatting time for display:", error);
+        return apiData.dateTime;
+    }
+};
+/**
+ * Groups availability items by time for display
+ *
+ * @param items - Array of items with start_datetime and timezone
+ * @param locale - User's locale
+ * @returns Map of time strings to grouped items
+ */
+export const groupItemsByTime = (items, locale = "en-GB") => {
+    const timeGroups = new Map();
+    items.forEach((item) => {
+        if (!item.start_datetime) {
+            return;
+        }
+        const timeString = formatTimeForDisplay({
+            dateTime: item.start_datetime,
+            timezone: item.timezone,
+            locale,
+        });
+        if (!timeGroups.has(timeString)) {
+            timeGroups.set(timeString, []);
+        }
+        timeGroups.get(timeString).push(item);
+    });
+    return timeGroups;
+};
+/**
+ * Sorts time strings in chronological order
+ *
+ * @param times - Array of time strings
+ * @returns Sorted array of time strings
+ */
+export const sortTimeStrings = (times) => {
+    return [...times].sort((a, b) => {
+        try {
+            // Create dates with same day to compare times
+            const dateA = new Date(`1970/01/01 ${a}`);
+            const dateB = new Date(`1970/01/01 ${b}`);
+            return dateA.getTime() - dateB.getTime();
+        }
+        catch {
+            // Fallback to string comparison if parsing fails
+            return a.localeCompare(b);
+        }
+    });
+};

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

@@ -0,0 +1,4 @@
+export declare const debounce: <Args extends unknown[]>({ delay }: {
+    delay: number;
+}, func: (...args: Args) => void) => (...args: Args) => void;
+export declare const memo: <Args extends unknown[], Result>(func: (...args: Args) => Result) => (...args: Args) => Result;

package/dist/core/utils/function.js

@@ -0,0 +1,22 @@
+// Delay invoking `func` until `delay` ms have elapsed since the last call, so
+// rapid triggers (typing, prop changes) collapse into a single trailing call.
+export const debounce = ({ delay }, func) => {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => func(...args), delay);
+    };
+};
+// Cache `func`'s result per unique argument set, keyed by their JSON form, so
+// repeated calls with the same inputs skip recomputation.
+export const memo = (func) => {
+    const cache = new Map();
+    return (...args) => {
+        const key = JSON.stringify({ args });
+        if (cache.has(key))
+            return cache.get(key);
+        const result = func(...args);
+        cache.set(key, result);
+        return result;
+    };
+};

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

@@ -0,0 +1,28 @@
+/** Sanitize untrusted HTML before inlining it via lit's `unsafeHTML`. */
+export declare const sanitizeHtml: (input: string) => string;
+/**
+ * Sanitize an SVG fragment before inlining it via lit's `unsafeSVG`. Icon
+ * sprites are fetched from the integrator's asset host, so a compromised host
+ * could otherwise inline scripting; the SVG profile keeps drawing elements only.
+ *
+ * The input is the inner markup of a `<symbol>` (e.g. bare `<path>`s), which the
+ * SVG profile drops without an `<svg>` root, so we sanitize inside a wrapper and
+ * return its inner contents.
+ */
+export declare const sanitizeSvg: (input: string) => string;
+export declare const removeHtmlTags: (htmlString: string) => string;
+/**
+ * Removes newlines (\n) on the left and right of HTML tags
+ * @param htmlString - The HTML string to process
+ * @returns The HTML string with newlines around tags removed
+ */
+export declare const removeNewlinesAroundTags: (htmlString: string) => string;
+/**
+ * Normalizes list markup coming from external HTML sources.
+ *
+ * Many providers wrap the first list item line in a <p> tag, which causes
+ * the bullet to appear on one line and the text on the next. This function
+ * unwraps the first <p> directly inside each <li> (optionally nested in a <span>)
+ * so that the bullet and the first line content stay on the same line.
+ */
+export declare const normalizeListItems: (htmlString: string) => string;

package/dist/core/utils/html.js

@@ -0,0 +1,78 @@
+import DOMPurify from "dompurify";
+// DOMPurify's defaults already strip scripts and event handlers; we also forbid
+// `style` tags/attributes so that, even if a sanitizer bypass surfaced, it could
+// not smuggle CSS-based layout attacks or data exfiltration.
+const NO_STYLE = { FORBID_TAGS: ["style"], FORBID_ATTR: ["style"] };
+/** Sanitize untrusted HTML before inlining it via lit's `unsafeHTML`. */
+export const sanitizeHtml = (input) => DOMPurify.sanitize(input, { ...NO_STYLE });
+/**
+ * Sanitize an SVG fragment before inlining it via lit's `unsafeSVG`. Icon
+ * sprites are fetched from the integrator's asset host, so a compromised host
+ * could otherwise inline scripting; the SVG profile keeps drawing elements only.
+ *
+ * The input is the inner markup of a `<symbol>` (e.g. bare `<path>`s), which the
+ * SVG profile drops without an `<svg>` root, so we sanitize inside a wrapper and
+ * return its inner contents.
+ */
+export const sanitizeSvg = (input) => {
+    const clean = DOMPurify.sanitize(`<svg>${input}</svg>`, {
+        USE_PROFILES: { svg: true, svgFilters: true },
+        ...NO_STYLE,
+    });
+    return clean.replace(/^<svg[^>]*>/i, "").replace(/<\/svg>$/i, "");
+};
+export const removeHtmlTags = (htmlString) => {
+    if (htmlString === null || htmlString === "") {
+        return "";
+    }
+    else {
+        return htmlString.replace(/<[^>]*>/g, "");
+    }
+};
+/**
+ * Removes newlines (\n) on the left and right of HTML tags
+ * @param htmlString - The HTML string to process
+ * @returns The HTML string with newlines around tags removed
+ */
+export const removeNewlinesAroundTags = (htmlString) => {
+    if (htmlString === null || htmlString === "") {
+        return "";
+    }
+    // Remove newlines before opening tags
+    let result = htmlString.replace(/\n\s*<(?!\/)/g, "<");
+    // Remove newlines after opening tags
+    result = result.replace(/<(?!\/)[^>]*>\s*\n/g, (match) => {
+        return match.replace(/>\s*\n/, ">");
+    });
+    // Remove newlines before closing tags
+    result = result.replace(/\n\s*<\//g, "</");
+    // Remove newlines after closing tags only if followed by another tag
+    // This preserves newlines that might be meaningful for document formatting
+    result = result.replace(/<\/[^>]*>\s*\n\s*</g, (match) => {
+        return match.replace(/>\s*\n\s*</, "><");
+    });
+    return result;
+};
+/**
+ * Normalizes list markup coming from external HTML sources.
+ *
+ * Many providers wrap the first list item line in a <p> tag, which causes
+ * the bullet to appear on one line and the text on the next. This function
+ * unwraps the first <p> directly inside each <li> (optionally nested in a <span>)
+ * so that the bullet and the first line content stay on the same line.
+ */
+export const normalizeListItems = (htmlString) => {
+    if (htmlString === null || htmlString === "") {
+        return "";
+    }
+    let result = htmlString;
+    // Case 1: <li><span><p>... becomes <li><span>...
+    result = result.replace(/<li(\s[^>]*)?>\s*(<span[^>]*>)\s*<p[^>]*>([\s\S]*?)<\/p>/gi, (_m, liAttrs = "", spanOpen, pContent) => {
+        return `<li${liAttrs ? liAttrs : ""}>${spanOpen}${pContent}`;
+    });
+    // Case 2: <li><p>... becomes <li>...
+    result = result.replace(/<li(\s[^>]*)?>\s*<p[^>]*>([\s\S]*?)<\/p>/gi, (_m, liAttrs = "", pContent) => {
+        return `<li${liAttrs ? liAttrs : ""}>${pContent}`;
+    });
+    return result;
+};

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

@@ -0,0 +1,3 @@
+import { SupportedLocales } from "../types/index.js";
+import { LocalePrefix } from "../types/locales.js";
+export declare function getLocalePrefix(locale: SupportedLocales): LocalePrefix;

package/dist/core/utils/locale.js

@@ -0,0 +1,3 @@
+export function getLocalePrefix(locale) {
+    return locale.split("-")[0];
+}

package/dist/core/utils/scroll-lock.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Centralized scroll lock manager using reference counting.
+ *
+ * Only the first `lock()` saves the original body state and scroll position.
+ * Only the last `unlock()` (count → 0) restores them — and the restore is
+ * **deferred** to the next animation frame so that dialog-to-dialog transitions
+ * within the same Lit render cycle can cancel it by calling `lock()` again.
+ *
+ * This prevents the scroll-position-loss bug that occurs when Dialog A is
+ * removed from the DOM (unlocking scroll) and Dialog B is created (locking
+ * scroll) in the same synchronous render pass.
+ */
+declare class ScrollLockManager {
+    private _lockCount;
+    private _scrollY;
+    private _savedState;
+    private _pendingRestore;
+    /**
+     * Request a scroll lock. The first caller captures the original
+     * body styles and scroll position. Subsequent callers only
+     * increment the reference count.
+     */
+    lock(): void;
+    /**
+     * Release a scroll lock. Only restores original body styles and
+     * scroll position when all locks have been released (count → 0),
+     * and the restore is deferred to the next animation frame.
+     */
+    unlock(): void;
+    /**
+     * Force immediate restore without waiting for the next frame.
+     * Cancels any pending deferred restore. Useful in tests for
+     * synchronous assertions.
+     */
+    flushRestore(): void;
+    /** Whether any lock is currently active. */
+    get isLocked(): boolean;
+    /** Current number of active locks. */
+    get lockCount(): number;
+    /**
+     * Reset all internal state. Intended ONLY for test cleanup.
+     * Does NOT restore body styles — the caller (test afterEach)
+     * should handle that.
+     */
+    _resetForTesting(): void;
+    private _applyRestore;
+}
+/** Singleton instance shared across all dialog components. */
+export declare const scrollLock: ScrollLockManager;
+export {};

package/dist/core/utils/scroll-lock.js

@@ -0,0 +1,121 @@
+/**
+ * Centralized scroll lock manager using reference counting.
+ *
+ * Only the first `lock()` saves the original body state and scroll position.
+ * Only the last `unlock()` (count → 0) restores them — and the restore is
+ * **deferred** to the next animation frame so that dialog-to-dialog transitions
+ * within the same Lit render cycle can cancel it by calling `lock()` again.
+ *
+ * This prevents the scroll-position-loss bug that occurs when Dialog A is
+ * removed from the DOM (unlocking scroll) and Dialog B is created (locking
+ * scroll) in the same synchronous render pass.
+ */
+class ScrollLockManager {
+    constructor() {
+        this._lockCount = 0;
+        this._scrollY = 0;
+        this._savedState = null;
+        this._pendingRestore = null;
+    }
+    /**
+     * Request a scroll lock. The first caller captures the original
+     * body styles and scroll position. Subsequent callers only
+     * increment the reference count.
+     */
+    lock() {
+        // If a deferred restore is pending, cancel it — we still need the lock
+        if (this._pendingRestore !== null) {
+            cancelAnimationFrame(this._pendingRestore);
+            this._pendingRestore = null;
+        }
+        if (this._lockCount === 0) {
+            if (!this._savedState) {
+                this._scrollY = window.scrollY;
+                this._savedState = {
+                    overflow: document.body.style.overflow,
+                    position: document.body.style.position,
+                    top: document.body.style.top,
+                    width: document.body.style.width,
+                    htmlOverflow: document.documentElement.style.overflow,
+                };
+            }
+        }
+        this._lockCount++;
+        document.documentElement.style.overflow = "hidden";
+        document.body.style.overflow = "hidden";
+        document.body.style.position = "fixed";
+        document.body.style.top = `-${this._scrollY}px`;
+        document.body.style.width = "100%";
+    }
+    /**
+     * Release a scroll lock. Only restores original body styles and
+     * scroll position when all locks have been released (count → 0),
+     * and the restore is deferred to the next animation frame.
+     */
+    unlock() {
+        if (this._lockCount === 0) {
+            return;
+        }
+        this._lockCount--;
+        if (this._lockCount === 0) {
+            this._pendingRestore = requestAnimationFrame(() => {
+                this._pendingRestore = null;
+                if (this._lockCount > 0 || !this._savedState) {
+                    return;
+                }
+                this._applyRestore();
+            });
+        }
+    }
+    /**
+     * Force immediate restore without waiting for the next frame.
+     * Cancels any pending deferred restore. Useful in tests for
+     * synchronous assertions.
+     */
+    flushRestore() {
+        if (this._pendingRestore !== null) {
+            cancelAnimationFrame(this._pendingRestore);
+            this._pendingRestore = null;
+            if (this._lockCount === 0 && this._savedState) {
+                this._applyRestore();
+            }
+        }
+    }
+    /** Whether any lock is currently active. */
+    get isLocked() {
+        return this._lockCount > 0;
+    }
+    /** Current number of active locks. */
+    get lockCount() {
+        return this._lockCount;
+    }
+    /**
+     * Reset all internal state. Intended ONLY for test cleanup.
+     * Does NOT restore body styles — the caller (test afterEach)
+     * should handle that.
+     */
+    _resetForTesting() {
+        if (this._pendingRestore !== null) {
+            cancelAnimationFrame(this._pendingRestore);
+            this._pendingRestore = null;
+        }
+        this._lockCount = 0;
+        this._scrollY = 0;
+        this._savedState = null;
+    }
+    _applyRestore() {
+        if (!this._savedState)
+            return;
+        document.documentElement.style.overflow = this._savedState.htmlOverflow;
+        document.body.style.overflow = this._savedState.overflow;
+        document.body.style.position = this._savedState.position;
+        document.body.style.top = this._savedState.top;
+        document.body.style.width = this._savedState.width;
+        const scrollY = this._scrollY;
+        this._savedState = null;
+        this._scrollY = 0;
+        window.scrollTo(0, scrollY);
+    }
+}
+/** Singleton instance shared across all dialog components. */
+export const scrollLock = new ScrollLockManager();

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

@@ -0,0 +1,9 @@
+export declare const truncate: ({ text, sentencesCount, maxLength, ellipsis, }: {
+    text: string;
+    sentencesCount?: number;
+    maxLength?: number;
+    ellipsis?: string;
+}) => string;
+export declare const isNilOrEmpty: (text: string | null | undefined) => boolean;
+export declare const capitalize: (text: string) => string;
+export declare const title: (text: string | null | undefined) => string;