@acoustte-digital-services/digitalstore-controls-dev 0.8.1-dev.20260326104921 → 0.8.1-dev.20260326105727

package/dist/LinkNodeButton-KBSXOEHS.mjs

@@ -0,0 +1,169 @@
+"use client";
+import {
+  Button_default,
+  ServiceClient_default
+} from "./chunk-3IDT4246.mjs";
+
+// src/components/pageRenderingEngine/nodes/LinkNodeButton.tsx
+import { useCallback, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var LinkNodeButton = (props) => {
+  const { node, dataitem, children, linkText, linkType, linkUrl } = props;
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const extractFieldNames = useCallback((template) => {
+    if (!template) return [];
+    const regex = /\{(\{\})?([a-zA-Z_$][a-zA-Z0-9_$]*)(?:\}\})?\}/g;
+    const matches = Array.from(template.matchAll(regex));
+    const fieldNames = matches.map((match) => match[2] || match[1]).filter((name, index, self) => self.indexOf(name) === index);
+    return fieldNames;
+  }, []);
+  const replaceTemplateVariables = useCallback((template, responseData) => {
+    if (!template) return template;
+    let result = template;
+    const fieldNames = extractFieldNames(template);
+    if (responseData) {
+      fieldNames.forEach((fieldName) => {
+        const value = getNestedValue(responseData, fieldName);
+        if (value !== void 0) {
+          const regex1 = new RegExp(`\\{${fieldName}\\}`, "g");
+          const regex2 = new RegExp(`\\{\\{${fieldName}\\}\\}`, "g");
+          result = result.replace(regex1, String(value));
+          result = result.replace(regex2, String(value));
+        }
+      });
+    }
+    if (props.routeParameters) {
+      Object.entries(props.routeParameters).forEach(([key, value]) => {
+        const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+        result = result.replace(regex, String(value));
+      });
+    }
+    if (dataitem) {
+      Object.entries(dataitem).forEach(([key, value]) => {
+        const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+        result = result.replace(regex, String(value));
+      });
+    }
+    return result;
+  }, [props.routeParameters, dataitem, extractFieldNames]);
+  const getNestedValue = useCallback((obj, path) => {
+    if (!obj || !path) return void 0;
+    if (obj[path] !== void 0) {
+      return obj[path];
+    }
+    const keys = path.split(".");
+    let current = obj;
+    for (const key of keys) {
+      if (current[key] === void 0) {
+        return void 0;
+      }
+      current = current[key];
+    }
+    return current;
+  }, []);
+  const onClick = useCallback(async (e) => {
+    if (!node.postUrl) {
+      setError("No POST URL configured for this button");
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const resolvedPostUrl = replaceTemplateVariables(node.postUrl);
+      let parsedPayload = {};
+      if (node.payload) {
+        try {
+          const payloadStr = replaceTemplateVariables(node.payload);
+          parsedPayload = JSON.parse(payloadStr);
+          console.log("Parsed payload:", parsedPayload);
+        } catch (err) {
+          console.error("Failed to parse payload JSON:", err);
+          parsedPayload = { error: "Invalid payload JSON" };
+        }
+      }
+      const serviceClient = new ServiceClient_default(props.apiBaseUrl, props.session);
+      const response = await serviceClient.post(resolvedPostUrl, parsedPayload);
+      console.log("API Response:", response);
+      if (response && !response.isSuccessful) {
+        const errorMessage = response.message || "API request failed";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { isSuccessful: false, message: errorMessage };
+      }
+      if (response && node.redirectUrl) {
+        const fieldNames = extractFieldNames(node.redirectUrl);
+        console.log("Field names in redirect URL:", fieldNames);
+        const fieldValueMap = {};
+        fieldNames.forEach((fieldName) => {
+          const value = getNestedValue(response, fieldName);
+          if (value !== void 0) {
+            fieldValueMap[fieldName] = String(value);
+          } else {
+            const resultValue = getNestedValue(response, `result.${fieldName}`);
+            if (resultValue !== void 0) {
+              fieldValueMap[fieldName] = String(resultValue);
+            } else {
+              const dataValue = getNestedValue(response, `data.${fieldName}`);
+              if (dataValue !== void 0) {
+                fieldValueMap[fieldName] = String(dataValue);
+              }
+            }
+          }
+        });
+        console.log("Field value map:", fieldValueMap);
+        const missingFields = fieldNames.filter((fieldName) => !fieldValueMap[fieldName]);
+        if (missingFields.length > 0) {
+          console.warn(`Missing field values for: ${missingFields.join(", ")}`);
+        }
+        let resolvedRedirectUrl = node.redirectUrl;
+        Object.entries(fieldValueMap).forEach(([fieldName, value]) => {
+          const regex1 = new RegExp(`\\{${fieldName}\\}`, "g");
+          const regex2 = new RegExp(`\\{\\{${fieldName}\\}\\}`, "g");
+          resolvedRedirectUrl = resolvedRedirectUrl.replace(regex1, value);
+          resolvedRedirectUrl = resolvedRedirectUrl.replace(regex2, value);
+        });
+        resolvedRedirectUrl = replaceTemplateVariables(resolvedRedirectUrl, response);
+        console.log("Final redirect URL:", resolvedRedirectUrl);
+        if (resolvedRedirectUrl && !resolvedRedirectUrl.includes("{")) {
+          window.location.href = resolvedRedirectUrl;
+        }
+      } else if (response && !response.result && response.message) {
+        setError(response.message);
+        throw new Error(response.message);
+      } else if (!response) {
+        setError("No response from server");
+      }
+      setIsLoading(false);
+      return { isSuccessful: true, response };
+    } catch (err) {
+      console.error("Button API call failed:", err);
+      setError(err.message || "An unexpected error occurred");
+      setIsLoading(false);
+      return { isSuccessful: false, message: err.message };
+    }
+  }, [node.postUrl, node.payload, node.redirectUrl, replaceTemplateVariables, extractFieldNames, getNestedValue, props.apiBaseUrl, props.session]);
+  const renderButtonContent = () => {
+    if (children) {
+      return children;
+    }
+    if (linkText) {
+      return /* @__PURE__ */ jsx("span", { children: linkText });
+    }
+    return node.title || "Button";
+  };
+  return /* @__PURE__ */ jsx("div", { className: "link-button-wrapper", children: /* @__PURE__ */ jsx(
+    Button_default,
+    {
+      ButtonType: linkType,
+      onClick,
+      disabled: isLoading,
+      className: "w-full",
+      children: renderButtonContent()
+    }
+  ) });
+};
+var LinkNodeButton_default = LinkNodeButton;
+export {
+  LinkNodeButton_default as default
+};

package/dist/chunk-3IDT4246.mjs

@@ -0,0 +1,400 @@
+// src/components/Button.tsx
+import React3, { useState as useState2 } from "react";
+
+// src/components/ToastService.tsx
+var ToastService = class _ToastService {
+  static initialize(showToast, closeToast) {
+    _ToastService.showToast = showToast;
+    _ToastService.closeToast = closeToast;
+  }
+  static showError(message) {
+    if (_ToastService.showToast) {
+      _ToastService.showToast(message, "error");
+    }
+  }
+  static showInfo(message) {
+    if (_ToastService.showToast) {
+      _ToastService.showToast(message, "info");
+    }
+  }
+  static close() {
+    if (_ToastService.closeToast) {
+      _ToastService.closeToast();
+    }
+  }
+};
+var ToastService_default = ToastService;
+
+// src/components/StyleTypes.tsx
+var buttonClasses = /* @__PURE__ */ new Map([
+  ["Primary" /* Solid */, "btn-solid"],
+  ["PrimaryHollow" /* Hollow */, "btn-hollow"],
+  ["Link" /* Link */, "btn-link"]
+]);
+var progressClasses = /* @__PURE__ */ new Map([
+  ["Primary" /* Solid */, ""],
+  ["PrimaryHollow" /* Hollow */, ""],
+  ["Link" /* Link */, ""]
+]);
+
+// src/components/Confirm.tsx
+import { useState } from "react";
+
+// src/components/ClientButton.tsx
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+var ClientButton = (props) => {
+  const execute = async (event) => {
+    if (props.onClick !== void 0) {
+      props.onClick();
+    } else {
+      ToastService_default.showError("No action defined.");
+    }
+  };
+  let buttonClass = props.ButtonType ? buttonClasses.get(props.ButtonType) : buttonClasses.get("Primary" /* Solid */);
+  return /* @__PURE__ */ jsx(React.Fragment, { children: /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: execute,
+      className: buttonClass + " " + props.className,
+      children: props.children
+    }
+  ) });
+};
+var ClientButton_default = ClientButton;
+
+// src/components/Confirm.tsx
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var Confirm = ({ message, onConfirm, onCancel }) => {
+  const [showModal, setShowModal] = useState(true);
+  const handleConfirmAction = () => {
+    setShowModal(false);
+    if (onConfirm) {
+      onConfirm();
+    }
+  };
+  const handleCancelAction = () => {
+    setShowModal(false);
+    if (onCancel) {
+      onCancel();
+    }
+  };
+  return /* @__PURE__ */ jsx2(Fragment, { children: showModal && /* @__PURE__ */ jsxs("div", { className: "fixed inset-0 flex items-center justify-center z-50", children: [
+    /* @__PURE__ */ jsx2("div", { className: "absolute inset-0 bg-black opacity-70" }),
+    /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-md p-6 w-2/6 shadow border z-50", children: [
+      /* @__PURE__ */ jsx2("p", { className: "text-xl font-medium mb-4", children: "Confirmation" }),
+      /* @__PURE__ */ jsx2("p", { className: "mb-4", children: message }),
+      /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-8", children: [
+        /* @__PURE__ */ jsx2(
+          ClientButton_default,
+          {
+            onClick: handleCancelAction,
+            ButtonType: "PrimaryHollow" /* Hollow */,
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          ClientButton_default,
+          {
+            onClick: handleConfirmAction,
+            children: "Confirm"
+          }
+        )
+      ] })
+    ] })
+  ] }) });
+};
+var Confirm_default = Confirm;
+{
+}
+
+// src/components/Button.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var Button = (props) => {
+  const [inProgress, setInProgress] = useState2(false);
+  const [isActionPerformed, setIsActionPerformed] = useState2(false);
+  const [responseMessage, setResponseMessage] = useState2(null);
+  const [showModal, setShowModal] = useState2(null);
+  const execute = async (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (props.confirm) {
+      const confirmed = await showConfirmation("Are you sure you want to delete this item?");
+      setShowModal(null);
+      if (!confirmed) {
+        return;
+      }
+    }
+    if (props.oneTimeAction && isActionPerformed) {
+      return;
+    }
+    setInProgress(true);
+    let isValid = true;
+    if (props.onValidate !== void 0) {
+      isValid = await props.onValidate();
+      if (!isValid) {
+        setInProgress(false);
+        ToastService_default.showError("There are errors in the form. Please fix them before proceeding.");
+        return;
+      }
+    }
+    if (props.onClick !== void 0) {
+      let response = await props.onClick();
+      if (response.isSuccessful) {
+        setIsActionPerformed(true);
+        setResponseMessage(response.message);
+        if (props.showToast) {
+          ToastService_default.showInfo(response.message || "");
+        }
+      } else {
+        ToastService_default.showError(response.message || "");
+      }
+    } else {
+      ToastService_default.showError("No action defined.");
+    }
+    setInProgress(false);
+  };
+  const showConfirmation = (message) => {
+    return new Promise((resolve) => {
+      const onConfirm = () => resolve(true);
+      const onCancel = () => resolve(false);
+      setShowModal(/* @__PURE__ */ jsx3(Confirm_default, { message: props.confirmationMessage, onConfirm, onCancel }));
+    });
+  };
+  let buttonClass = props.ButtonType ? buttonClasses.get(props.ButtonType) : buttonClasses.get("Primary" /* Solid */);
+  let progressClass = props.ButtonType ? progressClasses.get(props.ButtonType) : progressClasses.get("Primary" /* Solid */);
+  const isDisabled = inProgress || isActionPerformed && props.oneTimeAction;
+  return /* @__PURE__ */ jsxs2(React3.Fragment, { children: [
+    /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        type: "submit",
+        onClick: execute,
+        disabled: props.disabled,
+        title: isDisabled ? "The button is disabled to prevent any action" : "",
+        className: buttonClass + " relative " + props.className,
+        children: [
+          isActionPerformed && props.oneTimeAction && responseMessage ? responseMessage : props.children,
+          inProgress && /* @__PURE__ */ jsx3(React3.Fragment, { children: props.hideProgressIndicator === true ? /* @__PURE__ */ jsx3("div", { className: "absolute bottom-0 left-0 h-0.5 bg-gray-400 rounded animate-progress" }) : /* @__PURE__ */ jsxs2("svg", { className: "animate-spin ml-2 mr-3 h-5 w-5 " + progressClass, xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 24 24", children: [
+            /* @__PURE__ */ jsx3("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
+            /* @__PURE__ */ jsx3("path", { className: "opacity-75", fill: "currentColor", d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" })
+          ] }) })
+        ]
+      }
+    ),
+    showModal
+  ] });
+};
+var Button_default = Button;
+
+// src/clients/CacheManage.tsx
+import NodeCache from "node-cache";
+var CacheManager = class _CacheManager {
+  constructor() {
+    this.maxCacheSize = 1e3;
+    this.cache = new NodeCache({ stdTTL: 0, checkperiod: 300 });
+  }
+  static getInstance() {
+    if (!_CacheManager.instance) {
+      _CacheManager.instance = new _CacheManager();
+    }
+    return _CacheManager.instance;
+  }
+  get(key) {
+    return null;
+  }
+  set(key, data, ttl) {
+  }
+  clear() {
+    this.cache.flushAll();
+  }
+  size() {
+    return this.cache.keys().length;
+  }
+  destroy() {
+    this.cache.close();
+  }
+};
+
+// src/clients/ServiceClient.tsx
+var ServerApiError = class extends Error {
+  constructor(data, status) {
+    super(data.message || "---");
+    this.status = status;
+    this.data = data;
+    this.data.isSuccessful = false;
+  }
+};
+var ServiceClient = class {
+  constructor(apiBaseUrl, session) {
+    this.cacheManager = CacheManager.getInstance();
+    this.baseUrl = apiBaseUrl;
+    this.session = session;
+  }
+  buildFullPath(path, params) {
+    let updatedPath = path;
+    if (params) {
+      Object.keys(params).forEach((key) => {
+        updatedPath = updatedPath.replace(
+          `{${key}}`,
+          String(params[key])
+        );
+      });
+    }
+    return this.baseUrl + updatedPath;
+  }
+  getConfig() {
+    const config = { headers: {} };
+    if (this.session) {
+      if (this.session.oAuthToken) {
+        config.headers["Authorization"] = "Bearer " + this.session.oAuthToken;
+      }
+      config.headers["cid"] = this.session.cid || "";
+      config.headers["UserCurrencyCode"] = this.session.userCurrencyCode || "INR";
+      config.headers["MarketCode"] = this.session?.marketCode || "IND";
+    }
+    return config;
+  }
+  handleFetchError(error) {
+    console.log(error);
+    const serverApiError = error;
+    if (serverApiError) {
+      return serverApiError.data;
+    }
+    return {
+      message: "There is some error. Please try after sometime.",
+      isSuccessful: false
+    };
+  }
+  async fetchJsonWithCache(fullPath, config) {
+    const cacheKey = fullPath + "--" + (this.session?.marketCode || "IND");
+    const cachedData = this.cacheManager.get(cacheKey);
+    if (cachedData) {
+      return cachedData;
+    }
+    console.log("*****************CALLING API:", cacheKey, (/* @__PURE__ */ new Date()).toISOString());
+    const response = await fetch(fullPath, { headers: config.headers });
+    if (!response.ok) {
+      const apiErrorData = await response.json();
+      throw new ServerApiError(apiErrorData, response.status);
+    }
+    const cacheControl = response.headers.get("Cache-Control");
+    let revalidate = null;
+    if (cacheControl) {
+      const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+      if (maxAgeMatch && maxAgeMatch[1]) {
+        const maxAge = parseInt(maxAgeMatch[1], 10);
+        revalidate = maxAge * 1e3;
+      }
+    }
+    const data = await response.json();
+    data.isSuccessful = true;
+    if (revalidate !== null && revalidate > 0) {
+      console.log("revalidate............I am caching:" + revalidate);
+      this.cacheManager.set(cacheKey, data, revalidate);
+    }
+    return data;
+  }
+  //   private async refreshToken(): Promise<void> {
+  //     console.log("*******************calling refresh token***********************");
+  //     try {
+  //       const response = await fetch(this.baseUrl + "/auth/storefront/login/refreshToken", {
+  //         method: 'POST',
+  //         headers: {
+  //           'Content-Type': 'application/json'
+  //         },
+  //         body: JSON.stringify({ refreshToken: this.session.refreshToken })
+  //       });
+  //       if (!response.ok) {
+  //         throw new Error("Failed to refresh token");
+  //       }
+  //       const responseData = await response.json();
+  //       this.session.oAuthToken = responseData.result.accessToken;
+  //       if (typeof window === "undefined") {
+  //         // Running on the server
+  //       } else {
+  //         await fetch("/api/login", {
+  //           method: "post",
+  //           headers: {
+  //             "Content-Type": "application/json",
+  //           },
+  //           body: JSON.stringify({ session: this.session }),
+  //         });
+  //       }
+  //     } catch (error: any) {
+  //       throw new Error("Failed to refresh token");
+  //     }
+  //   }
+  async handleRequest(request) {
+    try {
+      return await request();
+    } catch (error) {
+      throw error;
+    }
+  }
+  async post(path, data) {
+    const request = async () => {
+      const fullPath = this.baseUrl + path;
+      const config = this.getConfig();
+      const response = await fetch(fullPath, {
+        method: "POST",
+        headers: {
+          ...config.headers,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        const apiErrorData = await response.json();
+        throw new ServerApiError(apiErrorData, response.status);
+      }
+      const responseData = await response.json();
+      responseData.isSuccessful = true;
+      return responseData;
+    };
+    try {
+      return await this.handleRequest(request);
+    } catch (error) {
+      return this.handleFetchError(error);
+    }
+  }
+  async getSingle(path, params) {
+    const request = async () => {
+      const sanitizedParams = params ? Object.fromEntries(
+        Object.entries(params).map(([k, v]) => [k, String(v)])
+      ) : void 0;
+      const fullPath = this.buildFullPath(path, sanitizedParams);
+      const config = this.getConfig();
+      return await this.fetchJsonWithCache(fullPath, config);
+    };
+    try {
+      return await this.handleRequest(request);
+    } catch (error) {
+      return this.handleFetchError(error);
+    }
+  }
+  async get(path, params) {
+    const request = async () => {
+      const sanitizedParams = params ? Object.fromEntries(
+        Object.entries(params).map(([k, v]) => [k, String(v)])
+      ) : void 0;
+      const fullPath = this.buildFullPath(path, sanitizedParams);
+      const config = this.getConfig();
+      console.log(fullPath);
+      return await this.fetchJsonWithCache(fullPath, config);
+    };
+    try {
+      return await this.handleRequest(request);
+    } catch (error) {
+      return this.handleFetchError(error);
+    }
+  }
+};
+var ServiceClient_default = ServiceClient;
+
+export {
+  buttonClasses,
+  Button_default,
+  ServiceClient_default
+};