oneentry 1.0.142 → 1.0.143

package/dist/base/stateModule.d.ts

@@ -0,0 +1,41 @@
+import type { IConfig, IError } from './utils';
+/**
+ * State module for managing application state and configuration.
+ * @description State module for managing application state and configuration.
+ */
+export default class StateModule {
+    url: string | undefined;
+    lang: string | undefined;
+    token: string | undefined;
+    accessToken: string | undefined;
+    traficLimit: boolean;
+    refreshToken: string | undefined;
+    providerMarker: string;
+    customAuth: boolean;
+    _NO_FETCH: boolean;
+    _https: any;
+    isShell: boolean;
+    validationEnabled: boolean;
+    validationStrictMode: boolean;
+    validationLogErrors: boolean;
+    rawData: boolean;
+    errorsFunctions: {
+        400?: (data: IError) => any | null;
+        401?: (data: IError) => any | null;
+        403?: (data: IError) => any | null;
+        404?: (data: IError) => any | null;
+        429?: (data: IError) => any | null;
+        500?: (data: IError) => any | null;
+        502?: (data: IError) => any | null;
+        503?: (data: IError) => any | null;
+        504?: (data: IError) => any | null;
+    };
+    saveFunction: (param: string) => void | null;
+    /**
+     * Constructor for StateModule
+     * @param {string} url - Base URL for API requests.
+     * @param {IConfig} config - Configuration object.
+     * @description Constructor for StateModule.
+     */
+    constructor(url: string, config: IConfig);
+}

package/dist/base/stateModule.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * State module for managing application state and configuration.
+ * @description State module for managing application state and configuration.
+ */
+class StateModule {
+    /**
+     * Constructor for StateModule
+     * @param {string} url - Base URL for API requests.
+     * @param {IConfig} config - Configuration object.
+     * @description Constructor for StateModule.
+     */
+    constructor(url, config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
+        this.url = url;
+        this.lang = (_a = config.langCode) !== null && _a !== void 0 ? _a : 'en_US';
+        this.token = config.token;
+        this.traficLimit = config.traficLimit || false;
+        this.validationEnabled = (_c = (_b = config.validation) === null || _b === void 0 ? void 0 : _b.enabled) !== null && _c !== void 0 ? _c : false;
+        this.validationStrictMode = (_e = (_d = config.validation) === null || _d === void 0 ? void 0 : _d.strictMode) !== null && _e !== void 0 ? _e : false;
+        this.validationLogErrors = (_g = (_f = config.validation) === null || _f === void 0 ? void 0 : _f.logErrors) !== null && _g !== void 0 ? _g : true;
+        this.rawData = (_h = config.rawData) !== null && _h !== void 0 ? _h : false;
+        this.refreshToken = (_k = (_j = config.auth) === null || _j === void 0 ? void 0 : _j.refreshToken) !== null && _k !== void 0 ? _k : undefined;
+        this.providerMarker = (_m = (_l = config.auth) === null || _l === void 0 ? void 0 : _l.providerMarker) !== null && _m !== void 0 ? _m : 'email';
+        this.customAuth = (_p = (_o = config.auth) === null || _o === void 0 ? void 0 : _o.customAuth) !== null && _p !== void 0 ? _p : false;
+        this.errorsFunctions = {
+            '400': undefined,
+            '401': undefined,
+            '403': undefined,
+            '404': undefined,
+            '429': undefined,
+            '500': undefined,
+            '502': undefined,
+            '503': undefined,
+            '504': undefined,
+        };
+        this.saveFunction = (_r = (_q = config.auth) === null || _q === void 0 ? void 0 : _q.saveFunction) !== null && _r !== void 0 ? _r : null;
+        if (config.errors) {
+            this.isShell = (_s = config.errors.isShell) !== null && _s !== void 0 ? _s : true;
+            if (config.errors.customErrors) {
+                this.errorsFunctions['400'] =
+                    (_t = config.errors.customErrors['400']) !== null && _t !== void 0 ? _t : undefined;
+                this.errorsFunctions['401'] =
+                    (_u = config.errors.customErrors['401']) !== null && _u !== void 0 ? _u : undefined;
+                this.errorsFunctions['403'] =
+                    (_v = config.errors.customErrors['403']) !== null && _v !== void 0 ? _v : undefined;
+                this.errorsFunctions['404'] =
+                    (_w = config.errors.customErrors['404']) !== null && _w !== void 0 ? _w : undefined;
+                this.errorsFunctions['429'] =
+                    (_x = config.errors.customErrors['429']) !== null && _x !== void 0 ? _x : undefined;
+                this.errorsFunctions['500'] =
+                    (_y = config.errors.customErrors['500']) !== null && _y !== void 0 ? _y : undefined;
+                this.errorsFunctions['502'] =
+                    (_z = config.errors.customErrors['502']) !== null && _z !== void 0 ? _z : undefined;
+                this.errorsFunctions['503'] =
+                    (_0 = config.errors.customErrors['503']) !== null && _0 !== void 0 ? _0 : undefined;
+                this.errorsFunctions['504'] =
+                    (_1 = config.errors.customErrors['504']) !== null && _1 !== void 0 ? _1 : undefined;
+            }
+        }
+        else {
+            this.isShell = true;
+        }
+        try {
+            if (typeof process === 'object' &&
+                +process.versions.node.split('.')[0] < 18) {
+                try {
+                    this._NO_FETCH = true;
+                    // Dynamically import https for older Node.js versions
+                    Promise.resolve().then(() => __importStar(require('https'))).then((https) => {
+                        this._https = https;
+                    })
+                        .catch(() => {
+                        this._https = null;
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    this._https = null;
+                }
+            }
+            else {
+                this._NO_FETCH = false;
+                this._https = null;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            this._NO_FETCH = false;
+            this._https = null;
+        }
+    }
+}
+exports.default = StateModule;

package/dist/base/syncModules.d.ts

@@ -0,0 +1,286 @@
+import type { IUploadingQuery } from '../file-uploading/fileUploadingInterfaces';
+import type { IProductsQuery } from '../products/productsInterfaces';
+import type StateModule from './stateModule';
+/**
+ * Abstract class representing synchronization modules.
+ */
+export default abstract class SyncModules {
+    /** Protected properties for state and URL */
+    protected state: StateModule;
+    protected _url: string;
+    private readonly _nodeDeviceId;
+    /**
+     * Constructor to initialize state and URL.
+     * @param {StateModule} state - StateModule instance.
+     */
+    protected constructor(state: StateModule);
+    /**
+     * 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.
+     */
+    protected _getFullPath(path: string): string;
+    /**
+     * 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.
+     */
+    protected _queryParamsToString(query: IProductsQuery | IUploadingQuery | any): string;
+    /**
+     * 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.
+     */
+    protected _normalizeData(data: any, langCode?: string): any;
+    /**
+     * 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.
+     */
+    protected _normalizePostBody(body: any, langCode?: string): any;
+    /**
+     * 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.
+     */
+    protected _clearArray(data: Record<string, any>): any;
+    /**
+     * 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.
+     */
+    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.
+     *
+     * 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.
+     */
+    private _normalizeAdditionalFields;
+    /**
+     * 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.
+     */
+    protected _normalizeAttr(data: any): any;
+    /**
+     * 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.
+     */
+    protected _dataPostProcess(data: any, langCode?: string): any;
+    /**
+     * 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: string): any;
+    /**
+     * 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: string): any;
+    /**
+     * 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.
+     */
+    protected _getDeviceMetadata(): string;
+}