datastake-daf 0.6.487 → 0.6.489

package/dist/utils/index.js

@@ -5096,6 +5096,16 @@ const safeJsonParse = (value, fallback = value) => {
     return fallback;
   }
 };
+const cleanJSON = json => {
+  for (let key in json) {
+    if (json[key] === undefined) {
+      json[key] = null;
+    } /*else if (typeof json[key] === 'object')
+      json[key] = cleanJSON(json[key]);
+      */
+  }
+  return json;
+};
 
 function _checkValue$1(wantedValue, match, fieldValue) {
   match = match ? match.trim() : null;
@@ -6016,6 +6026,152 @@ var browser$1 = {
 
 var process = browser$1;
 
+/**
+ * @description Manages window.storage
+ * @returns storage objects
+ * @class StorageManager
+ */
+class StorageManager {
+  /**
+   * @description Set or update given value in localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static set(key, value) {
+    if (key && value) {
+      window.localStorage.setItem(key, value);
+      return {
+        success: true,
+        data: "Storage has been set successfully."
+      };
+    }
+    return {
+      error: true,
+      data: "Storage was not set. Storage key and value is required!"
+    };
+  }
+
+  /**
+   * @description Set or update given value in sessionStorage, used to not remember user after closing opened tab.
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static setToSession(key, value) {
+    if (key && value) {
+      window.sessionStorage.setItem(key, value);
+      return {
+        success: true,
+        data: "Storage has been set successfully."
+      };
+    }
+    return {
+      error: true,
+      data: "Storage was not set. Storage key and value is required!"
+    };
+  }
+
+  /**
+   * @description Fetch data from localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static get(key, defaultValue = undefined) {
+    if (key) {
+      const val = window.localStorage.getItem(key) || window.sessionStorage.getItem(key);
+      return val || defaultValue;
+    }
+    return {
+      error: true,
+      data: "Storage key is required!"
+    };
+  }
+
+  /**
+   * @description Clear only one value from localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static clearOne(key) {
+    if (key === 'token') {
+      localStorage.removeItem('trade-type');
+      localStorage.removeItem('trade-value');
+    }
+    if (key) {
+      window.localStorage.removeItem(key) || window.sessionStorage.removeItem(key);
+    }
+    return "Storage key is required!";
+  }
+
+  /**
+   * @description Clear all values from localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static clearAll() {
+    window.localStorage.clear();
+    window.sessionStorage.clear();
+  }
+  static hasKey(key) {
+    return typeof this.get(key) === 'string';
+  }
+  static saveFilters(module, namespace, filters = {}, merge = false) {
+    let savedFilters = this.get('filters');
+    try {
+      savedFilters = JSON.parse(savedFilters);
+    } catch (e) {
+      savedFilters = {};
+    }
+    if (!savedFilters) {
+      savedFilters = {};
+    }
+    if (!savedFilters[module]) {
+      savedFilters[module] = {};
+    }
+    if (!savedFilters[module][namespace]) {
+      savedFilters[module][namespace] = {};
+    }
+    if (Object.keys(filters).length) {
+      savedFilters[module][namespace] = merge ? Object.assign(savedFilters[module][namespace], filters) : filters;
+    } else {
+      savedFilters[module][namespace] = {};
+    }
+    this.set('filters', JSON.stringify(savedFilters));
+    return savedFilters[module][namespace];
+  }
+  static getFilters(module, namespace) {
+    let savedFilters = this.get('filters');
+    try {
+      savedFilters = JSON.parse(savedFilters);
+    } catch (e) {
+      savedFilters = {};
+    }
+    if (!savedFilters) {
+      savedFilters = {};
+    }
+    if (!savedFilters[module]) {
+      savedFilters[module] = {};
+    }
+    if (!savedFilters[module][namespace]) {
+      savedFilters[module][namespace] = {};
+    }
+    return savedFilters[module][namespace];
+  }
+}
+
+const isProxy = () => {
+  const pathname = window.location.pathname;
+  if (pathname.includes('/proxy/pme') || pathname.includes('/proxy/cadd')) {
+    return window.opener || !!StorageManager.get('proxy_token');
+  }
+  return false;
+};
+const getToken = () => isProxy() ? StorageManager.get('proxy_token') : StorageManager.get('token');
+
 ({
   config: PropTypes__default["default"].object,
   filters: PropTypes__default["default"].object,
@@ -13431,17 +13587,153 @@ const processConfig = async configArray => {
   return processedConfig;
 };
 
+/**
+ * Utility functions for URL manipulation
+ */
+
+/**
+ * Assigns parameters to URL path
+ * Example: assignParamsToUrl('/users/{id}/posts/{postId}', { id: 1, postId: 2 })
+ * Returns: '/users/1/posts/2'
+ */
+const assignParamsToUrl = (path, params) => {
+  let paramsPath = path;
+  const matches = path.match(/\{\w+\}/gm);
+  if (matches) {
+    for (let param of matches) {
+      const key = param.match(/\w+/)[0];
+      paramsPath = paramsPath.replace(/\{\w+\}/, params[key]);
+    }
+  }
+  return paramsPath;
+};
+
+/**
+ * Build query string from object
+ * Example: buildQueryString({ page: 1, limit: 10 })
+ * Returns: '?page=1&limit=10'
+ */
+const buildQueryString = params => {
+  const query = Object.keys(params).filter(key => params[key] !== null && params[key] !== undefined).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join('&');
+  return query ? `?${query}` : '';
+};
+
+/**
+ * Generic error handler factory for axios requests
+ * Highly configurable to adapt to different project needs
+ */
+const createErrorHandler = (config = {}) => {
+  const {
+    onUnauthorized,
+    handleError,
+    getStorageManager,
+    checkTokenValidity = true,
+    unauthorizedRedirect = '/',
+    tokenStorageKey = 'token',
+    handleNetworkError = true
+  } = config;
+  return (error, customOnUnauthorized) => {
+    // Handle cases where error.response doesn't exist (network errors)
+    if (!error.response) {
+      if (handleNetworkError && handleError) {
+        handleError({
+          status: 0,
+          statusText: "Network Error",
+          data: ["Please check your internet connection."]
+        });
+      }
+      return Promise.reject(error);
+    }
+    const {
+      status,
+      statusText,
+      data: {
+        errors,
+        message
+      } = {}
+    } = error.response || {
+      data: {}
+    };
+
+    // Handle 401 Unauthorized
+    if (status === 401) {
+      if (checkTokenValidity && getStorageManager) {
+        const token = getStorageManager().get(tokenStorageKey);
+        if (token) {
+          if (typeof customOnUnauthorized === 'function') {
+            customOnUnauthorized();
+          } else if (typeof onUnauthorized === 'function') {
+            onUnauthorized();
+          } else {
+            getStorageManager().clearOne(tokenStorageKey);
+            if (typeof window !== 'undefined') {
+              window.location.href = unauthorizedRedirect;
+            }
+          }
+        }
+      }
+    }
+
+    // Handle 4xx and 5xx errors
+    if (status >= 400 && status <= 500) {
+      if (handleError) {
+        handleError({
+          status,
+          statusText: message || statusText,
+          data: errors || []
+        });
+      }
+    }
+    return Promise.reject(error);
+  };
+};
+
+/**
+ * Simple error handler using antd message component
+ * Useful for quick error notifications
+ */
+const handleError = err => {
+  const errorMessage = err?.response?.data?.message || err?.message || 'An error occurred';
+  antd.message.error(errorMessage);
+};
+
+/**
+ * Success message handler
+ */
+const handleSuccess = msg => {
+  antd.message.success(msg || 'Operation successful');
+};
+
+/**
+ * Warning message handler
+ */
+const handleWarning = msg => {
+  antd.message.warning(msg || 'Warning');
+};
+
+/**
+ * Info message handler
+ */
+const handleInfo = msg => {
+  antd.message.info(msg);
+};
+
 exports.ErrorFormat = ErrorFormat;
 exports.MessageTypes = MessageTypes;
+exports.StorageManager = StorageManager;
+exports.assignParamsToUrl = assignParamsToUrl;
 exports.btn = button;
+exports.buildQueryString = buildQueryString;
 exports.camelCaseToTitle = camelCaseToTitle;
 exports.capitalize = capitalize;
 exports.capitalizeAll = capitalizeAll;
 exports.captureComponentsAsImages = captureComponentsAsImages;
 exports.captureElementsAsImages = captureElementsAsImages;
 exports.changeInputMeta = changeInputMeta;
+exports.cleanJSON = cleanJSON;
 exports.convertUndefinedToNull = convertUndefinedToNull;
 exports.createDocument = createDocument;
+exports.createErrorHandler = createErrorHandler;
 exports.defaultFilterKeys = defaultFilterKeys;
 exports.defaultMapConfig = defaultMapConfig;
 exports.defaultTheme = mmtTheme;
@@ -13464,7 +13756,12 @@ exports.getOptionConfig = getOptionConfig;
 exports.getOptionLabel = getOptionLabel;
 exports.getRangeOfTicks = getRangeOfTicks;
 exports.getTagColor = getTagColor;
+exports.getToken = getToken;
 exports.groupSubsections = groupSubsections;
+exports.handleError = handleError;
+exports.handleInfo = handleInfo;
+exports.handleSuccess = handleSuccess;
+exports.handleWarning = handleWarning;
 exports.hasNotChanged = hasNotChanged;
 exports.isEmptyOrSpaces = isEmptyOrSpaces;
 exports.isModuleApproved = isModuleApproved;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "datastake-daf",
-	"version": "0.6.487",
+	"version": "0.6.489",
 	"dependencies": {
 		"@ant-design/icons": "^5.2.5",
 		"@antv/g2": "^5.1.1",

package/rollup.config.js

@@ -95,6 +95,26 @@ export default [
 				requireReturnsDefault: "auto",
 			}),
 		],
+	},	
+	{
+		input: "src/services.js",
+		output: [
+			{
+				file: "dist/services/index.js",
+				format: "cjs",
+			},
+		],
+		external,
+		plugins: [
+			nodePolyfills(),
+			resolve({ browser: true }),
+			babel({ exclude: "node_modules/**", babelrc: true }),
+			peerDep(),
+			commonjs({
+				include: /node_modules/,
+				requireReturnsDefault: "auto",
+			}),
+		],
 	},
 	{
 		input: "src/hooks.js",

package/src/@daf/core/components/Dashboard/ComponentWithFocus/HoverFocus/index.jsx

@@ -0,0 +1,114 @@
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import styled from "styled-components";
+import PropTypes from "prop-types";
+
+const Style = styled.div`
+	position: relative;
+	width: 100%;
+	height: 100%;
+
+	.p-placeholder {
+		position: absolute;
+		top: 0px;
+		left: 0px;
+		width: 100%;
+		height: 100%;
+		background: transparent;
+		z-index: 100;
+		cursor: default;
+	}
+`;
+
+/**
+ * ComponentWithHoverFocus
+ *
+ * A wrapper component that requires user interaction to activate (focus) its children.
+ * This is particularly useful for embedding interactive elements like tables, maps or flow editors
+ * (e.g., built with React Flow) that could otherwise interfere with global interactions
+ * like scrolling or dragging.
+ *
+ * Behavior:
+ * - Initially, a transparent overlay is shown to block interaction.
+ * - Hovering over the overlay removes it, allowing interaction with the children.
+ * - If the mouse moves outside the component bounds, the overlay reappears, blocking interaction again.
+ * - An optional `unFocus` callback is triggered when the component loses focus.
+ *
+ * Props:
+ * @param {React.ReactNode} children - The interactive content to be wrapped.
+ * @param {React.CSSProperties} [style={}] - Inline styles to apply to the wrapper.
+ * @param {boolean} [show=false] - If true, the placeholder overlay is always shown.
+ * @param {string} [className] - Additional class names for styling the wrapper.
+ * @param {() => void} [unFocus] - Callback fired when the component loses focus (mouse leaves bounds).
+ *
+ */
+
+function ComponentWithHoverFocus({
+	children,
+	style = {},
+	show = false,
+	className,
+	unFocus,
+}) {
+	const [placeholderIsVisible, setPlaceholderIsVisible] = useState(true);
+	const ref = useRef();
+	const [closed, setClosed] = useState(false);
+
+	const checkMouse = useCallback(
+		(event) => {
+			if (!placeholderIsVisible) {
+				if (ref.current) {
+					const divRect = ref.current.getBoundingClientRect();
+					if (
+						event.clientX >= divRect.left &&
+						event.clientX <= divRect.right &&
+						event.clientY >= divRect.top &&
+						event.clientY <= divRect.bottom
+					) {
+						return;
+					}
+					setPlaceholderIsVisible(true);
+					if (typeof unFocus === "function") {
+						unFocus();
+					}
+				}
+			}
+		},
+		[placeholderIsVisible, unFocus],
+	);
+
+	useEffect(() => {
+		document.addEventListener("mousemove", checkMouse);
+		return () => document.removeEventListener("mousemove", checkMouse); // Fixed typo
+	}, [checkMouse]);
+
+	useEffect(() => {
+		if (closed) {
+			setPlaceholderIsVisible(false);
+			setClosed(false);
+		}
+	}, [closed]);
+
+	return (
+		<Style className={className} ref={ref} style={style}>
+			{(placeholderIsVisible || show) && (
+				<div
+					onMouseEnter={() => setPlaceholderIsVisible(false)}
+					className="p-placeholder"
+					style={style}
+				/>
+			)}
+			{children}
+		</Style>
+	);
+}
+
+ComponentWithHoverFocus.propTypes = {
+	children: PropTypes.node,
+	style: PropTypes.object,
+	show: PropTypes.bool,
+	className: PropTypes.string,
+	unFocus: PropTypes.func,
+};
+
+export default ComponentWithHoverFocus;
+

package/src/@daf/core/components/Dashboard/ComponentWithFocus/index.jsx

@@ -76,7 +76,7 @@ export default function ComponentWithFocus({
 
 	useEffect(() => {
 		document.addEventListener("mousemove", checkMouse);
-		return () => document.removeEventListener("mousemov", checkMouse);
+		return () => document.removeEventListener("mousemove", checkMouse);
 	}, [checkMouse]);
 
 	useEffect(() => {