@libs-ui/utils 0.2.282 → 0.2.284

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,66 +2511,60 @@ const convertUrlToFile = (url, fileName) => {
     });
 };
 
+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;
 /**
- * Hàm có thể trả về lỗi nếu:
- * - maxData < 0 và acceptNegative là false
- * - minNegative là undefined và acceptNegative là true
- * - maxData < minNegative (chỉ xảy ra khi acceptNegative là true)
- * - minNegative > 0 (chỉ xảy ra khi acceptNegative là true)
- * @throws {Error}
- * @required luôn đặt hàm này trong try catch và xử lý ngoại lệ
- * @hint Truyền 3 tham số: min,max và tick
+ * Tính toán smart axis scale cho biểu đồ
+ *
+ * @param maxData - Giá trị tối đa của dữ liệu
+ * @param options - Các tùy chọn cấu hình axis scale
+ * @returns Cấu hình axis scale bao gồm stepSize, max, min, tickAmount
+ *
+ * @throws {Error} INVALID_NEGATIVE_DATA - khi maxData < 0 mà acceptNegative = false
+ * @throws {Error} MISSING_MIN_NEGATIVE - khi acceptNegative = true nhưng thiếu minNegative
+ * @throws {Error} INVALID_RANGE - khi maxData < minNegative
+ * @throws {Error} INVALID_MIN_NEGATIVE - khi minNegative >= 0
+ *
+ * @example
+ * ```typescript
+ * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });
+ * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }
+ * ```
  */
-const getSmartAxisScale = (maxData, options) => {
-    const minTickCount = options?.minTickCount || 5;
-    const maxTickCount = options?.maxTickCount || 10;
-    const stepCandidatesDefault = new Array();
-    const loopStepCandidates = Array.from({ length: 10 }, (_, index) => Math.pow(10, index)).findIndex(item => item > Math.abs(Math.max(maxData, Math.abs(options?.minNegative || 0)))) + 1;
-    Array.from({ length: loopStepCandidates }, (_, index) => {
-        for (let templateNumber = 1; templateNumber < 10; templateNumber++) {
-            if (options?.acceptStepIsTypeFloat) {
-                stepCandidatesDefault.push(Math.pow(10, index) * (((templateNumber - 1) * 2 + 1) / 2));
-            }
-            stepCandidatesDefault.push(Math.pow(10, index) * templateNumber);
-        }
-    });
-    const stepCandidates = options?.stepCandidates || stepCandidatesDefault;
-    let distanceToZero = maxData;
-    let reverse = 1;
-    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");
-        }
+const getSmartAxisScale = (originalMaxData, options) => {
+    let maxData = originalMaxData;
+    validateInputs(maxData, options);
+    const minTickCount = options?.minTickCount || DEFAULT_MIN_TICK_COUNT;
+    const maxTickCount = options?.maxTickCount || DEFAULT_MAX_TICK_COUNT;
+    let scaleDirection = 1;
+    let rangeDistance = maxData;
+    if (options?.acceptNegative && !isNil(options.minNegative)) {
         if (maxData === 0) {
             maxData = -1;
         }
-        stepCandidates.unshift(...stepCandidates.map(item => item * -1));
         if (maxData <= 0) {
-            distanceToZero = options.minNegative;
+            rangeDistance = options.minNegative;
         }
-        if (distanceToZero > -5) {
-            distanceToZero = -4;
+        if (rangeDistance > NEGATIVE_THRESHOLD) {
+            rangeDistance = FALLBACK_NEGATIVE_VALUE;
         }
         if (maxData > 0) {
-            distanceToZero = maxData + Math.abs(options.minNegative);
-            reverse = -1;
+            rangeDistance = maxData + Math.abs(options.minNegative);
+            scaleDirection = -1;
         }
     }
-    if (Math.abs(distanceToZero) < 3) {
-        distanceToZero = 3;
+    if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {
+        rangeDistance = MIN_DISTANCE_TO_ZERO;
     }
+    const stepCandidates = getStepCandidates(maxData, minTickCount, options?.minNegative || 0, options?.acceptStepIsTypeFloat, options?.stepCandidates, options?.acceptNegative);
     for (const step of stepCandidates) {
-        let tickCount = Math.abs(Math.ceil(distanceToZero / step)) + (reverse === -1 ? 2 : 1);
-        let maxValue = maxData <= 0 ? 0 : step * tickCount * reverse;
+        let tickCount = Math.abs(Math.ceil(rangeDistance / step)) + (scaleDirection === -1 ? 2 : 1);
+        let maxValue = maxData <= 0 ? 0 : step * tickCount * scaleDirection;
         let minValue = 0;
         if (tickCount >= minTickCount && tickCount <= maxTickCount) {
             if (maxData < maxValue) {
@@ -2517,8 +2575,9 @@ const getSmartAxisScale = (maxData, options) => {
                         tick++;
                     }
                 }
-                tickCount = distanceToZero - (tickCount - 1) * step < -1 * (step / 4) ? tickCount - 1 : tickCount;
-                maxValue = (step * tickCount * reverse) - (minValue * reverse);
+                const maxValuePositive = maxValue - Math.abs(minValue);
+                tickCount = maxValuePositive - originalMaxData > Math.abs(step) && tickCount - 1 >= minTickCount ? tickCount - 1 : tickCount;
+                maxValue = (step * tickCount * scaleDirection) - (minValue * scaleDirection);
                 return {
                     stepSize: Math.abs(step),
                     max: maxValue,
@@ -2528,9 +2587,9 @@ const getSmartAxisScale = (maxData, options) => {
             }
         }
     }
-    let step = Math.ceil(distanceToZero / minTickCount) || 1;
+    let step = Math.ceil(rangeDistance / minTickCount) || 1;
     let maxValue = step * minTickCount;
-    if (distanceToZero === maxValue) {
+    if (rangeDistance === maxValue) {
         step = step + Math.ceil(step / 10);
         maxValue = step * minTickCount;
     }
@@ -2541,6 +2600,89 @@ const getSmartAxisScale = (maxData, options) => {
         tickAmount: minTickCount
     };
 };
+// Cache cho các giá trị lũy thừa 10 để tối ưu hiệu suất
+const POWER_CACHE = new Map();
+/**
+ * Tạo danh sách các step candidates cho việc tính toán scale
+ * @param maxData - Giá trị dữ liệu tối đa
+ * @param minStep - Số bước tối thiểu
+ * @param minNegative - Giá trị âm tối thiểu
+ * @param acceptStepIsTypeFloat - Có chấp nhận step thập phân không
+ * @param stepCandidatesByOptions - Step candidates do người dùng cung cấp
+ * @param includeNegativeSteps - Có bao gồm các step âm không
+ * @returns Danh sách các step candidates
+ */
+const getStepCandidates = (maxData, minStep, minNegative, acceptStepIsTypeFloat = false, stepCandidatesByOptions, includeNegativeSteps = false) => {
+    // Nếu có step candidates tùy chỉnh, sử dụng chúng
+    if (stepCandidatesByOptions && stepCandidatesByOptions.length > 0) {
+        return stepCandidatesByOptions;
+    }
+    const stepCandidates = new Array();
+    const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;
+    // Tạo step candidates dựa trên lũy thừa của 10
+    for (let powNumber = 0; powNumber <= MAX_POW_NUMBER; powNumber++) {
+        // Sử dụng cache để tối ưu hiệu suất
+        if (!POWER_CACHE.has(powNumber)) {
+            POWER_CACHE.set(powNumber, Math.pow(10, powNumber));
+        }
+        const powValue = POWER_CACHE.get(powNumber);
+        for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {
+            // Thêm step thập phân nếu được chấp nhận
+            if (acceptStepIsTypeFloat) {
+                const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);
+                stepCandidates.push(step);
+            }
+            const step = powValue * templateNumber;
+            stepCandidates.push(step);
+            // Dừng khi step đã đủ lớn
+            if (step >= maxValueStep) {
+                checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
+                return stepCandidates;
+            }
+        }
+    }
+    checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
+    return stepCandidates;
+};
+/**
+ * Kiểm tra và thêm các step âm vào danh sách candidates nếu cần
+ * @param stepCandidates - Danh sách step candidates hiện tại
+ * @param acceptNegative - Có chấp nhận giá trị âm không
+ * @param minNegative - Giá trị âm tối thiểu
+ */
+const checkAndSetNegativeSteps = (stepCandidates, acceptNegative, minNegative) => {
+    if (acceptNegative && minNegative < 0) {
+        // Tạo các step âm và thêm vào đầu danh sách
+        const negativeSteps = [...stepCandidates].map(step => -step);
+        stepCandidates.unshift(...negativeSteps);
+    }
+};
+/**
+ * Kiểm tra tính hợp lệ của các tham số đầu vào
+ * @param maxData - Giá trị dữ liệu tối đa
+ * @param options - Các tùy chọn cấu hình
+ * @throws {Error} Khi các tham số không hợp lệ
+ */
+const validateInputs = (maxData, options) => {
+    // Kiểm tra maxData âm khi không chấp nhận giá trị âm
+    if (maxData < 0 && !options?.acceptNegative) {
+        throw new Error("maxData is less than 0 and acceptNegative is false");
+    }
+    if (options?.acceptNegative) {
+        // Kiểm tra minNegative có được cung cấp không
+        if (isNil(options.minNegative)) {
+            throw new Error("minNegative is required when acceptNegative is true");
+        }
+        // Kiểm tra maxData phải >= minNegative
+        if (maxData < options.minNegative) {
+            throw new Error("maxData is less than minNegative");
+        }
+        // Kiểm tra minNegative phải là số âm
+        if (options.minNegative >= 0) {
+            throw new Error("minNegative must be negative");
+        }
+    }
+};
 
 /**
  * Generated bundle index. Do not edit.