oneentry 1.0.138 → 1.0.140

package/dist/base/syncModules.js

@@ -1,530 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Using WeakMap to store unique instance IDs for each object instance
-const instanceIds = new WeakMap();
-// Counter to ensure even more uniqueness
-let instanceCounter = 0;
-/**
- * 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.
-         * @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;
-        // Generate and store a unique instance ID using WeakMap
-        if (!instanceIds.has(this)) {
-            const timestampPart = Date.now().toString(36);
-            const randomPart = Math.random().toString(36).substring(2, 15) +
-                Math.random().toString(36).substring(2, 15);
-            const counterPart = (++instanceCounter).toString(36);
-            const instanceId = `${timestampPart}${randomPart}${counterPart}`;
-            instanceIds.set(this, instanceId);
-        }
-    }
-    /**
-     * 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) {
-        let result = '';
-        for (const key in query) {
-            if (query[key] !== null) {
-                result += `${key}=${query[key]}&`;
-            }
-        }
-        return result.slice(0, result.length - 1);
-    }
-    /**
-     * Normalizes data based on language code.
-     * @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 = {};
-            for (const key in data) {
-                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]) {
-                    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.
-     * @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) {
-        const formData = {};
-        formData[langCode] = Array.isArray(body.formData)
-            ? body.formData
-            : [body.formData];
-        body.formData = formData;
-        return body;
-    }
-    /**
-     * Clears arrays within the data structure.
-     * @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 = {};
-            for (const key in data) {
-                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];
-                    for (const attr in attrs) {
-                        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).
-     * @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 {Function} 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.
-     * @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.
-     * @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.
-     * @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;
-                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);
-                    const nextMinutes = currentStart.minutes + timeInterval.period;
-                    const nextHours = currentStart.hours + Math.floor(nextMinutes / 60);
-                    const minutes = nextMinutes % 60;
-                    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).
-     * @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.
-     * Skipped when rawData is enabled in config.
-     * @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.
-     * @param {any} data - The data to normalize.
-     * @returns {any} Normalized attributes.
-     */
-    _normalizeAttr(data) {
-        var _a;
-        // For regular attributes collections - pages, products, etc.
-        if ('attributeValues' in data) {
-            for (const attr in data.attributeValues) {
-                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;
-            for (const attr in d) {
-                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.
-     * @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
-     * @returns {string} - Returns an object containing device metadata.
-     */
-    _getDeviceMetadata() {
-        // 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;
-        // Get the instance ID from the WeakMap
-        const instanceId = instanceIds.get(this) ||
-            Date.now().toString(36) +
-                Math.random().toString(36).substring(2, 15) +
-                Math.random().toString(36).substring(2, 15) +
-                (++instanceCounter).toString(36);
-        // Node.js environment - unique per-instance fingerprint (no shared process ID)
-        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;