sales-frontend-api 0.0.31 → 0.0.33

package/dist/method.js

@@ -4369,49 +4369,88 @@ var useDebugStore = create()((set) => ({
   requests: [],
   responses: [],
   errors: [],
+  isHold: false,
+  heldRequests: [],
+  heldResponses: [],
+  heldErrors: [],
   addRequest: (request) => set((state) => ({ requests: [...state.requests, request] })),
   addResponse: (response) => set((state) => ({ responses: [...state.responses, response] })),
   addError: (error) => set((state) => ({ errors: [...state.errors, error] })),
-  clear: () => set({ requests: [], responses: [], errors: [] })
+  clear: () => set({ requests: [], responses: [], errors: [], heldRequests: [], heldResponses: [], heldErrors: [] }),
+  toggleHold: () => set((state) => ({ isHold: !state.isHold })),
+  holdRequest: (request) => set((state) => ({ heldRequests: [...state.heldRequests, request] })),
+  holdResponse: (response) => set((state) => ({ heldResponses: [...state.heldResponses, response] })),
+  holdError: (error) => set((state) => ({ heldErrors: [...state.heldErrors, error] })),
+  playAllRequests: () => set((state) => {
+    state.heldRequests.forEach((r) => r.resolver(r.request));
+    return {
+      requests: [...state.requests, ...state.heldRequests.map((r) => r.request)],
+      heldRequests: []
+    };
+  }),
+  playAllResponses: () => set((state) => {
+    state.heldResponses.forEach((r) => r.resolver(r.response));
+    state.heldErrors.forEach((r) => r.resolver(r.error));
+    return {
+      responses: [...state.responses, ...state.heldResponses.map((r) => r.response)],
+      errors: [...state.errors, ...state.heldErrors.map((r) => r.error)],
+      heldResponses: [],
+      heldErrors: []
+    };
+  })
 }));
 
 // src/http-client/debug/interceptor-function.ts
 function addRequestLog(config) {
   const env = getEnvironmentFromHostname(location.hostname);
   if (env !== "prd") {
-    const { addRequest } = useDebugStore.getState();
+    const { addRequest, isHold, holdRequest } = useDebugStore.getState();
     const startTime = Date.now();
-    addRequest({
+    const requestInfo = {
       url: config.url || "",
       method: config.method || "",
       headers: config.headers,
       params: config.params,
       data: config.data,
       startTime
-    });
+    };
+    if (isHold) {
+      return new Promise((resolver) => {
+        holdRequest({ request: requestInfo, resolver });
+      });
+    } else {
+      addRequest(requestInfo);
+    }
   }
 }
 function addResponseLog(response) {
   const env = getEnvironmentFromHostname(location.hostname);
   if (env !== "prd") {
-    const { addResponse } = useDebugStore.getState();
+    const { addResponse, isHold, holdResponse } = useDebugStore.getState();
     const { config } = response;
-    addResponse({
+    const responseInfo = {
       url: config.url || "",
       method: config.method || "",
       status: response.status,
       statusText: response.statusText,
       headers: response.headers,
       data: response.data
-    });
+    };
+    if (isHold) {
+      return new Promise((resolver) => {
+        holdResponse({ response: responseInfo, resolver });
+      });
+    } else {
+      addResponse(responseInfo);
+    }
   }
 }
 function addErrorLog(error) {
   const env = getEnvironmentFromHostname(location.hostname);
   if (env !== "prd") {
-    const { addError } = useDebugStore.getState();
+    const { addError, isHold, holdError } = useDebugStore.getState();
     const { config } = error;
-    addError({
+    const errorInfo = {
       url: config?.url || "",
       method: config?.method || "",
       message: error.message,
@@ -4424,7 +4463,14 @@ function addErrorLog(error) {
         headers: error.response.headers,
         data: error.response.data
       } : void 0
-    });
+    };
+    if (isHold) {
+      return new Promise((resolver) => {
+        holdError({ error: errorInfo, resolver });
+      });
+    } else {
+      addError(errorInfo);
+    }
   }
 }
 
@@ -4520,7 +4566,7 @@ var HttpClientAxios = class {
     });
     this.api.interceptors.request.use(
       async (config2) => {
-        addRequestLog(config2);
+        await addRequestLog(config2);
         const authClient = new AuthClient();
         const accessToken = await authClient.getAT();
         if (accessToken) {
@@ -4555,15 +4601,15 @@ var HttpClientAxios = class {
       }
     );
     this.api.interceptors.response.use(
-      (response) => {
-        addResponseLog(response);
+      async (response) => {
+        await addResponseLog(response);
         if (response.data.isSuccess === false) {
           return Promise.reject(response);
         }
         return response;
       },
       async (error) => {
-        addErrorLog(error);
+        await addErrorLog(error);
         const originalRequest = error.config;
         if (error.response?.status === 401) {
           isRefreshed = false;