oneentry 1.0.142 → 1.0.144

package/dist/base/syncModules.js

@@ -0,0 +1,716 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Module-level device ID cache — survives class re-instantiation,
+// but resets on page reload if localStorage is unavailable.
+let _persistentDeviceId = null;
+/**
+ * Returns a stable device ID for the browser environment.
+ *
+ * Algorithm:
+ * 1. If the module-level cache is already populated — return it (fastest path).
+ * 2. Otherwise try reading the ID from localStorage (key `oneentry_device_id`).
+ * This ensures the same browser gets the same ID across sessions and tabs.
+ * 3. If localStorage has nothing — generate a new ID from timestamp + random,
+ * persist it to localStorage and cache it in the module variable.
+ * 4. If localStorage is unavailable (SSR, private mode, iframe sandbox) —
+ * return null; the caller falls back to `_nodeDeviceId`.
+ * @returns {string | null} Device ID or null if localStorage is unavailable.
+ */
+function _getBrowserDeviceId() {
+    const win = typeof globalThis !== 'undefined' ? globalThis.window : undefined;
+    if (!(win === null || win === void 0 ? void 0 : win.localStorage))
+        return null;
+    if (_persistentDeviceId)
+        return _persistentDeviceId;
+    try {
+        const stored = win.localStorage.getItem('oneentry_device_id');
+        if (stored) {
+            _persistentDeviceId = stored;
+            return _persistentDeviceId;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (_e) {
+        // ignore
+    }
+    // Generate ID: base-36 timestamp + two random segments.
+    // base-36 is more compact than hex and contains no special characters.
+    const id = Date.now().toString(36) +
+        Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15);
+    _persistentDeviceId = id;
+    try {
+        win.localStorage.setItem('oneentry_device_id', id);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (_e) {
+        // ignore
+    }
+    return _persistentDeviceId;
+}
+/**
+ * Abstract class representing synchronization modules.
+ */
+class SyncModules {
+    /**
+     * Constructor to initialize state and URL.
+     * @param {StateModule} state - StateModule instance.
+     */
+    constructor(state) {
+        /**
+         * Sorts attributes by their positions.
+         *
+         * The API returns attributes as an object `{ marker: AttrObject }`.
+         * Each attribute has a `position` field. The method rebuilds the object
+         * with keys sorted by ascending `position` so that the display order
+         * matches the order defined in the CMS.
+         * @param {any} data - The data containing attributes.
+         * @returns {any} Sorted attributes.
+         */
+        this._sortAttributes = (data) => Object.fromEntries(Object.entries(data).sort(([, a], [, b]) => a.position - b.position));
+        this.state = state;
+        this._url = state.url;
+        this._nodeDeviceId =
+            Date.now().toString(36) +
+                Math.random().toString(36).substring(2, 15) +
+                Math.random().toString(36).substring(2, 15);
+    }
+    /**
+     * Constructs the full URL path by appending the given path to the base URL.
+     * @param {string} path - The path to append to the base URL.
+     * @returns {string} The full URL as a string.
+     */
+    _getFullPath(path) {
+        return this._url + path;
+    }
+    /**
+     * Converts query parameters into a query string.
+     * @param {IProductsQuery | IUploadingQuery | any} query - The query object containing key-value pairs.
+     * @returns {string} A string representation of the query parameters.
+     */
+    _queryParamsToString(query) {
+        // Skip null/undefined to avoid sending empty parameters.
+        // 0, false and '' are kept — they are semantically meaningful.
+        return Object.keys(query)
+            .filter((key) => query[key] !== null && query[key] !== undefined)
+            .map((key) => `${key}=${query[key]}`)
+            .join('&');
+    }
+    /**
+     * Normalizes data based on language code.
+     *
+     * Recursively traverses the API response and unwraps localized fields.
+     * The API stores translations as objects like
+     * `{ "en_US": "Hello", "ru_RU": "Hello" }`. The method replaces such an object
+     * with the value for the requested `langCode` when that key is present.
+     *
+     * Traversal order:
+     * 1. Array → recursively normalize each element, then `_normalizeAttr`.
+     * 2. Object → for each key:
+     * - value is an array: recurse;
+     * - value is a non-object (primitive) or falsy: copy as-is;
+     * - object has key `langCode`: take only the needed translation;
+     * - otherwise: recurse deeper.
+     * 3. Primitive → return as-is.
+     * @param {any} data - The data to normalize.
+     * @param {string} langCode - The language code for normalization.
+     * @returns {any} Normalized data.
+     */
+    _normalizeData(data, langCode = this.state.lang) {
+        if (Array.isArray(data)) {
+            return this._normalizeAttr(data.map((item) => this._normalizeData(item, langCode)));
+        }
+        else if (typeof data === 'object' && data) {
+            const normalizeData = {};
+            Object.keys(data).forEach((key) => {
+                if (Array.isArray(data[key])) {
+                    normalizeData[key] = this._normalizeData(data[key], langCode);
+                }
+                else if (!data[key] || typeof data[key] !== 'object') {
+                    normalizeData[key] = data[key];
+                }
+                else if (langCode in data[key]) {
+                    // Field contains a translation map — pick the requested locale.
+                    normalizeData[key] = data[key][langCode];
+                }
+                else {
+                    normalizeData[key] = this._normalizeData(data[key], langCode);
+                }
+            });
+            return this._normalizeAttr(normalizeData);
+        }
+        else {
+            return data;
+        }
+    }
+    /**
+     * Normalizes the body of a POST request.
+     *
+     * Performs two transformations before sending to the API:
+     *
+     * 1. **phoneSMS cleanup**: the API rejects an empty string as a field value,
+     * so if `notificationData.phoneSMS === ''` the key is deleted entirely.
+     * A missing key is treated by the API as "not provided"; an empty string is not.
+     *
+     * 2. **formData localization**: the API expects formData as
+     * `{ "<langCode>": [...fields] }`, but callers pass a flat array or a single object.
+     * The method wraps the data into the required structure.
+     * If `formData` is absent from the body — return the body as-is (only phoneSMS cleanup applied).
+     * @param {any} body - The body to normalize.
+     * @param {string} [langCode] - The language code for normalization.
+     * @returns {any} Normalized body.
+     */
+    _normalizePostBody(body, langCode = this.state.lang) {
+        // API does not accept phoneSMS = '' — delete the field if empty.
+        if (body.notificationData && body.notificationData.phoneSMS === '') {
+            delete body.notificationData.phoneSMS;
+        }
+        // If formData is not provided — no further normalization needed.
+        if (!body.formData)
+            return body;
+        // Wrap form fields in an object keyed by locale:
+        // [{ marker, value }]  →  { "en_US": [{ marker, value }] }
+        const formData = {};
+        formData[langCode] = Array.isArray(body.formData)
+            ? body.formData
+            : [body.formData];
+        body.formData = formData;
+        return body;
+    }
+    /**
+     * Clears arrays within the data structure.
+     *
+     * Traverses the data and fixes a specific edge case with image attributes:
+     * when an `image` attribute has a single-element array in `value`,
+     * the API returns an array but consumers expect a plain object.
+     * In that case `value` is unwrapped: `[img]` → `img`.
+     *
+     * For all other keys the method recursively copies the structure unchanged.
+     * @param {Record<string, any>} data - The data to clear.
+     * @returns {any} Cleared data.
+     */
+    _clearArray(data) {
+        if (Array.isArray(data)) {
+            return data.map((item) => this._clearArray(item));
+        }
+        else if (typeof data === 'object' && data) {
+            const normalizeData = {};
+            Object.keys(data).forEach((key) => {
+                if (Array.isArray(data[key])) {
+                    normalizeData[key] = this._clearArray(data[key]);
+                }
+                else if (!data[key] || typeof data[key] !== 'object') {
+                    normalizeData[key] = data[key];
+                }
+                else if (key === 'attributeValues') {
+                    const attrs = data[key];
+                    Object.keys(attrs).forEach((attr) => {
+                        // If an image attribute has a single-element value array,
+                        // unwrap it to a plain object for consumer convenience.
+                        if (attrs[attr].type === 'image' &&
+                            attrs[attr].value.length === 1) {
+                            attrs[attr].value = attrs[attr].value[0];
+                        }
+                    });
+                    normalizeData[key] = data[key];
+                }
+                else {
+                    normalizeData[key] = this._clearArray(data[key]);
+                }
+            });
+            return normalizeData;
+        }
+        else {
+            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.
+     *
+     * The API returns `additionalFields` as an array: `[{ marker, ... }, ...]`.
+     * For convenient key-based access (`attr.additionalFields['fieldName']`)
+     * the method converts it to an object `{ marker: { marker, ... } }`.
+     * Transformation is skipped when `rawData` mode is enabled in config
+     * (the consumer wants the data as-is, without transformations).
+     * @param {any} attr - The attribute object that may contain additionalFields.
+     */
+    _normalizeAdditionalFields(attr) {
+        if (!this.state.rawData && Array.isArray(attr.additionalFields)) {
+            attr.additionalFields = Object.fromEntries(attr.additionalFields.map((field) => [field.marker, field]));
+        }
+    }
+    /**
+     * Normalizes attributes within the data.
+     *
+     * Handles three different attribute formats returned by the API:
+     *
+     * **1. `attributeValues`** — attributes of pages, products and other entities.
+     * 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,
+     * 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.
+     *
+     * If none of the keys are found — data is returned unchanged.
+     * @param {any} data - The data to normalize.
+     * @returns {any} Normalized attributes.
+     */
+    _normalizeAttr(data) {
+        // For regular attributes collections - pages, products, etc.
+        if ('attributeValues' in data) {
+            Object.keys(data.attributeValues).forEach((attr) => {
+                const d = data.attributeValues[attr];
+                this._normalizeAdditionalFields(d);
+                // normalize numbers
+                if (d.type === 'integer' || d.type === 'float') {
+                    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,
+                attributeValues: this._sortAttributes(data.attributeValues),
+            };
+        }
+        // for forms attributes - forms attributes collections
+        if ('attributes' in data) {
+            const d = data.attributes;
+            Object.keys(d).forEach((attr) => {
+                var _a;
+                this._normalizeAdditionalFields(d[attr]);
+                // Normalize numbers
+                // if (d[attr].type === 'integer' || d[attr].type === 'float') {
+                //   const numValue = Number(d[attr].value);
+                //   d[attr].value = isNaN(numValue) ? null : numValue;
+                // }
+                // 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;
+        }
+        //  For single attribute - for attribute sets
+        if ('type' in data) {
+            this._normalizeAdditionalFields(data);
+            // Normalize numbers
+            if (data.type === 'integer' || data.type === 'float') {
+                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;
+    }
+    /**
+     * Processes data after fetching or receiving it.
+     *
+     * Final post-processing of the API response: first unwraps localized fields
+     * (`_normalizeData`), then fixes single-element image attributes
+     * (`_clearArray`). Called at the end of every fetch method.
+     * @param {any} data - The data to process.
+     * @param {any} [langCode] - The language code for processing.
+     * @returns {any} Processed data.
+     */
+    _dataPostProcess(data, langCode = this.state.lang) {
+        const normalize = this._normalizeData(data, langCode);
+        const result = this._clearArray(normalize);
+        return result;
+    }
+    /**
+     * Sets the access token in the state.
+     * @param {string} accessToken - The access token to set.
+     * @returns {any} The instance of SyncModules for chaining.
+     */
+    setAccessToken(accessToken) {
+        this.state.accessToken = accessToken;
+        return this;
+    }
+    /**
+     * Sets the refresh token in the state.
+     * @param {string} refreshToken - The refresh token to set.
+     * @returns {any} The instance of SyncModules for chaining.
+     */
+    setRefreshToken(refreshToken) {
+        this.state.refreshToken = refreshToken;
+        return this;
+    }
+    /**
+     * Get deviceMetadata
+     *
+     * Builds a device metadata object to be sent in request headers.
+     * Used for analytics and anti-fraud on the API side.
+     *
+     * Returned JSON structure:
+     * ```json
+     * {
+     *   "fingerprint": "UQ_<hash>_<instanceId>",
+     *   "deviceInfo": { "os": "...", "browser": "...", "location": "en-US" }
+     * }
+     * ```
+     *
+     * **Fingerprint algorithm:**
+     * 1. Builds a string from stable characteristics: platform, userAgent, language,
+     * screen resolution, colorDepth, timezone, private-browsing mode, instanceId.
+     * 2. Runs it through a simple 32-bit hash (djb2-like).
+     * 3. Concatenates the hash and the first 12 characters of instanceId.
+     *
+     * **instanceId strategy:**
+     * - Browser: `_getBrowserDeviceId()` — read from localStorage, stable across sessions.
+     * - Node.js / no localStorage: `_nodeDeviceId` — generated at instance creation,
+     * lives until the process restarts.
+     *
+     * In a Node.js environment (no `window`) returns a simplified object without screen/navigator.
+     * @returns {string} - Returns an object containing device metadata.
+     */
+    _getDeviceMetadata() {
+        var _a;
+        // Check if we're in a browser environment
+        if (typeof globalThis === 'undefined') {
+            return '';
+        }
+        // Access navigator through globalThis.window object to avoid direct reference
+        const win = globalThis.window;
+        const instanceId = (_a = _getBrowserDeviceId()) !== null && _a !== void 0 ? _a : this._nodeDeviceId;
+        // Node.js environment
+        if (!win) {
+            return JSON.stringify({
+                fingerprint: `UQ_${instanceId}`,
+                deviceInfo: {
+                    os: 'Node.js',
+                    browser: `Node.js/${instanceId.substring(0, 10)}`,
+                    location: 'en-US',
+                },
+            });
+        }
+        const nav = win.navigator || {};
+        const platform = nav.platform || 'Win32';
+        const userAgent = nav.userAgent || 'Node.js/22';
+        const language = nav.language || 'en-US';
+        // Get screen information if available
+        const screen = win.screen || {};
+        const screenWidth = screen.width || 0;
+        const screenHeight = screen.height || 0;
+        const colorDepth = screen.colorDepth || 0;
+        // Get timezone
+        let timezone = 'UTC';
+        try {
+            timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            // Ignore error, fallback to UTC
+        }
+        // Detect private browsing mode
+        let isPrivateBrowsing = false;
+        try {
+            // Simple localStorage test to detect private browsing
+            if (win.localStorage) {
+                const testKey = 'test_private_browsing';
+                win.localStorage.setItem(testKey, '1');
+                win.localStorage.removeItem(testKey);
+            }
+            else {
+                isPrivateBrowsing = true; // If localStorage is not available, likely private browsing
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            isPrivateBrowsing = true; // Error during localStorage access indicates private browsing
+        }
+        // Create a stable fingerprint string using stable device/browser characteristics
+        const fingerprintString = `${platform}|${userAgent}|${language}|${screenWidth}|${screenHeight}|${colorDepth}|${timezone}|${isPrivateBrowsing ? 'private' : 'normal'}|${instanceId}`;
+        // Simple but stable hash function
+        let hash = 0;
+        for (let i = 0; i < fingerprintString.length; i++) {
+            const char = fingerprintString.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        const deviceMetadata = {
+            fingerprint: `UQ_${Math.abs(hash).toString(36)}_${instanceId.substring(0, 12)}`,
+            deviceInfo: {
+                os: platform.replace(/ /g, '_'),
+                browser: userAgent.replace(/ /g, '_'),
+                location: language,
+            },
+        };
+        return JSON.stringify(deviceMetadata);
+    }
+}
+exports.default = SyncModules;