oneentry 1.0.154 → 1.0.156

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;
     }
@@ -698,6 +428,35 @@ class SyncModules {
         this.state.guestId = guestId || undefined;
         return this;
     }
+    /**
+     * Sets the device-metadata override in the state.
+     *
+     * Once set, the string is sent as the `x-device-metadata` header on POST
+     * requests and token refresh instead of 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 set the
+     * browser's string (obtained there via `getDeviceMetadata`). Pass an empty
+     * string to clear the override and fall back to the computed fingerprint.
+     * @param {string} deviceMetadata - The metadata string to send (empty string clears the override).
+     * @returns {any} The instance of SyncModules for chaining.
+     */
+    setDeviceMetadata(deviceMetadata) {
+        this.state.deviceMetadata = deviceMetadata || undefined;
+        return this;
+    }
+    /**
+     * Returns the device-metadata string the SDK sends as the `x-device-metadata` header.
+     *
+     * Public counterpart of `_getDeviceMetadata`: an explicit override (config or
+     * `setDeviceMetadata`) wins, otherwise the environment-derived fingerprint is
+     * computed. Use it in the browser to obtain the string that a server-side
+     * token-issuing flow (OAuth code exchange) must forward, so the issued refresh
+     * token stays refreshable from this browser.
+     * @returns {string} The metadata string sent with requests from this instance.
+     */
+    getDeviceMetadata() {
+        return this._getDeviceMetadata();
+    }
     /**
      * Get deviceMetadata
      *
@@ -724,10 +483,18 @@ class SyncModules {
      * lives until the process restarts.
      *
      * In a Node.js environment (no `window`) returns a simplified object without screen/navigator.
+     *
+     * An explicitly provided string (`deviceMetadata` in config or `setDeviceMetadata`)
+     * takes precedence over the environment-derived fingerprint — this lets a server
+     * issue tokens bound to the browser's fingerprint (see `IConfig.deviceMetadata`).
      * @returns {string} - Returns an object containing device metadata.
      */
     _getDeviceMetadata() {
         var _a;
+        // Explicit override wins: the API binds refresh tokens to this header, so
+        // server-side token issuance must be able to stamp the browser's string.
+        if (this.state.deviceMetadata)
+            return this.state.deviceMetadata;
         // Check if we're in a browser environment
         if (typeof globalThis === 'undefined') {
             return '';

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[];