oneentry 1.0.159 → 1.0.161

package/esm/base/timeIntervals.js

@@ -0,0 +1,317 @@
+const _MS_PER_MINUTE = 60000;
+const _MS_PER_DAY = 86400000;
+const _MS_PER_WEEK = 7 * _MS_PER_DAY;
+/**
+ * Converts a date-ish value to the UTC midnight of its day, as epoch milliseconds.
+ *
+ * Everything downstream works on whole UTC days, so this is the single place
+ * where an incoming `Date` / ISO string / timestamp is reduced to a day key.
+ *
+ * `null` is rejected explicitly: `new Date(null)` is the epoch, not an invalid
+ * date, so a NaN check alone would silently accept it as 1970-01-01.
+ * @param {Date | string | number} value - The value to interpret as a date.
+ * @returns {number | null} Epoch ms of the UTC day start, or null when the value is not a valid date.
+ */
+function _toUtcDayStart(value) {
+    if (value === null || value === undefined)
+        return null;
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+/**
+ * Converts a time-of-day point to minutes since midnight.
+ *
+ * Guards the numeric contract: a missing component, or one arriving as a string
+ * (`{ hours: '9' }`), would otherwise poison the arithmetic downstream — either
+ * throwing `RangeError` on `toISOString` or, for strings, concatenating instead
+ * of adding.
+ * @param {ITimeIntervalPoint | undefined} point - The point to convert.
+ * @returns {number | null} Minutes since midnight, or null when the point is malformed.
+ */
+function _toMinutes(point) {
+    if (!point)
+        return null;
+    if (!Number.isFinite(point.hours) || !Number.isFinite(point.minutes)) {
+        return null;
+    }
+    return point.hours * 60 + point.minutes;
+}
+/**
+ * Resolves the days a schedule is active on, clipped to the requested window.
+ *
+ * `anchor` is both the recurrence phase (which weekday / which day-of-month)
+ * and the first day the schedule is valid — nothing before it is ever emitted.
+ * The recurrence rule is open-ended, so `rangeEnd` (the window, intersected
+ * with the schedule's own validity end) is what stops the enumeration.
+ * @param {number} anchor - UTC day start the schedule is anchored to.
+ * @param {number} rangeStart - UTC day start of the first day to consider (inclusive).
+ * @param {number} rangeEnd - UTC day start of the last day to consider (inclusive).
+ * @param {boolean} inEveryWeek - Whether the schedule repeats weekly.
+ * @param {boolean} inEveryMonth - Whether the schedule repeats monthly.
+ * @returns {number[]} Ascending UTC day starts the schedule is active on.
+ */
+function _resolveActiveDays(anchor, rangeStart, rangeEnd, inEveryWeek, inEveryMonth) {
+    const days = [];
+    // Weekly wins over monthly: repeating "every week" already visits every
+    // occurrence of the anchor's weekday in every month, which is exactly what
+    // the two flags combined have always meant.
+    if (inEveryWeek) {
+        const offset = Math.ceil((rangeStart - anchor) / _MS_PER_WEEK);
+        for (let day = anchor + Math.max(0, offset) * _MS_PER_WEEK; day <= rangeEnd; day += _MS_PER_WEEK) {
+            days.push(day);
+        }
+        return days;
+    }
+    // Monthly: the same day-of-month, every month. Months too short for that day
+    // (e.g. the 31st in February) are skipped rather than rolled over.
+    if (inEveryMonth) {
+        const dayOfMonth = new Date(anchor).getUTCDate();
+        const start = new Date(rangeStart);
+        let year = start.getUTCFullYear();
+        let month = start.getUTCMonth();
+        // Walk the calendar month by month. The cursor is the first of the month,
+        // not the emitted day: a month too short for `dayOfMonth` emits nothing and
+        // would otherwise leave the cursor standing still.
+        while (Date.UTC(year, month, 1) <= rangeEnd) {
+            const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+            if (dayOfMonth <= daysInMonth) {
+                const day = Date.UTC(year, month, dayOfMonth);
+                if (day >= rangeStart && day <= rangeEnd)
+                    days.push(day);
+            }
+            month += 1;
+            if (month > 11) {
+                month = 0;
+                year += 1;
+            }
+        }
+        return days;
+    }
+    // No recurrence: a plain date range — every day of it.
+    for (let day = rangeStart; day <= rangeEnd; day += _MS_PER_DAY) {
+        days.push(day);
+    }
+    return days;
+}
+/**
+ * Builds slots for one day from explicit `[start, end]` time pairs.
+ *
+ * Used by entity schedules, where each pair is emitted verbatim as one slot.
+ * @param {number} day - UTC day start, in epoch ms.
+ * @param {ITimeIntervalPoint[][]} times - Daily time ranges as `[start, end]` pairs.
+ * @param {TimeIntervalPair[]} out - Accumulator the produced slots are pushed to.
+ */
+function _addSlotsFromTimes(day, times, out) {
+    times.forEach((range) => {
+        const [start, end] = range !== null && range !== void 0 ? range : [];
+        const startMinutes = _toMinutes(start);
+        const endMinutes = _toMinutes(end);
+        if (startMinutes === null || endMinutes === null)
+            return;
+        const from = day + startMinutes * _MS_PER_MINUTE;
+        const to = day + endMinutes * _MS_PER_MINUTE;
+        out.push([new Date(from).toISOString(), new Date(to).toISOString()]);
+    });
+}
+/**
+ * Builds slots for one day by slicing each range into fixed-length periods.
+ *
+ * Used by form schedules: `start=09:00, end=12:00, period=30` yields
+ * `[09:00–09:30], [09:30–10:00], …, [11:30–12:00]`. A trailing partial slot
+ * that would overrun `end` is not emitted.
+ * @param {number} day - UTC day start, in epoch ms.
+ * @param {ITimeIntervalRange[]} ranges - Daily ranges carrying a slot `period` in minutes.
+ * @param {TimeIntervalPair[]} out - Accumulator the produced slots are pushed to.
+ */
+function _addSlotsFromRanges(day, ranges, out) {
+    ranges.forEach((range) => {
+        const startMinutes = _toMinutes(range === null || range === void 0 ? void 0 : range.start);
+        const endMinutes = _toMinutes(range === null || range === void 0 ? void 0 : range.end);
+        if (startMinutes === null || endMinutes === null)
+            return;
+        // A non-positive period would never advance the cursor; a null or
+        // non-numeric one would concatenate into it.
+        const period = range === null || range === void 0 ? void 0 : range.period;
+        if (typeof period !== 'number' || !Number.isFinite(period) || period <= 0)
+            return;
+        for (let minutes = startMinutes; minutes + period <= endMinutes; minutes += period) {
+            const from = day + minutes * _MS_PER_MINUTE;
+            const to = day + (minutes + period) * _MS_PER_MINUTE;
+            out.push([new Date(from).toISOString(), new Date(to).toISOString()]);
+        }
+    });
+}
+/**
+ * Deduplicates slots by value and sorts them by start, then end.
+ *
+ * A plain `Set` would not do: slots are arrays, so it would compare by
+ * reference and keep every duplicate.
+ * @param {TimeIntervalPair[]} slots - The slots to normalize.
+ * @returns {TimeIntervalPair[]} Sorted, deduplicated slots.
+ */
+function _dedupeAndSort(slots) {
+    const unique = new Map();
+    slots.forEach((slot) => {
+        const key = `${slot[0]}|${slot[1]}`;
+        if (!unique.has(key))
+            unique.set(key, slot);
+    });
+    return [...unique.values()].sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+}
+/**
+ * Narrows a schedule to the entity shape (pages, products, blocks, attribute sets).
+ *
+ * Entity schedules carry `times`; form schedules never do.
+ * @param {ITimeIntervalEntitySchedule | ITimeIntervalSchedule} schedule - The schedule to test.
+ * @returns {boolean} True when the schedule is an entity schedule.
+ */
+function _isEntitySchedule(schedule) {
+    return Array.isArray(schedule.times);
+}
+/**
+ * Expands a `timeInterval` schedule into concrete UTC slots for a given window.
+ *
+ * A schedule as returned by the API is a compact **recurrence rule** — an
+ * anchor date plus daily time ranges plus repeat flags — not a list of slots.
+ * Materializing it wholesale is what makes `timeInterval` attributes expensive
+ * (a year of half-hour slots runs to megabytes), so expansion is on demand and
+ * the window is required: only the caller knows how far it needs to resolve.
+ *
+ * Both schedule shapes the API returns are accepted:
+ * - **entity** — `attributeValues[marker].value[].values[]` on pages, products,
+ * blocks and attribute sets: a `dates` range with `times` pairs;
+ * - **form** — `attributes[marker].localizeInfos.intervals[]`: a `range` with
+ * `intervals` that carry a slot `period` in minutes.
+ *
+ * Semantics:
+ * - `dates[0]` / `range[0]` is both the recurrence phase and the first valid
+ * day — nothing earlier is emitted, however wide the window;
+ * - `dates[1]` / `range[1]` ends validity; when it does not extend past the
+ * start, the schedule is anchored to that day — with a recurrence flag set,
+ * recurrence is then open-ended and the window alone bounds the result;
+ * - `inEveryWeek` repeats every 7 days from the anchor; `inEveryMonth` repeats
+ * on the same day-of-month, skipping months that are too short; with both set
+ * the weekly rule applies, which is what it has always meant in practice;
+ * - with neither flag the schedule is a plain date range — every day of it;
+ * - the result is deduplicated and sorted by start, then end.
+ * @param {ITimeIntervalEntitySchedule | ITimeIntervalSchedule} schedule - A single schedule entry from a `timeInterval` attribute.
+ * @param {ITimeIntervalWindow} window - Inclusive `{ from, to }` range to resolve, compared at UTC day granularity.
+ * @returns {TimeIntervalPair[]} Sorted, deduplicated `[start, end]` ISO pairs; empty when the schedule is malformed or does not overlap the window.
+ * To expand a whole attribute at once, prefer {@link expandAttributeTimeIntervals}
+ * — it walks the groups and merges the results for you. Reach for this function
+ * directly when you already hold a single schedule, e.g. a form's
+ * `localizeInfos.intervals[]`.
+ * @example
+ * ```ts
+ * import { expandTimeIntervals } from 'oneentry';
+ *
+ * // Form attributes are an array keyed by `marker`, and carry their schedules
+ * // already typed on `localizeInfos.intervals`.
+ * const field = form.attributes.find((a) => a.marker === 'booking');
+ *
+ * const slots = (field?.localizeInfos.intervals ?? []).flatMap((schedule) =>
+ *     expandTimeIntervals(schedule, { from: '2025-05-01', to: '2025-05-31' }),
+ * );
+ * // [['2025-05-07T09:00:00.000Z', '2025-05-07T10:00:00.000Z'], …]
+ * ```
+ */
+export function expandTimeIntervals(schedule, window) {
+    var _a, _b;
+    if (!schedule || !window)
+        return [];
+    const isEntity = _isEntitySchedule(schedule);
+    const bounds = isEntity ? schedule.dates : schedule.range;
+    if (!Array.isArray(bounds))
+        return [];
+    const anchor = _toUtcDayStart(bounds[0]);
+    if (anchor === null)
+        return [];
+    const windowFrom = _toUtcDayStart(window.from);
+    const windowTo = _toUtcDayStart(window.to);
+    if (windowFrom === null || windowTo === null || windowTo < windowFrom) {
+        return [];
+    }
+    const inEveryWeek = (_a = schedule.inEveryWeek) !== null && _a !== void 0 ? _a : false;
+    const inEveryMonth = (_b = schedule.inEveryMonth) !== null && _b !== void 0 ? _b : false;
+    // An anchor-only range (start === end) means the schedule is pinned to that
+    // day; with a recurrence rule it then runs open-ended and the window is the
+    // only horizon. Otherwise the second bound ends validity.
+    const declaredEnd = _toUtcDayStart(bounds[1]);
+    const isOpenEnded = (declaredEnd === null || declaredEnd <= anchor) &&
+        (inEveryWeek || inEveryMonth);
+    const validTo = isOpenEnded
+        ? Number.POSITIVE_INFINITY
+        : Math.max(anchor, declaredEnd !== null && declaredEnd !== void 0 ? declaredEnd : anchor);
+    const rangeStart = Math.max(anchor, windowFrom);
+    const rangeEnd = Math.min(validTo, windowTo);
+    if (rangeEnd < rangeStart)
+        return [];
+    const days = _resolveActiveDays(anchor, rangeStart, rangeEnd, inEveryWeek, inEveryMonth);
+    const slots = [];
+    days.forEach((day) => {
+        if (isEntity) {
+            _addSlotsFromTimes(day, schedule.times, slots);
+        }
+        else if (Array.isArray(schedule.intervals)) {
+            _addSlotsFromRanges(day, schedule.intervals, slots);
+        }
+    });
+    return _dedupeAndSort(slots);
+}
+/**
+ * Narrows an attribute value to a `timeInterval` attribute.
+ *
+ * `IAttributeValue.value` is `unknown` — its shape depends on `type` — so this
+ * guard is what lets you reach the schedules without a cast.
+ * @param {IAttributeValue | undefined} attr - The attribute value to test.
+ * @returns {boolean} True when the attribute is a `timeInterval` carrying an array of groups.
+ * @example
+ * ```ts
+ * const attr = page.attributeValues.interval;
+ * if (isTimeIntervalAttribute(attr)) {
+ *     attr.value[0].values[0].dates; // fully typed, no cast
+ * }
+ * ```
+ */
+export function isTimeIntervalAttribute(attr) {
+    return !!attr && attr.type === 'timeInterval' && Array.isArray(attr.value);
+}
+/**
+ * Expands a whole `timeInterval` attribute into concrete UTC slots for a window.
+ *
+ * The one-call path for the common case: it walks the attribute's groups and
+ * their schedules, expands each with {@link expandTimeIntervals}, and merges the
+ * results. Merging matters — deduplication and ordering only hold within a
+ * single schedule, so combining groups by hand can yield duplicate or unsorted
+ * slots.
+ *
+ * Anything that is not a `timeInterval` attribute yields an empty array, so this
+ * is safe to call on an arbitrary attribute without checking `type` first.
+ *
+ * For **form** attributes the schedules are already typed at
+ * `localizeInfos.intervals`, so no equivalent helper is needed — map over them
+ * and call {@link expandTimeIntervals} directly.
+ * @param {IAttributeValue | undefined} attr - A `timeInterval` attribute value, e.g. `page.attributeValues.interval`.
+ * @param {ITimeIntervalWindow} window - Inclusive `{ from, to }` range to resolve, compared at UTC day granularity.
+ * @returns {TimeIntervalPair[]} Sorted, deduplicated `[start, end]` ISO pairs across every group; empty when the attribute is not a `timeInterval`.
+ * @example
+ * ```ts
+ * import { expandAttributeTimeIntervals } from 'oneentry';
+ *
+ * const slots = expandAttributeTimeIntervals(page.attributeValues.interval, {
+ *     from: '2025-04-01',
+ *     to: '2025-04-30',
+ * });
+ * // [['2025-04-14T09:00:00.000Z', '2025-04-14T10:00:00.000Z'], …]
+ * ```
+ */
+export function expandAttributeTimeIntervals(attr, window) {
+    if (!isTimeIntervalAttribute(attr))
+        return [];
+    const slots = attr.value.flatMap((group) => Array.isArray(group === null || group === void 0 ? void 0 : group.values)
+        ? group.values.flatMap((schedule) => expandTimeIntervals(schedule, window))
+        : []);
+    return _dedupeAndSort(slots);
+}

package/esm/base/utils.d.ts

@@ -0,0 +1,354 @@
+/**
+ * @interface IConfig
+ * @property {string} [token] - If your project is protected by a token, specify this token in this parameter.
+ * @property {string} [guestId] - Guest identifier sent as the `x-guest-id` header on unauthenticated requests. Lets cart/wishlist/activity endpoints work for a guest. In the browser a stable id is auto-generated (localStorage) when omitted; on the server pass a per-visitor id. Can also be set later via `setGuestId`.
+ * @property {string} [deviceMetadata] - Device-metadata string sent as the `x-device-metadata` header on POST requests and token refresh, overriding the environment-derived fingerprint. The API binds refresh tokens to this header, so server-side flows that issue tokens on behalf of a browser (e.g. an OAuth code exchange) must pass the browser's string here — otherwise the token is bound to the server's fingerprint and cannot be refreshed from the browser. Obtain the string in the browser via `getDeviceMetadata()`. Can also be set later via `setDeviceMetadata`.
+ * @property {string} [langCode] - specify the default language to avoid specifying it in every request.
+ * @property {boolean} [traficLimit] - Some methods use multiple queries to make it easier to work with the API. Set this parameter to "false" to save traffic and decide for yourself what data you need.
+ * @property {boolean} [rawData] - Set to true to receive raw API responses without any transformation.
+ * @property {object} [validation] - Validation settings for API responses.
+ * @property {boolean} [auth] - An object with authorization settings.
+ * @property {boolean} [auth.customAuth] - Set this flag to true if you want to configure the authorization process yourself. Set the flag to false, or do not pass it at all to have automatic authorization and token renewal.
+ * @property {boolean} [auth.refreshToken] - Transfer the refresh token here, for example from the local storage, to resume the user's session. Otherwise, the user will need to log in every time a new session is created.
+ * @property {boolean} [auth.providerMarker] - The marker of the provider, for example, email, google, facebook, etc. Default 'email';
+ * @property {boolean} [auth.saveFunction] - If you want to store the token between sessions, for example in local storage, create a custom function that takes refreshToken as a parameter and executes the necessary instructions. This function will be called every time the tokens are updated.
+ * @property {object} [errors] - Error handling settings.
+ * @example
+ * ```ts
+ * const saveToken = (token) => {
+ *     localStorage.setItem('refresh', token)
+ * }
+ *
+ * const config = {
+ *     token: 'project.token.here',
+ *     langCode: 'en_US',
+ *     multipleRequests: true,
+ *     auth: {
+ *         customAuth: false,
+ *         refreshToken: 'user.refresh.token',
+ *         providerMarker: 'email',
+ *         saveFunction: saveToken
+ *     },
+ *     errors: {
+ *         isShell: true,
+ *         customErrors: {
+ *             '400': badRequestFunction,
+ *             '404': notFoundFunction,
+ *             '429': rateLimitFunction,
+ *             '500': serverErrorFunction,
+ *             '503': serviceUnavailableFunction
+ *         }
+ *     }
+ * }
+ * ```
+ */
+interface IConfig {
+    token?: string;
+    guestId?: string;
+    deviceMetadata?: string;
+    langCode?: string;
+    traficLimit?: boolean;
+    rawData?: boolean;
+    validation?: {
+        enabled?: boolean;
+        strictMode?: boolean;
+        logErrors?: boolean;
+    };
+    auth?: {
+        customAuth?: boolean;
+        refreshToken?: string;
+        providerMarker?: string;
+        saveFunction?: (refreshToken: string) => void;
+    };
+    errors?: {
+        isShell?: boolean;
+        customErrors?: {
+            400?: (data?: IError) => unknown;
+            401?: (data?: IError) => unknown;
+            403?: (data?: IError) => unknown;
+            404?: (data?: IError) => unknown;
+            429?: (data?: IError) => unknown;
+            500?: (data?: IError) => unknown;
+            502?: (data?: IError) => unknown;
+            503?: (data?: IError) => unknown;
+            504?: (data?: IError) => unknown;
+        };
+    };
+}
+/**
+ * @interface IAttributes
+ * @property {Array<object>} listTitles - Predefined option list for `list`/`enum`-style attributes. Each entry holds a localized label, raw value, sort position, and an `extended` payload with the typed value used by the runtime.
+ * @example
+    [
+      {
+        "title": "Red",
+        "value": "red",
+        "position": 1,
+        "extended": { "value": "#ff0000", "type": "string" }
+      }
+    ]
+ * @property {IAttributeLocalizeInfo} localizeInfos - Localized labels for the attribute (title and other text fields shown in UI). For `timeInterval` attributes, also carries the `intervals` schedule payload.
+ * @property {string} marker - Machine-readable identifier of the attribute, unique within its set. Example: "color".
+ * @property {number} position - Sort position of the attribute inside its set. Example: 1.
+ * @property {boolean} isVisible - Whether the attribute is exposed in the public API/UI. Example: true.
+ * @property {string} type - Attribute data type (e.g. "string", "integer", "list", "file", "image").
+ * @property {Record<string, unknown>} [settings] - Type-specific configuration (e.g. min/max for numbers, accepted MIME types for files). Optional.
+ * @property {Record<string, unknown>} validators - Validation rules applied to the attribute value (e.g. `requiredValidator`, `regexValidator`). Example: { "requiredValidator": { "strict": true } }.
+ * @property {Record<string, IAttributes>} [additionalFields] - Nested sub-attributes attached to this attribute, keyed by marker. Optional.
+ * @property {boolean} [isIcon] - Block/preview attribute flag — whether the field is treated as an icon. Optional.
+ * @property {boolean} [isProductPreview] - Block/preview attribute flag — whether the field is shown in product preview. Optional.
+ * @property {boolean} [isLogin] - Form attribute flag — whether the field carries the login value used for authentication. Optional.
+ * @property {boolean} [isSignUp] - Form attribute flag — whether the field is required during sign-up. Optional.
+ * @property {boolean} [isNotificationEmail] - Form attribute flag — whether the field stores the email used for notifications. Optional.
+ * @property {boolean} [isNotificationPhonePush] - Form attribute flag — whether the field stores the phone number used for push notifications. Optional.
+ * @property {boolean} [isNotificationPhoneSMS] - Form attribute flag — whether the field stores the phone number used for SMS notifications. Optional.
+ * @description Definition of a single attribute inside an attribute set — describes how a field is labeled, validated and rendered.
+ */
+interface IAttributes {
+    listTitles: Array<{
+        title: string;
+        value: number | string | null;
+        position: number;
+        extended: {
+            value: string | number | null;
+            type: string | number | null;
+        };
+    }>;
+    localizeInfos: IAttributeLocalizeInfo;
+    marker: string;
+    position: number;
+    isVisible: boolean;
+    type: string;
+    settings?: Record<string, unknown>;
+    validators: Record<string, unknown>;
+    additionalFields?: Record<string, IAttributes>;
+    isIcon?: boolean;
+    isProductPreview?: boolean;
+    isLogin?: boolean;
+    isSignUp?: boolean;
+    isNotificationEmail?: boolean;
+    isNotificationPhonePush?: boolean;
+    isNotificationPhoneSMS?: boolean;
+}
+/**
+ * @interface ILocalizeInfo
+ * @property {string} title - Localized title of the entity. Example: "Catalog".
+ * @property {string | null} [plainValue] - Localized plain-text content (without HTML markup). Example: "Plain description".
+ * @property {string | null} [htmlValue] - Localized HTML-rendered content. Example: "<p>Description</p>".
+ * @property {string | null} [htmlContent] - Localized HTML body content for richer pages. Example: "<div>...</div>".
+ * @property {string | null} [plainContent] - Localized plain-text version of `htmlContent`; returned by pages and menus. Example: "Description".
+ * @property {string | null} [menuTitle] - Localized title used in menus and navigation. Example: "Home".
+ * @description Normalized localization payload for a single locale, returned by the SDK after unwrapping the API's per-language map.
+ */
+interface ILocalizeInfo {
+    title: string;
+    plainValue?: string | null;
+    htmlValue?: string | null;
+    htmlContent?: string | null;
+    plainContent?: string | null;
+    menuTitle?: string | null;
+}
+/**
+ * @interface IAttributeLocalizeInfo
+ * @property {string} [title] - Localized title of the attribute. Optional — the payload is an empty object when the attribute has no localization for the requested language (e.g. form attributes in list responses). Example: "Color".
+ * @property {ITimeIntervalSchedule[]} [intervals] - For attributes of type `timeInterval`, the schedule data attached to the localization payload. Each entry is a compact recurrence rule — pass it to `expandTimeIntervals` to resolve concrete slots.
+ * @description Extension of {@link ILocalizeInfo} used by attribute entities — adds attribute-type-specific fields the API exposes via `localizeInfos`. Unlike the base type, `title` is optional here.
+ */
+interface IAttributeLocalizeInfo extends Omit<ILocalizeInfo, 'title'> {
+    title?: string;
+    intervals?: ITimeIntervalSchedule[];
+    [key: string]: unknown;
+}
+/**
+ * @interface ITimeIntervalSchedule
+ * @property {string} id - Schedule entry identifier (UUID). Example: "c6466cd8-c55d-4583-97c5-42b684210f12".
+ * @property {number} [fullMonth] - Month index this schedule covers (0-11). Optional — present when the schedule is pinned to a month/year rather than an explicit date `range`. Example: 2.
+ * @property {boolean} inEveryMonth - Whether the schedule repeats every month. Example: true.
+ * @property {number} [selectedYear] - Year the schedule applies to. Optional — present when the schedule is pinned to a month/year rather than an explicit date `range`. Example: 2025.
+ * @property {ITimeIntervalRange[]} intervals - Daily time ranges configured for the schedule.
+ * @property {unknown[]} external - External overrides; empty array when none.
+ * @property {string[]} range - Validity range as a pair of ISO dates `[from, to]`; empty array when none. When both entries are equal the schedule is anchored to that single day and its recurrence is open-ended. Example: ["2025-05-07T21:00:00.000Z", "2025-05-07T21:00:00.000Z"].
+ * @property {boolean} [inEveryWeek] - Whether the schedule repeats every week. Optional.
+ * @description One entry of a `timeInterval` **form** attribute's schedule, carried on `localizeInfos.intervals`. Holds a compact recurrence rule — pass it to `expandTimeIntervals` to resolve concrete slots for a given window.
+ */
+interface ITimeIntervalSchedule {
+    id: string;
+    fullMonth?: number;
+    inEveryMonth: boolean;
+    selectedYear?: number;
+    intervals: ITimeIntervalRange[];
+    external: unknown[];
+    range: string[];
+    inEveryWeek?: boolean;
+}
+/**
+ * @interface ITimeIntervalEntitySchedule
+ * @property {string} id - Schedule entry identifier (UUID). Example: "bbc82c9f-1bc4-4c86-b83c-c062016eb7cb".
+ * @property {string} intervalId - Identifier of the parent interval group (UUID). Example: "c6466cd8-c55d-4583-97c5-42b684210f12".
+ * @property {string[]} dates - Validity range as a pair of ISO dates `[from, to]`. When both entries are equal the schedule is anchored to that single day and its recurrence is open-ended. Example: ["2025-04-14T00:00:00.000Z", "2025-04-14T00:00:00.000Z"].
+ * @property {ITimeIntervalPoint[][]} times - Daily time ranges, each a `[start, end]` pair. Example: [[{ "hours": 9, "minutes": 0 }, { "hours": 10, "minutes": 0 }]].
+ * @property {boolean} inEveryWeek - Whether the schedule repeats every week. Example: true.
+ * @property {boolean} inEveryMonth - Whether the schedule repeats every month. Example: true.
+ * @property {unknown[]} [exceptions] - Excluded dates; empty array when none. Optional.
+ * @property {ITimeIntervalRange[]} [intervals] - Slot-based ranges; empty array on entity schedules, which use `times` instead. Optional.
+ * @description One entry of a `timeInterval` attribute's schedule on pages, products, blocks and attribute sets — found at `attributeValues[marker].value[].values[]`. Holds a compact recurrence rule — pass it to `expandTimeIntervals` to resolve concrete slots for a given window.
+ */
+interface ITimeIntervalEntitySchedule {
+    id: string;
+    intervalId: string;
+    dates: string[];
+    times: ITimeIntervalPoint[][];
+    inEveryWeek: boolean;
+    inEveryMonth: boolean;
+    exceptions?: unknown[];
+    intervals?: ITimeIntervalRange[];
+}
+/**
+ * @interface ITimeIntervalGroup
+ * @property {string} intervalId - Identifier of the interval group (UUID). Example: "c6466cd8-c55d-4583-97c5-42b684210f12".
+ * @property {ITimeIntervalEntitySchedule[]} values - The schedules configured under this group.
+ * @description One entry of a `timeInterval` attribute's `value` array — a group of schedules sharing an `intervalId`.
+ */
+interface ITimeIntervalGroup {
+    intervalId: string;
+    values: ITimeIntervalEntitySchedule[];
+}
+/**
+ * @interface ITimeIntervalAttributeValue
+ * @property {'timeInterval'} type - Discriminant identifying the attribute as a `timeInterval`.
+ * @property {ITimeIntervalGroup[]} value - Groups of schedules attached to the attribute.
+ * @description {@link IAttributeValue} narrowed to `timeInterval` attributes, whose generic `value: unknown` resolves to an array of {@link ITimeIntervalGroup}. Narrow to it with `isTimeIntervalAttribute`, or skip straight to the slots with `expandAttributeTimeIntervals`.
+ */
+interface ITimeIntervalAttributeValue extends IAttributeValue {
+    type: 'timeInterval';
+    value: ITimeIntervalGroup[];
+}
+/**
+ * @interface ITimeIntervalWindow
+ * @property {Date | string | number} from - Inclusive start of the window.
+ * @property {Date | string | number} to - Inclusive end of the window.
+ * @description The bounded range to expand a schedule into. Both bounds are inclusive and compared at UTC day granularity, so the time-of-day component of `from`/`to` is ignored. The window is required: a schedule is an open-ended recurrence rule, and only the caller knows how far it needs to be resolved.
+ */
+interface ITimeIntervalWindow {
+    from: Date | string | number;
+    to: Date | string | number;
+}
+/**
+ * TimeIntervalPair — one resolved slot as a `[start, end]` pair of ISO 8601 UTC timestamps.
+ */
+type TimeIntervalPair = [string, string];
+/**
+ * @interface ITimeIntervalPoint
+ * @property {number} hours - Hour component (0-23).
+ * @property {number} minutes - Minute component (0-59).
+ * @description A point in time within a day, used as start/end of {@link ITimeIntervalRange}.
+ */
+interface ITimeIntervalPoint {
+    hours: number;
+    minutes: number;
+}
+/**
+ * @interface ITimeIntervalRange
+ * @property {string} id - Range identifier (UUID).
+ * @property {ITimeIntervalPoint} start - Start time of the range.
+ * @property {ITimeIntervalPoint} end - End time of the range.
+ * @property {number | null} period - Slot duration in minutes; `null` when the range is not sliced into slots. Example: 60.
+ * @description A single daily time range inside a {@link ITimeIntervalSchedule}.
+ */
+interface ITimeIntervalRange {
+    id: string;
+    start: ITimeIntervalPoint;
+    end: ITimeIntervalPoint;
+    period: number | null;
+}
+/**
+ * @interface IAttributeValue
+ * @property {string} type - Attribute data type (e.g. "string", "integer", "list", "file", "image").
+ * @property {unknown} value - Attribute value — actual TS type depends on `type`, and the SDK normalizes it to the same shape in every module: `string` for "string"/"text"; `number | null` for "integer"/"float"/"real"; the file object itself for a single-file "image"/"file" and an array of them for several; an array for "list" and "groupOfImages". An attribute with no value is always `null`. Example: "Admins text".
+ * @property {number} [position] - Sort position of the value inside its set; the containing collection is returned sorted by it. Example: 0.
+ * @property {Record<string, IAttributeValue> | unknown[]} [additionalFields] - Nested attribute values keyed by marker; the API may also return an empty array when none are configured. Optional.
+ * @property {boolean} [isIcon] - Block/preview attribute flag — whether the field is treated as an icon. Optional.
+ * @property {boolean} [isProductPreview] - Block/preview attribute flag — whether the field is shown in product preview. Optional.
+ * @description A single attribute value attached to an entity (admin, user, page, product, …).
+ */
+interface IAttributeValue {
+    type: string;
+    value: unknown;
+    position?: number;
+    additionalFields?: Record<string, IAttributeValue> | unknown[];
+    isIcon?: boolean;
+    isProductPreview?: boolean;
+}
+/**
+ * @interface IAttributeValues
+ * @description Map of attribute values keyed by attribute marker.
+ */
+interface IAttributeValues {
+    [key: string]: IAttributeValue;
+}
+/**
+ * @interface IRating
+ * @property {number} [value] - Average rating value. Example: 4.5.
+ * @property {number} [like] - Number of likes. Example: 10.
+ * @property {number} [dislike] - Number of dislikes. Example: 2.
+ * @property {string} [method] - Rating calculation method. Example: "average".
+ * @description Rating data attached to an entity. All fields are optional — the API returns an empty object when no rating has been collected yet.
+ */
+interface IRating {
+    value?: number;
+    like?: number;
+    dislike?: number;
+    method?: string;
+}
+/**
+ * @interface IError
+ * @property {string} message - Error message.
+ * @property {unknown} pageData - Page data.
+ * @property {number} statusCode - Status code.
+ * @property {string} timestamp - Timestamp.
+ * @property {string} [localizeMessage] - Human-readable localized error message; populated by the SDK when response validation fails. Optional.
+ * @property {unknown[]} [validationErrors] - Detailed validation issues from Zod when response validation fails. Optional.
+ * @description Interface for error responses returned by the SDK either from the API or from local response validation.
+ */
+interface IError {
+    message: string;
+    pageData: unknown;
+    statusCode: number;
+    timestamp: string;
+    localizeMessage?: string;
+    validationErrors?: unknown[];
+}
+/**
+ * @interface IHttpHeaders
+ * @property {string} [Authorization] - Authorization header.
+ * @description Interface for HTTP headers. Supports the standard `Content-Type`, `Authorization`, and OneEntry-specific `x-app-token` / `x-device-metadata` / `x-guest-id` (guest cart/wishlist/activity) headers, plus arbitrary string entries via the index signature.
+ */
+interface IHttpHeaders {
+    'Content-Type'?: string;
+    'x-app-token'?: string;
+    'x-device-metadata'?: string;
+    'x-guest-id'?: string;
+    Authorization?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * @interface IHttpOptions
+ * @property {string} method - HTTP method
+ * @property {IHttpHeaders} headers - HTTP headers
+ * @property {string | FormData | Blob} [body] - Request body
+ * @description Interface for HTTP request options
+ */
+interface IHttpOptions {
+    method: string;
+    headers: IHttpHeaders;
+    body?: string | FormData | Blob;
+}
+/**
+ * LangType
+ */
+type LangType = string | Array<string>;
+/**
+ * LocalizeType
+ */
+type LocalizeType = ILocalizeInfo;
+export type { IAttributeLocalizeInfo, IAttributes, IAttributeValue, IAttributeValues, IConfig, IError, IHttpHeaders, IHttpOptions, ILocalizeInfo, IRating, ITimeIntervalAttributeValue, ITimeIntervalEntitySchedule, ITimeIntervalGroup, ITimeIntervalPoint, ITimeIntervalRange, ITimeIntervalSchedule, ITimeIntervalWindow, LangType, LocalizeType, TimeIntervalPair, };

package/esm/base/utils.js

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