oneentry 1.0.155 → 1.0.156

package/README.md

@@ -181,6 +181,25 @@ const api = defineOneEntry('your-url', {
 
 OneEntry SDK supports optional validation of API responses using Zod. This feature is disabled by default and can be enabled for development or critical operations.
 
+### Time Intervals
+
+Attributes of type `timeInterval` return a compact recurrence rule (an anchor date, daily time ranges and repeat flags), not a ready list of slots. The SDK does not expand it eagerly — a single attribute can materialize into megabytes of slots — so resolve it on demand with `expandAttributeTimeIntervals`, passing the window you actually render:
+
+```js
+import { defineOneEntry, expandAttributeTimeIntervals } from 'oneentry'
+
+const { Pages } = defineOneEntry('your-url', { token: 'your-app-token' })
+const page = await Pages.getPageByUrl('booking')
+
+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'], …]
+```
+
+Also exported: `expandTimeIntervals(schedule, window)` for a single schedule (e.g. a form's `localizeInfos.intervals`), and the `isTimeIntervalAttribute` type guard.
+
 ### Errors
 
 If you want to escape errors inside the sc, leave the "errors" property by default.

package/changelog.md

@@ -1,5 +1,69 @@
 # SDK Change Log
 
+## v.1.0.156
+
+### What's New
+
+- `expandAttributeTimeIntervals(attr, { from, to })` — new top-level export that resolves a whole `timeInterval` attribute into concrete `[start, end]` ISO pairs for a window you choose. This is the one-call replacement for the removed `timeIntervals` field: it walks the attribute's groups and schedules and merges the results (merging matters — deduplication and ordering only hold within a single schedule). Anything that is not a `timeInterval` attribute yields an empty array, so it is safe to call without checking `type` first.
+
+  ```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'], …]
+  ```
+
+- `expandTimeIntervals(schedule, { from, to })` — new top-level export that resolves a single schedule. Accepts both shapes the API returns: entity schedules (`attributeValues[marker].value[].values[]` on pages, products, blocks and attribute sets) and form schedules (`attributes[].localizeInfos.intervals[]`). Use it when you already hold one schedule — most notably on forms, whose schedules are already typed:
+
+  ```ts
+  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' }),
+  );
+  ```
+
+  Both functions are pure — they do not mutate their input and perform no requests.
+
+- `isTimeIntervalAttribute(attr)` — new exported type guard narrowing an `IAttributeValue` to `ITimeIntervalAttributeValue`. `IAttributeValue.value` is `unknown` because its shape depends on `type`; this guard is what lets you reach the schedules without a cast:
+
+  ```ts
+  const attr = page.attributeValues.interval;
+  if (isTimeIntervalAttribute(attr)) {
+    attr.value[0].values[0].dates; // fully typed
+  }
+  ```
+
+- `ITimeIntervalAttributeValue`, `ITimeIntervalGroup`, `ITimeIntervalEntitySchedule`, `ITimeIntervalWindow` and `TimeIntervalPair` — new exported types covering the whole `timeInterval` payload: the attribute, its groups, an entity schedule, the expansion window and a resolved slot. `ITimeIntervalSchedule` and `IAttributeValue` are now exported for the same reason. The payload previously had no typed representation at all.
+
+### What's Changed
+
+- `ITimeIntervalSchedule` — `range` is typed `string[]` instead of `unknown[]` (it is a pair of ISO dates), and the optional `inEveryWeek` flag is documented; the SDK always read it, but the interface omitted it.
+
+### Bug Fixes
+
+These affect `expandTimeIntervals`, which replaces the removed built-in expansion:
+
+- The expansion horizon is no longer hardcoded. Monthly recurrence stopped exactly 12 months after the anchor and weekly recurrence stopped at the end of the anchor's month, so slots beyond that could not be obtained at all. The window is now the horizon.
+- A schedule with no recurrence flags (`inEveryWeek: false, inEveryMonth: false`) produced no intervals at all — `_processScheduleDates` had no branch for that case. A plain date range now yields slots for every day in it.
+- Weekly recurrence combined with monthly no longer emits dates **before** the schedule's start date. The old branch walked from the 1st of the anchor's month, so a schedule starting Monday 2025-04-14 also emitted 2025-04-07.
+- Weekly recurrence was host-timezone dependent: it computed its end-of-month bound with `getFullYear`/`getMonth` (local time) while every other date operation used UTC, so the result shifted with the machine's timezone. All arithmetic is now UTC.
+- Weekly+monthly recurrence silently dropped months: it advanced the month before pinning the day to the 1st, so an anchor on the 31st overflowed short months and lost 5 of 12 months.
+- Identical intervals are now actually deduplicated. The old code collected into a `Set` of array references, which compares by identity, so duplicates always survived despite the intent.
+- A range with a non-positive `period` no longer hangs. The slot loop never advanced its cursor and spun forever; such ranges are now skipped.
+- Malformed input no longer throws. `_addTimeIntervalsToFormSchedules` dereferenced its argument unguarded (`TypeError` on `undefined`), and both expanders read `dates[0]` / `range[0]` without checking the array existed. `expandTimeIntervals` returns an empty array instead.
+
+### What's Deleted
+
+- **Breaking** — the computed `timeIntervals` field is no longer added to `timeInterval` attribute values. It was injected into every response carrying a `timeInterval` attribute (pages, products, blocks, attribute sets and forms) and materialized a full year of slots regardless of what the caller needed: a single attribute with hourly slots expanded to roughly 2,000 lines of JSON, and finer slot periods reached megabytes — enough to blow past framework data-cache limits. The field was never declared in any interface or Zod schema, so TypeScript consumers could only reach it through a cast.
+
+  Migrate by calling `expandAttributeTimeIntervals(attr, window)` with the window you actually render. The source data it expands (`dates`/`range`, `times`/`intervals`, `inEveryWeek`, `inEveryMonth`) is unchanged and still on every schedule, so nothing is lost — it is now resolved on demand instead of eagerly, and the compact rule is what gets cached.
+
+- `_addTimeIntervalsToSchedules` and `_addTimeIntervalsToFormSchedules` — removed from every module. Despite the `_` prefix these were public and callable (e.g. `Pages._addTimeIntervalsToSchedules`). Use `expandTimeIntervals`.
+
 ## v.1.0.155
 
 ### What's New
@@ -247,7 +311,7 @@
 
 - Discounts > `getAllDiscounts` — removed `'PERSONAL_BONUS'` from type filter parameter.
 
-- Forms > `IFormsEntity` — type narrowed to `'order' | 'sing_in_up' | 'collection' | 'data' | 'rating'`, removed `moduleFormConfigs` field.
+- Forms > `IFormsEntity` — type narrowed to `'order' | 'sign_in_up' | 'collection' | 'data' | 'rating'`, removed `moduleFormConfigs` field.
 
 - Products > `getProductsEmptyPage` — changed from GET to POST, added `body` parameter, return type changed to `IAggregatedProductGroup[]`.
 

package/dist/base/syncModules.d.ts

@@ -111,113 +111,6 @@ export default abstract class SyncModules {
      * @returns {any} Sorted attributes.
      */
     protected _sortAttributes: (data: any) => any;
-    /**
-     * Adds a specified number of days to a date.
-     * @param {Date} date - The initial date.
-     * @param {number} days - The number of days to add.
-     * @returns {any} The new date with added days.
-     */
-    protected _addDays(date: Date, days: number): any;
-    /**
-     * Common logic for processing schedule dates (weekly, monthly, or both).
-     *
-     * Abstracts date iteration for three scheduling modes:
-     *
-     * - **`inEveryWeek` only**: starting from the start date, generates dates
-     * with a 7-day step until the end of the current month.
-     *
-     * - **`inEveryMonth` only**: pins the day-of-month from the start date
-     * and repeats it for each of the next 12 months. If the month does not
-     * have that day (e.g. Feb 31), the iteration is skipped.
-     *
-     * - **`inEveryWeek` + `inEveryMonth`**: for each of the next 12 months finds
-     * the first occurrence of the target weekday (from the start date), then
-     * iterates all occurrences of that weekday in the month with a 7-day step.
-     *
-     * `processDate(currentDate)` is called for every resolved date.
-     * @param {Date} date - The date for which to process intervals.
-     * @param {object} config - Configuration for schedule repetition.
-     * @param {boolean} config.inEveryWeek - Whether to repeat weekly.
-     * @param {boolean} config.inEveryMonth - Whether to repeat monthly.
-     * @param {(currentDate: Date) => void} processDate - Callback function to process each date.
-     */
-    protected _processScheduleDates(date: Date, config: {
-        inEveryWeek: boolean;
-        inEveryMonth: boolean;
-    }, processDate: (currentDate: Date) => void): void;
-    /**
-     * Generates intervals for a specific date based on a schedule.
-     *
-     * For each date resolved by `_processScheduleDates`, iterates over
-     * the `schedule.times` array of time ranges. Each range is a pair
-     * `[startTime, endTime]` with `{ hours, minutes }` fields.
-     * Creates an ISO interval `[start.toISOString(), end.toISOString()]`
-     * and adds it to `utcIntervals` (Set deduplicates automatically).
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} schedule - The schedule defining the intervals.
-     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
-     * @param {any[]} schedule.times - The times for each interval.
-     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
-     */
-    protected _generateIntervalsForDate(date: Date, schedule: {
-        inEveryWeek: boolean;
-        times: any[];
-        inEveryMonth: boolean;
-    }, utcIntervals: Set<Array<string>>): void;
-    /**
-     * Adds time intervals to schedules.
-     *
-     * Accepts an array of schedule groups (structure of `timeInterval` attributes
-     * for pages/products). For each group iterates over `values` — the set of
-     * concrete schedules. Each schedule contains a date range `dates[0..1]`.
-     *
-     * If both boundaries are equal (`isSameDay`), intervals are generated only
-     * for that single date. Otherwise — for every day in the range inclusive.
-     *
-     * The result (`schedule.timeIntervals`) is a sorted array of ISO pairs,
-     * ready to pass to UI components.
-     * @param {any[]} schedules - The schedules to process.
-     * @returns {any} Schedules with added time intervals.
-     */
-    _addTimeIntervalsToSchedules(schedules: any[]): any;
-    /**
-     * Generates intervals for a specific date for form schedules.
-     *
-     * Unlike `_generateIntervalsForDate`, time ranges here have a different shape:
-     * each `timeInterval` contains `start`, `end` and `period`
-     * (slot length in minutes). The method slices the [start, end) window into
-     * fixed-length slots of `period` minutes:
-     *
-     * start=09:00, end=12:00, period=30 → [09:00–09:30], [09:30–10:00], …, [11:30–12:00]
-     *
-     * Generation stops if the next slot would exceed `end`.
-     * Each slot is added to `utcIntervals` (Set deduplicates automatically).
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} interval - The interval configuration.
-     * @param {boolean} interval.inEveryWeek - Indicates whether the schedule is weekly.
-     * @param {boolean} interval.inEveryMonth - Indicates whether the schedule is monthly.
-     * @param {any[]} timeIntervals - The time intervals to process.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
-     */
-    protected _generateIntervalsForFormDate(date: Date, interval: {
-        inEveryWeek: boolean;
-        inEveryMonth: boolean;
-    }, timeIntervals: any[], utcIntervals: Set<Array<string>>): void;
-    /**
-     * Adds time intervals to form schedules (different structure).
-     *
-     * Same as `_addTimeIntervalsToSchedules` but for `timeInterval` attributes
-     * in **forms** (different API data structure):
-     * - `interval.range[0..1]` instead of `schedule.dates[0..1]`
-     * - `interval.intervals` — array of time ranges with slots (`period`)
-     * instead of `[startTime, endTime]` pairs
-     *
-     * Result is written to `interval.timeIntervals`.
-     * @param {any[]} intervals - The intervals to process.
-     * @returns {any} Intervals with added time intervals.
-     */
-    _addTimeIntervalsToFormSchedules(intervals: any[]): any;
     /**
      * Transforms additionalFields from array to object keyed by marker.
      *
@@ -238,16 +131,20 @@ export default abstract class SyncModules {
      * Contains an object `{ marker: AttrObject }`. For each attribute:
      * - `_normalizeAdditionalFields` is called;
      * - numeric types (`integer`, `float`) are cast to a JS number (or `null`);
-     * - `timeInterval` attributes are enriched with computed `timeIntervals`;
      * - the whole object is re-sorted by `position`.
      *
      * **2. `attributes`** — form attributes (different API structure).
-     * Same `additionalFields` and `timeInterval` processing,
+     * Same `additionalFields` processing,
      * but numbers are not normalized here (commented out — logic differs).
      *
      * **3. `type`** — a single attribute from an attribute set.
      * Same transformations as in case 1, but without sorting.
      *
+     * `timeInterval` attributes are left exactly as the API returned them — a
+     * compact recurrence rule. Resolving one into concrete slots is the caller's
+     * job, via `expandTimeIntervals`: the rule is open-ended, so only the caller
+     * knows how wide a window it needs.
+     *
      * If none of the keys are found — data is returned unchanged.
      * @param {any} data - The data to normalize.
      * @returns {any} Normalized attributes.

package/dist/base/syncModules.js

@@ -286,253 +286,6 @@ class SyncModules {
             return data;
         }
     }
-    /**
-     * Adds a specified number of days to a date.
-     * @param {Date} date - The initial date.
-     * @param {number} days - The number of days to add.
-     * @returns {any} The new date with added days.
-     */
-    _addDays(date, days) {
-        const result = new Date(date);
-        result.setUTCDate(result.getUTCDate() + days);
-        return result;
-    }
-    /**
-     * Common logic for processing schedule dates (weekly, monthly, or both).
-     *
-     * Abstracts date iteration for three scheduling modes:
-     *
-     * - **`inEveryWeek` only**: starting from the start date, generates dates
-     * with a 7-day step until the end of the current month.
-     *
-     * - **`inEveryMonth` only**: pins the day-of-month from the start date
-     * and repeats it for each of the next 12 months. If the month does not
-     * have that day (e.g. Feb 31), the iteration is skipped.
-     *
-     * - **`inEveryWeek` + `inEveryMonth`**: for each of the next 12 months finds
-     * the first occurrence of the target weekday (from the start date), then
-     * iterates all occurrences of that weekday in the month with a 7-day step.
-     *
-     * `processDate(currentDate)` is called for every resolved date.
-     * @param {Date} date - The date for which to process intervals.
-     * @param {object} config - Configuration for schedule repetition.
-     * @param {boolean} config.inEveryWeek - Whether to repeat weekly.
-     * @param {boolean} config.inEveryMonth - Whether to repeat monthly.
-     * @param {(currentDate: Date) => void} processDate - Callback function to process each date.
-     */
-    _processScheduleDates(date, config, processDate) {
-        // Handle weekly schedules
-        if (config.inEveryWeek && !config.inEveryMonth) {
-            let currentDate = new Date(date);
-            // Calculate the last day of the current month
-            const endOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
-            while (currentDate <= endOfMonth) {
-                processDate(currentDate);
-                // Move to the next week
-                currentDate = this._addDays(currentDate, 7);
-            }
-        }
-        // Handle monthly schedules
-        if (config.inEveryMonth && !config.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfMonth = startDate.getUTCDate();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                // Try setting the current date to the target day of the month
-                currentDate.setUTCDate(targetDayOfMonth);
-                // Check if we have exceeded the month
-                if (currentDate.getUTCMonth() !== (startDate.getUTCMonth() + i) % 12) {
-                    continue; // Skip this month if exceeded
-                }
-                processDate(currentDate);
-            }
-        }
-        // Handle both weekly and monthly schedules
-        if (config.inEveryMonth && config.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfWeek = startDate.getUTCDay();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                // Set to the first day of the month
-                currentDate.setUTCDate(1);
-                // Find the first target day of the week in the current month
-                const daysUntilTargetDay = (targetDayOfWeek - currentDate.getUTCDay() + 7) % 7;
-                currentDate.setUTCDate(currentDate.getUTCDate() + daysUntilTargetDay);
-                // Iterate over all target days of the week in the current month
-                while (currentDate.getUTCMonth() ===
-                    (startDate.getUTCMonth() + i) % 12) {
-                    processDate(currentDate);
-                    // Move to the next week (same day of the week)
-                    currentDate.setUTCDate(currentDate.getUTCDate() + 7);
-                }
-            }
-        }
-    }
-    /**
-     * Generates intervals for a specific date based on a schedule.
-     *
-     * For each date resolved by `_processScheduleDates`, iterates over
-     * the `schedule.times` array of time ranges. Each range is a pair
-     * `[startTime, endTime]` with `{ hours, minutes }` fields.
-     * Creates an ISO interval `[start.toISOString(), end.toISOString()]`
-     * and adds it to `utcIntervals` (Set deduplicates automatically).
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} schedule - The schedule defining the intervals.
-     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
-     * @param {any[]} schedule.times - The times for each interval.
-     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
-     */
-    _generateIntervalsForDate(date, schedule, utcIntervals) {
-        this._processScheduleDates(date, schedule, (currentDate) => {
-            schedule.times.forEach((timeRange) => {
-                const [startTime, endTime] = timeRange;
-                const intervalStart = new Date(currentDate);
-                intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                const intervalEnd = new Date(currentDate);
-                intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                utcIntervals.add([
-                    intervalStart.toISOString(),
-                    intervalEnd.toISOString(),
-                ]);
-            });
-        });
-    }
-    /**
-     * Adds time intervals to schedules.
-     *
-     * Accepts an array of schedule groups (structure of `timeInterval` attributes
-     * for pages/products). For each group iterates over `values` — the set of
-     * concrete schedules. Each schedule contains a date range `dates[0..1]`.
-     *
-     * If both boundaries are equal (`isSameDay`), intervals are generated only
-     * for that single date. Otherwise — for every day in the range inclusive.
-     *
-     * The result (`schedule.timeIntervals`) is a sorted array of ISO pairs,
-     * ready to pass to UI components.
-     * @param {any[]} schedules - The schedules to process.
-     * @returns {any} Schedules with added time intervals.
-     */
-    _addTimeIntervalsToSchedules(schedules) {
-        schedules === null || schedules === void 0 ? void 0 : schedules.forEach((scheduleGroup) => {
-            // Skip if scheduleGroup.values is not an array
-            if (!scheduleGroup ||
-                !scheduleGroup.values ||
-                !Array.isArray(scheduleGroup.values)) {
-                return;
-            }
-            scheduleGroup.values.forEach((schedule) => {
-                const utcIntervals = new Set();
-                const startDate = new Date(schedule.dates[0]);
-                const endDate = new Date(schedule.dates[1]);
-                const isSameDay = startDate.toISOString() === endDate.toISOString();
-                if (isSameDay) {
-                    this._generateIntervalsForDate(startDate, schedule, utcIntervals);
-                }
-                else {
-                    for (let currentDate = new Date(startDate); currentDate <= endDate; currentDate = this._addDays(currentDate, 1)) {
-                        this._generateIntervalsForDate(currentDate, schedule, utcIntervals);
-                    }
-                }
-                schedule.timeIntervals = Array.from(utcIntervals).sort();
-            });
-        });
-        return schedules;
-    }
-    /**
-     * Generates intervals for a specific date for form schedules.
-     *
-     * Unlike `_generateIntervalsForDate`, time ranges here have a different shape:
-     * each `timeInterval` contains `start`, `end` and `period`
-     * (slot length in minutes). The method slices the [start, end) window into
-     * fixed-length slots of `period` minutes:
-     *
-     * start=09:00, end=12:00, period=30 → [09:00–09:30], [09:30–10:00], …, [11:30–12:00]
-     *
-     * Generation stops if the next slot would exceed `end`.
-     * Each slot is added to `utcIntervals` (Set deduplicates automatically).
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} interval - The interval configuration.
-     * @param {boolean} interval.inEveryWeek - Indicates whether the schedule is weekly.
-     * @param {boolean} interval.inEveryMonth - Indicates whether the schedule is monthly.
-     * @param {any[]} timeIntervals - The time intervals to process.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
-     */
-    _generateIntervalsForFormDate(date, interval, timeIntervals, utcIntervals) {
-        const generateTimeSlotsForDate = (currentDate) => {
-            timeIntervals.forEach((timeInterval) => {
-                let currentStart = timeInterval.start;
-                const endTime = timeInterval.end;
-                // Slice the window into slots of `period` minutes each.
-                while (currentStart.hours < endTime.hours ||
-                    (currentStart.hours === endTime.hours &&
-                        currentStart.minutes < endTime.minutes)) {
-                    const intervalStart = new Date(currentDate);
-                    intervalStart.setUTCHours(currentStart.hours, currentStart.minutes, 0, 0);
-                    // Compute slot end: add period minutes with hour carry normalization.
-                    const nextMinutes = currentStart.minutes + timeInterval.period;
-                    const nextHours = currentStart.hours + Math.floor(nextMinutes / 60);
-                    const minutes = nextMinutes % 60;
-                    // If the slot end exceeds `end` — stop; partial slots are not emitted.
-                    if (nextHours > endTime.hours ||
-                        (nextHours === endTime.hours && minutes > endTime.minutes)) {
-                        break;
-                    }
-                    const intervalEnd = new Date(currentDate);
-                    intervalEnd.setUTCHours(nextHours, minutes, 0, 0);
-                    utcIntervals.add([
-                        intervalStart.toISOString(),
-                        intervalEnd.toISOString(),
-                    ]);
-                    currentStart = { hours: nextHours, minutes };
-                }
-            });
-        };
-        this._processScheduleDates(date, interval, generateTimeSlotsForDate);
-    }
-    /**
-     * Adds time intervals to form schedules (different structure).
-     *
-     * Same as `_addTimeIntervalsToSchedules` but for `timeInterval` attributes
-     * in **forms** (different API data structure):
-     * - `interval.range[0..1]` instead of `schedule.dates[0..1]`
-     * - `interval.intervals` — array of time ranges with slots (`period`)
-     * instead of `[startTime, endTime]` pairs
-     *
-     * Result is written to `interval.timeIntervals`.
-     * @param {any[]} intervals - The intervals to process.
-     * @returns {any} Intervals with added time intervals.
-     */
-    _addTimeIntervalsToFormSchedules(intervals) {
-        intervals.forEach((interval) => {
-            var _a, _b;
-            if (!interval.intervals || !Array.isArray(interval.intervals)) {
-                return;
-            }
-            const utcIntervals = new Set();
-            const startDate = new Date(interval.range[0]);
-            const endDate = new Date(interval.range[1]);
-            const isSameDay = startDate.toISOString() === endDate.toISOString();
-            const intervalConfig = {
-                inEveryWeek: (_a = interval.inEveryWeek) !== null && _a !== void 0 ? _a : false,
-                inEveryMonth: (_b = interval.inEveryMonth) !== null && _b !== void 0 ? _b : false,
-            };
-            if (isSameDay) {
-                this._generateIntervalsForFormDate(startDate, intervalConfig, interval.intervals, utcIntervals);
-            }
-            else {
-                for (let currentDate = new Date(startDate); currentDate <= endDate; currentDate = this._addDays(currentDate, 1)) {
-                    this._generateIntervalsForFormDate(currentDate, intervalConfig, interval.intervals, utcIntervals);
-                }
-            }
-            interval.timeIntervals = Array.from(utcIntervals).sort();
-        });
-        return intervals;
-    }
     /**
      * Transforms additionalFields from array to object keyed by marker.
      *
@@ -557,16 +310,20 @@ class SyncModules {
      * Contains an object `{ marker: AttrObject }`. For each attribute:
      * - `_normalizeAdditionalFields` is called;
      * - numeric types (`integer`, `float`) are cast to a JS number (or `null`);
-     * - `timeInterval` attributes are enriched with computed `timeIntervals`;
      * - the whole object is re-sorted by `position`.
      *
      * **2. `attributes`** — form attributes (different API structure).
-     * Same `additionalFields` and `timeInterval` processing,
+     * Same `additionalFields` processing,
      * but numbers are not normalized here (commented out — logic differs).
      *
      * **3. `type`** — a single attribute from an attribute set.
      * Same transformations as in case 1, but without sorting.
      *
+     * `timeInterval` attributes are left exactly as the API returned them — a
+     * compact recurrence rule. Resolving one into concrete slots is the caller's
+     * job, via `expandTimeIntervals`: the rule is open-ended, so only the caller
+     * knows how wide a window it needs.
+     *
      * If none of the keys are found — data is returned unchanged.
      * @param {any} data - The data to normalize.
      * @returns {any} Normalized attributes.
@@ -582,15 +339,6 @@ class SyncModules {
                     const numValue = Number(d.value);
                     d.value = isNaN(numValue) ? null : numValue;
                 }
-                // add timeIntervals
-                if (data.attributeValues[attr].type === 'timeInterval') {
-                    const schedules = data.attributeValues[attr].value;
-                    // console.log('Schedules: ', JSON.stringify(schedules));
-                    if (Array.isArray(schedules) && schedules.length > 0) {
-                        const result = this._addTimeIntervalsToSchedules(schedules);
-                        data.attributeValues[attr].value = result;
-                    }
-                }
             });
             return {
                 ...data,
@@ -608,22 +356,12 @@ class SyncModules {
         if ('attributes' in data) {
             const d = data.attributes;
             Object.keys(d).forEach((attr) => {
-                var _a;
                 this._normalizeAdditionalFields(d[attr]);
                 for (const field of booleanFields) {
                     if (field in d[attr] && d[attr][field] === null) {
                         d[attr][field] = false;
                     }
                 }
-                // Add time intervals
-                if (d[attr].type === 'timeInterval') {
-                    const intervals = (_a = d[attr].localizeInfos) === null || _a === void 0 ? void 0 : _a.intervals;
-                    // console.log('Schedules:: ', JSON.stringify(intervals));
-                    if (intervals && Array.isArray(intervals) && intervals.length > 0) {
-                        const result = this._addTimeIntervalsToFormSchedules(intervals);
-                        d[attr].localizeInfos.intervals = result;
-                    }
-                }
             });
             return data;
         }
@@ -640,14 +378,6 @@ class SyncModules {
                 const numValue = Number(data.value);
                 data.value = isNaN(numValue) ? null : numValue;
             }
-            // Add time intervals
-            if (data.type === 'timeInterval') {
-                const schedules = data.value;
-                if (Array.isArray(schedules) && schedules.length > 0) {
-                    const result = this._addTimeIntervalsToSchedules(schedules);
-                    data.value = result;
-                }
-            }
         }
         return data;
     }

package/dist/base/timeIntervals.d.ts

@@ -0,0 +1,95 @@
+import type { IAttributeValue, ITimeIntervalAttributeValue, ITimeIntervalEntitySchedule, ITimeIntervalSchedule, ITimeIntervalWindow, TimeIntervalPair } from './utils';
+/**
+ * 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 declare function expandTimeIntervals(schedule: ITimeIntervalEntitySchedule | ITimeIntervalSchedule, window: ITimeIntervalWindow): TimeIntervalPair[];
+/**
+ * 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 declare function isTimeIntervalAttribute(attr: IAttributeValue | undefined): attr is ITimeIntervalAttributeValue;
+/**
+ * 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 declare function expandAttributeTimeIntervals(attr: IAttributeValue | undefined, window: ITimeIntervalWindow): TimeIntervalPair[];

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

@@ -148,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 {
@@ -163,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;
@@ -173,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).
@@ -289,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/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
@@ -135,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

package/package.json

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