@libs-ui/utils 0.2.281 → 0.2.283

package/fesm2022/libs-ui-utils.mjs

@@ -645,6 +645,70 @@ const omitBy = (objData, predicate) => {
     });
     return newObj;
 };
+/**
+ * Lấy giá trị từ đối tượng theo đường dẫn chỉ định
+ *
+ * Hàm này giúp bạn truy cập vào các thuộc tính sâu bên trong một đối tượng một cách an toàn,
+ * tránh lỗi khi thuộc tính không tồn tại.
+ *
+ * @param obj Đối tượng nguồn cần lấy giá trị
+ * @param path Đường dẫn đến thuộc tính cần lấy. Có thể là:
+ *   - Chuỗi: 'user.profile.name' hoặc 'items[0].title'
+ *   - Mảng: ['user', 'profile', 'name'] hoặc ['items', '0', 'title']
+ *   - Chuỗi rỗng '': trả về chính đối tượng gốc
+ * @param defaultValue Giá trị mặc định trả về khi không tìm thấy thuộc tính (mặc định: undefined)
+ * @param keepLastValueIfSignal Có giữ nguyên signal cuối cùng hay không (mặc định: false - sẽ gọi signal())
+ * @returns Giá trị tìm được hoặc giá trị mặc định
+ *
+ * @example
+ * // Ví dụ cơ bản
+ * const user = { name: 'John', age: 30 };
+ * get(user, 'name'); // 'John'
+ * get(user, 'email'); // undefined
+ * get(user, 'email', 'no-email'); // 'no-email'
+ *
+ * @example
+ * // Truyền path rỗng - trả về chính đối tượng gốc
+ * const data = { name: 'Alice', age: 25 };
+ * get(data, ''); // { name: 'Alice', age: 25 } (chính đối tượng data)
+ * get(data, '', 'default'); // { name: 'Alice', age: 25 } (bỏ qua defaultValue)
+ *
+ * @example
+ * // Truy cập thuộc tính sâu
+ * const data = {
+ *   user: {
+ *     profile: {
+ *       name: 'Alice',
+ *       settings: { theme: 'dark' }
+ *     }
+ *   }
+ * };
+ * get(data, 'user.profile.name'); // 'Alice'
+ * get(data, 'user.profile.settings.theme'); // 'dark'
+ * get(data, 'user.profile.avatar', 'default.jpg'); // 'default.jpg'
+ *
+ * @example
+ * // Truy cập mảng
+ * const items = [
+ *   { name: 'Item 1', price: 100 },
+ *   { name: 'Item 2', price: 200 }
+ * ];
+ * get(items, '[0].name'); // 'Item 1'
+ * get(items, '0.price'); // 100
+ * get(items, '[1].name'); // 'Item 2'
+ * get(items, '[2].name', 'Not found'); // 'Not found'
+ *
+ * @example
+ * // Sử dụng với mảng path
+ * const nested = { a: { b: { c: 'deep value' } } };
+ * get(nested, ['a', 'b', 'c']); // 'deep value'
+ * get(nested, ['a', 'b', 'd'], 'default'); // 'default'
+ *
+ * @example
+ * // Trường hợp đặc biệt
+ * get(null, 'any.path'); // undefined
+ * get(undefined, 'any.path', 'fallback'); // 'fallback'
+ */
 const get = (obj, path, defaultValue = undefined, keepLastValueIfSignal) => {
     if (isNil(obj)) {
         return defaultValue;
@@ -2447,36 +2511,190 @@ const convertUrlToFile = (url, fileName) => {
     });
 };
 
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+// Constants for better maintainability
+const DEFAULT_MIN_TICK_COUNT = 5;
+const DEFAULT_MAX_TICK_COUNT = 10;
+const MIN_DISTANCE_TO_ZERO = 3;
+const NEGATIVE_THRESHOLD = -5;
+const FALLBACK_NEGATIVE_VALUE = -4;
+const MAX_POW_NUMBER = 14;
+const MAX_TEMPLATE_NUMBER = 10;
+// Cache for power calculations - shared across function calls for better performance
+const POWER_CACHE = new Map();
+/**
+ * Calculates smart axis scale for charts
+ *
+ * @description This function can throw errors if:
+ * - maxData < 0 and acceptNegative is false
+ * - minNegative is undefined and acceptNegative is true
+ * - maxData < minNegative (only when acceptNegative is true)
+ * - minNegative > 0 (only when acceptNegative is true)
+ *
+ * @throws {Error} Validation errors for invalid input combinations
+ * @required Always wrap this function in try-catch and handle exceptions
+ * @param maxData - Maximum data value
+ * @param options - Configuration options for axis scaling
+ * @returns Axis scale configuration
+ */
 const getSmartAxisScale = (maxData, options) => {
-    const stepCandidates = options?.stepCandidates || [1, 2, 5, 10, 20, 25, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000];
+    // Input validation - fail fast approach
+    validateInputs(maxData, options);
+    // Extract and set defaults
+    const { minTickCount = DEFAULT_MIN_TICK_COUNT, maxTickCount = DEFAULT_MAX_TICK_COUNT, stepCandidates = [], acceptNegative = false, minNegative, acceptStepIsTypeFloat = false } = options || {};
+    // Generate step candidates if not provided
+    const finalStepCandidates = stepCandidates.length > 0
+        ? [...stepCandidates]
+        : generateStepCandidates(maxData, minTickCount, minNegative, acceptStepIsTypeFloat);
+    // Remove console.log for production code
+    // console.log(`stepCandidates: `, finalStepCandidates);
+    // Calculate scale parameters
+    const scaleParams = calculateScaleParams(maxData, acceptNegative, minNegative, finalStepCandidates);
+    // Find optimal scale
+    const optimalScale = findOptimalScale(scaleParams, finalStepCandidates, minTickCount, maxTickCount, options);
+    if (optimalScale) {
+        return optimalScale;
+    }
+    // Fallback calculation
+    return calculateFallbackScale(scaleParams.distanceToZero, minTickCount);
+};
+/**
+ * Validates input parameters
+ */
+function validateInputs(maxData, options) {
+    if (maxData < 0 && !options?.acceptNegative) {
+        throw new Error("maxData is less than 0 and acceptNegative is false");
+    }
+    if (options?.acceptNegative) {
+        if (isNil(options.minNegative)) {
+            throw new Error("minNegative is required when acceptNegative is true");
+        }
+        if (maxData < options.minNegative) {
+            throw new Error("maxData is less than minNegative");
+        }
+        if (options.minNegative >= 0) {
+            throw new Error("minNegative must be negative");
+        }
+    }
+}
+/**
+ * Calculates scale parameters for axis calculation
+ */
+function calculateScaleParams(maxData, acceptNegative, minNegative, stepCandidates) {
+    let distanceToZero = maxData;
+    let reverse = 1;
+    let adjustedMaxData = maxData;
+    if (acceptNegative && !isNil(minNegative)) {
+        if (maxData === 0) {
+            adjustedMaxData = -1;
+        }
+        // Add negative step candidates
+        if (stepCandidates) {
+            stepCandidates.unshift(...stepCandidates.map(item => -item));
+        }
+        if (adjustedMaxData <= 0) {
+            distanceToZero = minNegative;
+        }
+        if (distanceToZero > NEGATIVE_THRESHOLD) {
+            distanceToZero = FALLBACK_NEGATIVE_VALUE;
+        }
+        if (adjustedMaxData > 0) {
+            distanceToZero = adjustedMaxData + Math.abs(minNegative);
+            reverse = -1;
+        }
+    }
+    if (Math.abs(distanceToZero) < MIN_DISTANCE_TO_ZERO) {
+        distanceToZero = MIN_DISTANCE_TO_ZERO;
+    }
+    return { distanceToZero, reverse, adjustedMaxData };
+}
+/**
+ * Finds optimal scale from step candidates
+ */
+function findOptimalScale(scaleParams, stepCandidates, minTickCount, maxTickCount, options) {
+    const { distanceToZero, reverse, adjustedMaxData } = scaleParams;
     for (const step of stepCandidates) {
-        let tickCount = Math.ceil(maxData / step) + 1;
-        let maxY = step * tickCount;
-        if (tickCount >= (options?.minTickCount || 5) && tickCount <= (options?.maxTickCount || 10)) {
-            if (maxData < maxY) {
-                tickCount = maxData - (tickCount - 1) * step < -1 * (step / 4) ? tickCount - 1 : tickCount;
-                maxY = step * tickCount;
-                return {
-                    step: step,
-                    maxY: maxY,
-                    ticks: tickCount
-                };
+        let tickCount = Math.abs(Math.ceil(distanceToZero / step)) + (reverse === -1 ? 2 : 1);
+        let maxValue = adjustedMaxData <= 0 ? 0 : step * tickCount * reverse;
+        let minValue = 0;
+        if (tickCount >= minTickCount && tickCount <= maxTickCount && adjustedMaxData < maxValue) {
+            if (options?.acceptNegative) {
+                minValue = calculateMinValue(step, tickCount, options.minNegative);
             }
+            // Adjust tick count based on distance calculation
+            const distanceCheck = distanceToZero - (tickCount - 1) * step;
+            if (distanceCheck < -1 * (step / 4)) {
+                tickCount -= 1;
+            }
+            maxValue = (step * tickCount * reverse) - (minValue * reverse);
+            return {
+                stepSize: Math.abs(step),
+                max: maxValue,
+                min: minValue,
+                tickAmount: tickCount
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Calculates minimum value for negative acceptance
+ */
+function calculateMinValue(step, tickCount, minNegative) {
+    let minValue = 0;
+    if (!isNil(minNegative)) {
+        let tick = 1;
+        while (tick <= tickCount && minValue >= minNegative) {
+            minValue = tick * step;
+            tick++;
         }
     }
-    const tickCount = options?.maxTickCount || 10;
-    let step = Math.ceil(maxData / tickCount);
-    let maxY = step * tickCount;
-    if (maxData === maxY) {
+    return minValue;
+}
+/**
+ * Calculates fallback scale when no optimal scale is found
+ */
+function calculateFallbackScale(distanceToZero, minTickCount) {
+    let step = Math.ceil(distanceToZero / minTickCount) || 1;
+    let maxValue = step * minTickCount;
+    if (distanceToZero === maxValue) {
         step = step + Math.ceil(step / 10);
-        maxY = step * tickCount;
+        maxValue = step * minTickCount;
     }
     return {
-        step: step,
-        maxY: maxY,
-        ticks: tickCount
+        stepSize: Math.abs(step),
+        max: maxValue,
+        min: 0,
+        tickAmount: minTickCount
     };
-};
+}
+/**
+ * Generates step candidates with performance optimizations
+ */
+function generateStepCandidates(maxData, minStep, minNegative, acceptStepIsTypeFloat) {
+    const stepCandidates = [];
+    const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;
+    // Pre-populate power cache for better performance
+    for (let powNumber = 0; powNumber < MAX_POW_NUMBER; powNumber++) {
+        if (!POWER_CACHE.has(powNumber)) {
+            POWER_CACHE.set(powNumber, Math.pow(10, powNumber));
+        }
+        const powByTemp = POWER_CACHE.get(powNumber);
+        for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {
+            if (acceptStepIsTypeFloat) {
+                const floatStep = powByTemp * (((templateNumber - 1) * 2 + 1) / 2);
+                stepCandidates.push(floatStep);
+            }
+            const step = powByTemp * templateNumber;
+            stepCandidates.push(step);
+            // Early termination for performance
+            if (step >= maxValueStep) {
+                return stepCandidates;
+            }
+        }
+    }
+    return stepCandidates;
+}
 
 /**
  * Generated bundle index. Do not edit.