@inappstory/react-sdk 1.15.0 → 1.15.2

package/dist/index.esm.mjs

@@ -2617,25 +2617,45 @@ class ApiRequestError extends Error {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "requestUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.name = "IasNetworkError";
         this.networkStatus = networkStatus;
         this.networkMessage = networkMessage;
         this.response = response !== null && response !== void 0 ? response : null;
-        /*  console.error({ name: this.name, networkStatus, networkMessage, response }); */
     }
     static createByRequestError(response) {
         return new ApiRequestError(null, JSON.stringify(response.data), response);
     }
     static createByFetchError(error) {
+        const requestUrl = error.requestUrl ? decodeURIComponent(error.requestUrl) : "";
         const isOnline = window.navigator && window.navigator.onLine;
-        if (isOnline)
-            return new ApiRequestError(null, error.name === "AbortError"
-                ? "The operation was aborted by the AbortController signal. Make sure you don't destroy the InAppStoryManager while it's running."
-                : error.message);
-        return new ApiRequestError(null, "net::ERR_INTERNET_DISCONNECTED");
+        let networkMessage = error.message;
+        if (error.name === "AbortError") {
+            if (error.abortedBySdkConfigUpdate) {
+                networkMessage = `The request with URL <${requestUrl}> was interrupted due to an SDK config update (changed userId, lang or apiKey).`;
+            }
+            else {
+                networkMessage = `The request with URL <${requestUrl}> was aborted. Make sure you don't destroy the <InAppStoryManager> while it's running.`;
+            }
+        }
+        if (!isOnline) {
+            networkMessage = "net::ERR_INTERNET_DISCONNECTED";
+        }
+        const apiError = new ApiRequestError(null, networkMessage);
+        apiError.requestUrl = error.requestUrl;
+        return apiError;
     }
 }
 
+;// ../core/src/helpers/awaitMacrotask.ts
+/** Schedules a macrotask so pending microtasks can run before continuing. */
+const awaitMacrotask = () => new Promise(resolve => setTimeout(resolve));
+
 ;// ../core/src/helpers/classificators/isNumeric.ts
 function isNumeric(str) {
     if (typeof str != "string")
@@ -3522,6 +3542,7 @@ function safeJson(input) {
 
 
 
+
 ;// ../core/src/api/deviceDescriptor.ts
 
 
@@ -3593,7 +3614,7 @@ class InterceptorManager {
 ;// ../core/src/api/exceptions/apiAbortRequestError.ts
 class IasAbortRequestError extends Error {
     constructor(url) {
-        super(`The request with URL <${url}> was aborted. Make sure you don't destroy the InAppStoryManager while it's running.`);
+        super(`The request with URL <${url}> was aborted. Make sure you don't destroy the <InAppStoryManager> while it's running.`);
         this.name = "IasAbortRequestError";
     }
 }
@@ -10335,7 +10356,7 @@ class GameClientConfig {
             value: void 0
         });
         const storyManagerConfig = this.storyManager.config;
-        const sdkVersion = "1.15.0";
+        const sdkVersion = "1.15.2";
         const placeholders = this.storyManager.rootStore.placeholderStore.placeholders;
         const session = this.storyManager.rootStore.sessionStore.session;
         this.sessionId = session.id;
@@ -15229,6 +15250,9 @@ let StoryManagerConfig = (() => {
             /** Fast user switching breaks feed loading (may close session while feed is loading). Added noConcurrent */
             async reloadSdk() {
                 try {
+                    await api.abortBySdkConfigUpdate();
+                    // Let microtasks from aborted request handlers run (e.g. isLoading → false) before reloading lists.
+                    await awaitMacrotask();
                     this.storyManager.emit("requestSDKReload");
                     this.storyManager.rootStore.sessionStore.close();
                     this.storyManager.closeAllReaders();
@@ -15400,6 +15424,77 @@ class StoryManagerConfigValidator {
 
 
 
+;// ../core/src/api/apiRequest.ts
+class ApiRequest {
+    constructor(externalSignal) {
+        Object.defineProperty(this, "_abortController", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AbortController()
+        });
+        Object.defineProperty(this, "_inFlight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_abortedBySdkConfigUpdate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_resolve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "promise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promise = new Promise(resolve => {
+            this._resolve = resolve;
+        });
+        this.bindExternalSignal(externalSignal);
+    }
+    get signal() {
+        return this._abortController.signal;
+    }
+    get inFlight() {
+        return this._inFlight;
+    }
+    get abortedBySdkConfigUpdate() {
+        return this._abortedBySdkConfigUpdate;
+    }
+    abort() {
+        this._abortController.abort();
+    }
+    abortBySdkConfigUpdate() {
+        this._abortedBySdkConfigUpdate = true;
+        this._abortController.abort();
+    }
+    complete() {
+        if (!this._inFlight)
+            return;
+        this._inFlight = false;
+        this._resolve();
+    }
+    bindExternalSignal(signal) {
+        if (!signal)
+            return;
+        if (signal.aborted) {
+            this.abort();
+            return;
+        }
+        signal.addEventListener("abort", () => this.abort(), { once: true });
+    }
+}
+
 ;// ../core/src/api/api.ts
 
 
@@ -15409,6 +15504,7 @@ class StoryManagerConfigValidator {
 
 
 
+
 class API {
     constructor(config) {
         var _a;
@@ -15424,6 +15520,12 @@ class API {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "_inFlightRequests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "interceptors", {
             enumerable: true,
             configurable: true,
@@ -15444,16 +15546,36 @@ class API {
     set baseHeaders(headers) {
         this._baseHeaders = headers;
     }
+    async abortBySdkConfigUpdate() {
+        const inFlightRequests = Array.from(this._inFlightRequests);
+        for (const apiRequest of inFlightRequests) {
+            apiRequest.abortBySdkConfigUpdate();
+        }
+        await Promise.allSettled(inFlightRequests.map(apiRequest => apiRequest.promise));
+    }
     async request(config) {
+        const apiRequest = new ApiRequest(config.signal);
+        this.registerInFlight(apiRequest);
+        config.signal = apiRequest.signal;
         try {
             const processedConfig = await this.interceptors.request.run(config);
-            const response = await this.dispatchRequest(processedConfig);
-            return await this.interceptors.response.run(response);
+            const requestUrl = this.buildURL(processedConfig.url, processedConfig.params).toString();
+            try {
+                const response = await this.dispatchRequest(processedConfig);
+                return await this.interceptors.response.run(response);
+            }
+            catch (error) {
+                if (error instanceof ApiRequestError)
+                    throw error;
+                const fetchError = error;
+                fetchError.requestUrl = requestUrl;
+                fetchError.abortedBySdkConfigUpdate = apiRequest.abortedBySdkConfigUpdate;
+                throw ApiRequestError.createByFetchError(fetchError);
+            }
         }
-        catch (error) {
-            if (error instanceof ApiRequestError)
-                throw error;
-            throw ApiRequestError.createByFetchError(error);
+        finally {
+            apiRequest.complete();
+            this.unregisterInFlight(apiRequest);
         }
     }
     get(url, config = {}) {
@@ -15578,6 +15700,12 @@ class API {
         }
         return result;
     }
+    registerInFlight(apiRequest) {
+        this._inFlightRequests.add(apiRequest);
+    }
+    unregisterInFlight(apiRequest) {
+        this._inFlightRequests.delete(apiRequest);
+    }
 }
 const APIInstance = new API();
 APIInstance.interceptors.request.use(config => {
@@ -15690,7 +15818,7 @@ let IamApi = (() => {
                     value: (iamApi_runInitializers(this, _instanceExtraInitializers), storyManager)
                 });
             }
-            async fetchAll({ tags, options }) {
+            async fetchAll({ tags, options, signal }) {
                 const response = await api.post("inappmessaging", {
                     tags: tags.join(","),
                     options
@@ -15698,25 +15826,28 @@ let IamApi = (() => {
                     params: {
                         fields: messageFieldsWithPrefix,
                         expand: "messages.slides"
-                    }
+                    },
+                    signal
                 });
                 return response.data.messages;
             }
-            async fetchContext({ needFetchStyles, messageIds }) {
+            async fetchContext({ needFetchStyles, messageIds, signal }) {
                 const response = await api.get("inappmessaging/message-context", {
                     params: {
                         fields: "widgetsData" + (needFetchStyles ? ",style" : ""),
                         id: messageIds.join()
-                    }
+                    },
+                    signal
                 });
                 return response.data;
             }
-            async fetchById(messageId) {
+            async fetchById(messageId, signal) {
                 const response = await api.get(`inappmessaging/message/${messageId}`, {
                     params: {
                         expand: "slides",
-                        fields: messageFields,
-                    }
+                        fields: messageFields
+                    },
+                    signal
                 });
                 const messageDto = response.data;
                 if (!messageDto)
@@ -15766,7 +15897,7 @@ let IamApi = (() => {
                     console.error(error);
                 }
             }
-            async checkMesageLimit(messageId) {
+            async checkMesageLimit(messageId, signal) {
                 if (this.storyManager.isStatisticsDisabled) {
                     return {
                         canOpen: true
@@ -15774,7 +15905,7 @@ let IamApi = (() => {
                 }
                 const response = await api.post("inappmessaging/message-limit", {
                     id: [messageId]
-                });
+                }, { signal });
                 const messageLimitDto = response.data.find(messageLimitDto => messageLimitDto.messageId.toString() === messageId.toString());
                 if (!messageLimitDto)
                     throw new IamNotFoundLimitError(messageId);
@@ -16943,29 +17074,29 @@ class IamDisplayService {
             value: iamApi
         });
     }
-    async getMessageById(messageId, options) {
+    async getMessageById(messageId, options = {}) {
         new IamValidator(this.storyManager, this.iamStore)
             .checkOtherReadersAreClosed()
             .checkShowOnlyIfLoaded(options.showOnlyIfLoaded)
             .validate();
-        const message = await this.iamStore.findById(messageId);
+        const message = await this.iamStore.findById(messageId, { signal: options.signal });
         if (message.hasLimit)
-            await this.checkMesageLimit(messageId);
+            await this.checkMesageLimit(messageId, options.signal);
         return message;
     }
-    async getMessageByEvent(eventName, options) {
+    async getMessageByEvent(eventName, options = {}) {
         const validator = new IamValidator(this.storyManager, this.iamStore);
         validator.checkOtherReadersAreClosed().checkShowOnlyIfLoaded(options.showOnlyIfLoaded).validate();
-        await this.iamStore.preload({ tags: options.tags });
+        await this.iamStore.preload({ tags: options.tags, signal: options.signal });
         const messages = this.iamStore.findAllByEvent(eventName);
         const messagesSortedByPriority = this.getMessagesSortedByEventPriority(eventName, messages);
-        return this.getFirstValidMessageByEvent(messagesSortedByPriority);
+        return this.getFirstValidMessageByEvent(messagesSortedByPriority, options.signal);
     }
-    async getFirstValidMessageByEvent(messages) {
+    async getFirstValidMessageByEvent(messages, signal) {
         let validationError = new Error();
         for (const message of messages) {
             try {
-                const validMessage = await this.validateMessageByEvent(message);
+                const validMessage = await this.validateMessageByEvent(message, signal);
                 return validMessage;
             }
             catch (error) {
@@ -16974,15 +17105,15 @@ class IamDisplayService {
         }
         throw validationError;
     }
-    async validateMessageByEvent(message) {
+    async validateMessageByEvent(message, signal) {
         const validator = new IamValidator(this.storyManager, this.iamStore);
         validator.checkFrequencyLimit(message).checkDisplayTimeRange(message).validate();
         if (message.hasLimit)
-            await this.checkMesageLimit(message.id);
+            await this.checkMesageLimit(message.id, signal);
         return message;
     }
-    async checkMesageLimit(messageId) {
-        const { canOpen } = await this.iamApi.checkMesageLimit(messageId);
+    async checkMesageLimit(messageId, signal) {
+        const { canOpen } = await this.iamApi.checkMesageLimit(messageId, signal);
         if (!canOpen)
             throw new IamMessageLimitExceededError(messageId);
     }
@@ -20973,11 +21104,11 @@ let IamStore = (() => {
                     this._isLoading = false;
                 }
             }
-            async findById(messageId) {
+            async findById(messageId, options = {}) {
                 const message = this._messages.get(messageId.toString());
                 if (message)
                     return message;
-                return this.fetchById(messageId);
+                return this.fetchById(messageId, options.signal);
             }
             findAllByEvent(eventName) {
                 let messages = Array.from(this._messages.values()).filter(message => message.hasEvent(eventName));
@@ -20988,27 +21119,33 @@ let IamStore = (() => {
             async updateMessageUserData(messageId, data) {
                 return this.iamApi.updateUserData(messageId, data);
             }
-            async fetchById(messageId) {
+            async fetchById(messageId, signal) {
                 await this.rootStore.sessionStore.open();
-                const messageContext = await this.fetchMessageContext({ messageIds: [messageId] });
-                const messageDto = await this.iamApi.fetchById(messageId);
+                const messageContext = await this.fetchMessageContext({ messageIds: [messageId], signal });
+                const messageDto = await this.iamApi.fetchById(messageId, signal);
                 return this.createMessageByDto(messageDto, messageContext);
             }
             async fetchAll(params) {
                 await this.rootStore.sessionStore.open();
                 const config = this.rootStore.storyManagerConfigStore.config;
                 const tags = params.tags ? params.tags : config.tags;
-                const messageDtos = await this.iamApi.fetchAll({ tags: filterTags(tags), options: config.options });
+                const messageDtos = await this.iamApi.fetchAll({
+                    tags: filterTags(tags),
+                    options: config.options,
+                    signal: params.signal
+                });
                 const messageContext = await this.fetchMessageContext({
-                    messageIds: messageDtos.map(message => message.id)
+                    messageIds: messageDtos.map(message => message.id),
+                    signal: params.signal
                 });
                 return this.createMessagesByDtos(messageDtos, messageContext);
             }
-            async fetchMessageContext({ messageIds }) {
+            async fetchMessageContext({ messageIds, signal }) {
                 await this.rootStore.sessionStore.open();
                 const messageContextDto = await this.iamApi.fetchContext({
                     needFetchStyles: !this.iamCSS,
-                    messageIds
+                    messageIds,
+                    signal
                 });
                 if (!this.iamCSS && messageContextDto.style) {
                     this.iamCSS = applyInternalFontFamilyPrefix(messageContextDto.style, this.rootStore.storyManagerConfigStore.config.fontPrefix);
@@ -21796,7 +21933,7 @@ class UgcEditorStore {
         const session = await this.storyManager.rootStore.sessionStore.open();
         const ugcEditorConfigDto = await this.ugcEditorApi.fetchUgcEditorConfig();
         const storyManagerConfig = this.storyManager.config;
-        const sdkVersion = "1.15.0";
+        const sdkVersion = "1.15.2";
         this._config = {
             sessionId: session.id,
             apiKey: storyManagerConfig.apiKey,
@@ -22256,11 +22393,11 @@ class StoryManager extends TypedEventEmitter {
         return deviceDescriptor.deviceId;
     }
     get sdkVersionName() {
-        const sdkVersionName = "1.15.0";
+        const sdkVersionName = "1.15.2";
         return sdkVersionName || "0.0.0";
     }
     get sdkVersionCode() {
-        const sdkVersionCode = 11500;
+        const sdkVersionCode = 11502;
         return sdkVersionCode ? parseInt(sdkVersionCode) : 0;
     }
     get lang() {
@@ -22324,7 +22461,7 @@ class StoryManager extends TypedEventEmitter {
         this.rootStore.storyManagerConfigStore.setConfig(configDto);
     }
     setUserAgent(userAgent) {
-        const sdkVersionCode = 11500;
+        const sdkVersionCode = 11502;
         const buildVersion = sdkVersionCode ? parseInt(sdkVersionCode) : 0;
         // According to RFC5987, HTTP header values can legitimately be supplied using the ISO-8859-1 encoding.
         this._userAgent = `${userAgent} ${convertStrToLatin1(navigator.userAgent)}`;