oneentry 1.0.154 → 1.0.156

package/dist/base/timeIntervals.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandTimeIntervals = expandTimeIntervals;
+exports.isTimeIntervalAttribute = isTimeIntervalAttribute;
+exports.expandAttributeTimeIntervals = expandAttributeTimeIntervals;
+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 non-numeric one
+        // would concatenate into it.
+        if (!Number.isFinite(range.period) || range.period <= 0)
+            return;
+        for (let minutes = startMinutes; minutes + range.period <= endMinutes; minutes += range.period) {
+            const from = day + minutes * _MS_PER_MINUTE;
+            const to = day + (minutes + range.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'], …]
+ * ```
+ */
+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
+ * }
+ * ```
+ */
+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'], …]
+ * ```
+ */
+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/dist/base/utils.d.ts

@@ -2,6 +2,7 @@
  * @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.
@@ -44,6 +45,7 @@
 interface IConfig {
     token?: string;
     guestId?: string;
+    deviceMetadata?: string;
     langCode?: string;
     traficLimit?: boolean;
     rawData?: boolean;
@@ -146,7 +148,7 @@ interface ILocalizeInfo {
 }
 /**
  * @interface IAttributeLocalizeInfo
- * @property {ITimeIntervalSchedule[]} [intervals] - For attributes of type `timeInterval`, the precomputed schedule data attached to the localization payload.
+ * @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`.
  */
 interface IAttributeLocalizeInfo extends ILocalizeInfo {
@@ -161,8 +163,9 @@ interface IAttributeLocalizeInfo extends ILocalizeInfo {
  * @property {number} selectedYear - Year the schedule applies to. Example: 2025.
  * @property {ITimeIntervalRange[]} intervals - Daily time ranges configured for the schedule.
  * @property {unknown[]} external - External overrides; empty array when none.
- * @property {unknown[]} range - Date ranges; empty array when none.
- * @description One entry of a `timeInterval` attribute's schedule.
+ * @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;
@@ -171,8 +174,65 @@ interface ITimeIntervalSchedule {
     selectedYear: number;
     intervals: ITimeIntervalRange[];
     external: unknown[];
-    range: 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).
@@ -287,4 +347,4 @@ type LangType = string | Array<string>;
  * LocalizeType
  */
 type LocalizeType = ILocalizeInfo;
-export type { IAttributeLocalizeInfo, IAttributes, IAttributeValue, IAttributeValues, IConfig, IError, IHttpHeaders, IHttpOptions, ILocalizeInfo, IRating, ITimeIntervalPoint, ITimeIntervalRange, ITimeIntervalSchedule, LangType, LocalizeType, };
+export type { IAttributeLocalizeInfo, IAttributes, IAttributeValue, IAttributeValues, IConfig, IError, IHttpHeaders, IHttpOptions, ILocalizeInfo, IRating, ITimeIntervalAttributeValue, ITimeIntervalEntitySchedule, ITimeIntervalGroup, ITimeIntervalPoint, ITimeIntervalRange, ITimeIntervalSchedule, ITimeIntervalWindow, LangType, LocalizeType, TimeIntervalPair, };

package/dist/base/validation.js

@@ -5,7 +5,6 @@ exports.createPaginatedSchema = createPaginatedSchema;
 exports.validateResponse = validateResponse;
 exports.validateResponseSafe = validateResponseSafe;
 /* eslint-disable jsdoc/reject-any-type */
-/* eslint-disable jsdoc/no-undefined-types */
 const zod_1 = require("zod");
 /**
  * Common validation schemas for API responses

package/dist/blocks/blocksApi.js

@@ -43,7 +43,12 @@ class BlocksApi extends asyncModules_1.default {
         const validated = this._validateResponse(response, blocksSchemas_1.BlocksResponseSchema);
         if (!this.state.traficLimit) {
             const normalizeResponse = this._normalizeData(validated);
-            await Promise.all(normalizeResponse.items.map((block) => this._enrichBlock(block, langCode, offset, limit, true)));
+            // On API error responses (e.g. 403 without list permission, 422) the
+            // normalized value is an IError without `items` — skip enrichment and
+            // return it as-is
+            if (Array.isArray(normalizeResponse.items)) {
+                await Promise.all(normalizeResponse.items.map((block) => this._enrichBlock(block, langCode, offset, limit, true)));
+            }
             return normalizeResponse;
         }
         return this._normalizeData(validated);
@@ -169,6 +174,11 @@ class BlocksApi extends asyncModules_1.default {
             signPrice,
         };
         const result = await this._fetchGet(`/${marker}/products?` + this._queryParamsToString(query));
+        // On API error responses there is no `items` array — return the (normalized)
+        // error as-is instead of producing `undefined` from `result.items`.
+        if (!Array.isArray(result === null || result === void 0 ? void 0 : result.items)) {
+            return this._normalizeData(result);
+        }
         return this._normalizeData(result.items);
     }
     /**

package/dist/forms/formsInterfaces.d.ts

@@ -79,7 +79,7 @@ interface IFromPages {
 interface IFormsEntity {
     id: number;
     attributeSetId: number | null;
-    type: 'order' | 'sing_in_up' | 'collection' | 'data' | 'rating' | null;
+    type: 'order' | 'sign_in_up' | 'collection' | 'data' | 'rating' | null;
     localizeInfos: IFormLocalizeInfo;
     version: number;
     position: number;

package/dist/index.d.ts

@@ -4,7 +4,7 @@
 import AdminsApi from './admins/adminsApi';
 import AttributesSetsApi from './attribute-sets/attributeSetsApi';
 import AuthProviderApi from './auth-provider/authProviderApi';
-import type { IConfig } from './base/utils';
+import type { IAttributeValue, IConfig, ITimeIntervalAttributeValue, ITimeIntervalEntitySchedule, ITimeIntervalGroup, ITimeIntervalSchedule, ITimeIntervalWindow, TimeIntervalPair } from './base/utils';
 import BlocksApi from './blocks/blocksApi';
 import DiscountsApi from './discounts/discountsApi';
 import EventsApi from './events/eventsApi';
@@ -29,6 +29,8 @@ import TemplatePreviewsApi from './templates-preview/templatesPreviewApi';
 import UserActivityApi from './user-activity/userActivityApi';
 import UsersApi from './users/usersApi';
 import WsApi from './web-socket/wsApi';
+export { expandAttributeTimeIntervals, expandTimeIntervals, isTimeIntervalAttribute, } from './base/timeIntervals';
+export type { IAttributeValue, ITimeIntervalAttributeValue, ITimeIntervalEntitySchedule, ITimeIntervalGroup, ITimeIntervalSchedule, ITimeIntervalWindow, TimeIntervalPair, };
 /**
  * IDefineApi interface
  * @interface IDefineApi
@@ -123,6 +125,7 @@ interface IDefineApi {
  * @param {IConfig} config - Custom configuration settings
  * @param {string} [config.token] - Optional token parameter
  * @param {string} [config.guestId] - Optional guest identifier sent as the `x-guest-id` header for guest cart/wishlist/activity flows (only while unauthenticated). In the browser, if omitted, a stable per-device id is generated and persisted in localStorage. On the server you MUST pass a per-visitor `guestId` (or call `setGuestId`): the SDK never auto-generates a server id, to avoid sharing one guest across visitors.
+ * @param {string} [config.deviceMetadata] - Optional device-metadata string sent as the `x-device-metadata` header instead of the environment-derived fingerprint. Refresh tokens are bound to this header, so a server issuing tokens for a browser (OAuth code exchange) must pass the browser's string (from `getDeviceMetadata()`), or the token will not be refreshable from that browser.
  * @param {string} [config.langCode] - Optional langCode parameter
  * @param {boolean} [config.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.
  * @param {string} [config.auth] - An object with authorization settings.
@@ -134,4 +137,3 @@ interface IDefineApi {
  * @description Define API.
  */
 export declare function defineOneEntry(url: string, config: IConfig): IDefineApi;
-export {};

package/dist/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTimeIntervalAttribute = exports.expandTimeIntervals = exports.expandAttributeTimeIntervals = void 0;
 exports.defineOneEntry = defineOneEntry;
 /**
  * OneEntry SDK
@@ -35,6 +36,10 @@ const templatesPreviewApi_1 = __importDefault(require("./templates-preview/templ
 const userActivityApi_1 = __importDefault(require("./user-activity/userActivityApi"));
 const usersApi_1 = __importDefault(require("./users/usersApi"));
 const wsApi_1 = __importDefault(require("./web-socket/wsApi"));
+var timeIntervals_1 = require("./base/timeIntervals");
+Object.defineProperty(exports, "expandAttributeTimeIntervals", { enumerable: true, get: function () { return timeIntervals_1.expandAttributeTimeIntervals; } });
+Object.defineProperty(exports, "expandTimeIntervals", { enumerable: true, get: function () { return timeIntervals_1.expandTimeIntervals; } });
+Object.defineProperty(exports, "isTimeIntervalAttribute", { enumerable: true, get: function () { return timeIntervals_1.isTimeIntervalAttribute; } });
 /**
  * Define API.
  * @function defineOneEntry
@@ -42,6 +47,7 @@ const wsApi_1 = __importDefault(require("./web-socket/wsApi"));
  * @param {IConfig} config - Custom configuration settings
  * @param {string} [config.token] - Optional token parameter
  * @param {string} [config.guestId] - Optional guest identifier sent as the `x-guest-id` header for guest cart/wishlist/activity flows (only while unauthenticated). In the browser, if omitted, a stable per-device id is generated and persisted in localStorage. On the server you MUST pass a per-visitor `guestId` (or call `setGuestId`): the SDK never auto-generates a server id, to avoid sharing one guest across visitors.
+ * @param {string} [config.deviceMetadata] - Optional device-metadata string sent as the `x-device-metadata` header instead of the environment-derived fingerprint. Refresh tokens are bound to this header, so a server issuing tokens for a browser (OAuth code exchange) must pass the browser's string (from `getDeviceMetadata()`), or the token will not be refreshable from that browser.
  * @param {string} [config.langCode] - Optional langCode parameter
  * @param {boolean} [config.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.
  * @param {string} [config.auth] - An object with authorization settings.

package/dist/pages/pagesApi.js

@@ -277,6 +277,12 @@ class PagesApi extends asyncModules_1.default {
      * For example, if 100 pages use 3 different templates, this method makes 3 requests instead of 100.
      */
     async addTemplateToPages(data) {
+        // On API error responses (e.g. 403 without list permission, 422) the value
+        // is an IError, not an array — return it as-is instead of calling array
+        // methods (.filter/.map) on it and throwing a TypeError.
+        if (!Array.isArray(data)) {
+            return data;
+        }
         // Step 1: Collect unique templateIdentifiers from all pages
         const uniqueIdentifiers = [
             ...new Set(data
@@ -381,6 +387,11 @@ class StaffModule extends asyncModules_1.default {
     async getProductsByBlockMarker(marker, langCode = this.state.lang, offset = 0, limit = 30) {
         // Fetch products from the server
         const result = await this._fetchGet(`/${marker}/products?langCode=${langCode}&offset=${offset}&limit=${limit}`);
+        // On API error responses there is no `items` array — return the (normalized)
+        // error as-is instead of producing `undefined` from `result.items`.
+        if (!Array.isArray(result === null || result === void 0 ? void 0 : result.items)) {
+            return this._normalizeData(result);
+        }
         return this._normalizeData(result.items);
     }
 }

package/dist/templates-preview/templatesPreviewInterfaces.d.ts

@@ -1,4 +1,4 @@
-import type { IAttributeValues, IError } from '../base/utils';
+import type { IError } from '../base/utils';
 /**
  * @interface ITemplatesPreviewApi
  * @description This interface defines methods for retrieving template previews in the system, including fetching all previews, specific previews by marker.
@@ -69,7 +69,6 @@ interface ITemplatesPreviewApi {
     }
  * @property {string} identifier - The textual identifier for the record field. Example: "preview-templates"
  * @property {number} version - The version number of the object. Example: 1.
- * @property {IAttributeValues} attributeValues - Attribute values from index. Example: {}
  * @property {number} position - The position of the object. Example: 1.
  * @property {boolean} isUsed - Indicates whether the template preview is used. Example: true.
  * @property {string | null} [attributeSetIdentifier] - Text identifier used for a set of attributes. Example: "attribute_set_1".
@@ -81,7 +80,6 @@ interface ITemplatesPreviewEntity {
     proportions: ITemplatesPreviewProportions;
     identifier: string;
     version: number;
-    attributeValues: IAttributeValues;
     position: number;
     isUsed: boolean;
     attributeSetIdentifier?: string | null;

package/dist/templates-preview/templatesPreviewSchemas.d.ts

@@ -45,7 +45,6 @@ export declare const TemplatePreviewEntitySchema: z.ZodObject<{
     }, z.core.$strip>;
     identifier: z.ZodString;
     version: z.ZodNumber;
-    attributeValues: z.ZodRecord<z.ZodString, z.ZodAny>;
     position: z.ZodNumber;
     isUsed: z.ZodBoolean;
     attributeSetIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -76,7 +75,6 @@ export declare const TemplatePreviewsResponseSchema: z.ZodArray<z.ZodObject<{
     }, z.core.$strip>;
     identifier: z.ZodString;
     version: z.ZodNumber;
-    attributeValues: z.ZodRecord<z.ZodString, z.ZodAny>;
     position: z.ZodNumber;
     isUsed: z.ZodBoolean;
     attributeSetIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/templates-preview/templatesPreviewSchemas.js

@@ -37,7 +37,6 @@ exports.TemplatePreviewEntitySchema = zod_1.z.object({
     }),
     identifier: zod_1.z.string(),
     version: zod_1.z.number(),
-    attributeValues: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
     position: zod_1.z.number(),
     isUsed: zod_1.z.boolean(),
     attributeSetIdentifier: zod_1.z.string().nullable().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oneentry",
-  "version": "1.0.154",
+  "version": "1.0.156",
   "description": "OneEntry NPM package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/base/result.d.ts

@@ -1,39 +0,0 @@
-/**
- * Result class for handling response data.
- * @description Result class for handling response data.
- */
-export default class Result {
-    body: any;
-    /**
-     * Constructor that initializes the class with a given data.
-     * @param {Response | string} data - Response or string data.
-     * @description Constructor that initializes the class with a given data, which can be of type Response or string.
-     */
-    constructor(data: Response | string);
-    /**
-     * Asynchronously converts the body to a blob and returns the current instance.
-     * @returns {Promise<Result>} Current instance.
-     * @description Asynchronously converts the body to a blob and returns the current instance.
-     */
-    blob(): Promise<Result>;
-    /**
-     * Asynchronously parses the body as JSON and returns the current instance.
-     * @returns {Promise<Result>} Current instance.
-     * @description Asynchronously parses the body as JSON and returns the current instance.
-     */
-    json(): Promise<Result>;
-    /**
-     * Recursively removes language-specific data from the provided data or the body.
-     * @param {string} langCode - Language code.
-     * @param {any} [data] - Data to process.
-     * @returns {any} Processed data.
-     * @description Recursively removes language-specific data from the provided data or the body.
-     */
-    makeDataWithoutLang(langCode: string, data?: any): any;
-    /**
-     * Recursively simplifies arrays in the provided data or the body by removing single-element arrays.
-     * @param {any} data - The data to simplify.
-     * @returns {any} The simplified data.
-     */
-    makeDataWithoutArray(data?: any): any;
-}