@libs-ui/utils 0.2.283 → 0.2.285

package/esm2022/get-smart-axis-scale.mjs

@@ -1,6 +1,4 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { isNil } from "./helpers";
-// Constants for better maintainability
 const DEFAULT_MIN_TICK_COUNT = 5;
 const DEFAULT_MAX_TICK_COUNT = 10;
 const MIN_DISTANCE_TO_ZERO = 3;
@@ -8,144 +6,78 @@ 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
+ * 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
  *
- * @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} 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
  *
- * @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
+ * @example
+ * ```typescript
+ * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });
+ * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }
+ * ```
  */
-export const getSmartAxisScale = (maxData, options) => {
-    // Input validation - fail fast approach
+export const getSmartAxisScale = (originalMaxData, options) => {
+    let maxData = originalMaxData;
     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)) {
+    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) {
-            adjustedMaxData = -1;
+            maxData = -1;
         }
-        // Add negative step candidates
-        if (stepCandidates) {
-            stepCandidates.unshift(...stepCandidates.map(item => -item));
+        if (maxData <= 0) {
+            rangeDistance = options.minNegative;
         }
-        if (adjustedMaxData <= 0) {
-            distanceToZero = minNegative;
+        if (rangeDistance > NEGATIVE_THRESHOLD) {
+            rangeDistance = FALLBACK_NEGATIVE_VALUE;
         }
-        if (distanceToZero > NEGATIVE_THRESHOLD) {
-            distanceToZero = FALLBACK_NEGATIVE_VALUE;
-        }
-        if (adjustedMaxData > 0) {
-            distanceToZero = adjustedMaxData + Math.abs(minNegative);
-            reverse = -1;
+        if (maxData > 0) {
+            rangeDistance = maxData + Math.abs(options.minNegative);
+            scaleDirection = -1;
         }
     }
-    if (Math.abs(distanceToZero) < MIN_DISTANCE_TO_ZERO) {
-        distanceToZero = MIN_DISTANCE_TO_ZERO;
+    if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {
+        rangeDistance = 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;
+    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 = adjustedMaxData <= 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 && 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;
+        if (tickCount >= minTickCount && tickCount <= maxTickCount) {
+            if (maxData < maxValue) {
+                if (options?.acceptNegative) {
+                    let tick = 1;
+                    while (!isNil(options.minNegative) && tick <= tickCount && minValue >= options.minNegative) {
+                        minValue = tick * step;
+                        tick++;
+                    }
+                }
+                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,
+                    min: minValue,
+                    tickAmount: tickCount
+                };
             }
-            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++;
-        }
-    }
-    return minValue;
-}
-/**
- * Calculates fallback scale when no optimal scale is found
- */
-function calculateFallbackScale(distanceToZero, minTickCount) {
-    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;
     }
@@ -155,32 +87,88 @@ function calculateFallbackScale(distanceToZero, minTickCount) {
         min: 0,
         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();
 /**
- * Generates step candidates with performance optimizations
+ * 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
  */
-function generateStepCandidates(maxData, minStep, minNegative, acceptStepIsTypeFloat) {
-    const stepCandidates = [];
+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;
-    // Pre-populate power cache for better performance
-    for (let powNumber = 0; powNumber < MAX_POW_NUMBER; powNumber++) {
+    // 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 powByTemp = POWER_CACHE.get(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 floatStep = powByTemp * (((templateNumber - 1) * 2 + 1) / 2);
-                stepCandidates.push(floatStep);
+                const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);
+                stepCandidates.push(step);
             }
-            const step = powByTemp * templateNumber;
+            const step = powValue * templateNumber;
             stepCandidates.push(step);
-            // Early termination for performance
+            // Dừng khi step đã đủ lớn
             if (step >= maxValueStep) {
+                checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
                 return stepCandidates;
             }
         }
     }
+    checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
     return stepCandidates;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-smart-axis-scale.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/get-smart-axis-scale.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { isNil } from \"./helpers\";\n\n// Define interfaces for better type safety\ninterface AxisScaleOptions {\n  minTickCount?: number;\n  maxTickCount?: number;\n  stepCandidates?: number[];\n  acceptNegative?: boolean;\n  minNegative?: number;\n  acceptStepIsTypeFloat?: boolean;\n}\n\ninterface AxisScaleResult {\n  stepSize: number;\n  max: number;\n  min: number;\n  tickAmount: number;\n}\n\n// Constants for better maintainability\nconst DEFAULT_MIN_TICK_COUNT = 5;\nconst DEFAULT_MAX_TICK_COUNT = 10;\nconst MIN_DISTANCE_TO_ZERO = 3;\nconst NEGATIVE_THRESHOLD = -5;\nconst FALLBACK_NEGATIVE_VALUE = -4;\nconst MAX_POW_NUMBER = 14;\nconst MAX_TEMPLATE_NUMBER = 10;\n\n// Cache for power calculations - shared across function calls for better performance\nconst POWER_CACHE = new Map<number, number>();\n\n/**\n * Calculates smart axis scale for charts\n * \n * @description This function can throw errors if:\n * - maxData < 0 and acceptNegative is false\n * - minNegative is undefined and acceptNegative is true\n * - maxData < minNegative (only when acceptNegative is true)\n * - minNegative > 0 (only when acceptNegative is true)\n * \n * @throws {Error} Validation errors for invalid input combinations\n * @required Always wrap this function in try-catch and handle exceptions\n * @param maxData - Maximum data value\n * @param options - Configuration options for axis scaling\n * @returns Axis scale configuration\n */\nexport const getSmartAxisScale = (\n  maxData: number, \n  options?: AxisScaleOptions\n): AxisScaleResult => {\n  // Input validation - fail fast approach\n  validateInputs(maxData, options);\n  \n  // Extract and set defaults\n  const {\n    minTickCount = DEFAULT_MIN_TICK_COUNT,\n    maxTickCount = DEFAULT_MAX_TICK_COUNT,\n    stepCandidates = [],\n    acceptNegative = false,\n    minNegative,\n    acceptStepIsTypeFloat = false\n  } = options || {};\n\n  // Generate step candidates if not provided\n  const finalStepCandidates = stepCandidates.length > 0 \n    ? [...stepCandidates]\n    : generateStepCandidates(maxData, minTickCount, minNegative, acceptStepIsTypeFloat);\n\n  // Remove console.log for production code\n  // console.log(`stepCandidates: `, finalStepCandidates);\n\n  // Calculate scale parameters\n  const scaleParams = calculateScaleParams(maxData, acceptNegative, minNegative, finalStepCandidates);\n  \n  // Find optimal scale\n  const optimalScale = findOptimalScale(\n    scaleParams, \n    finalStepCandidates, \n    minTickCount, \n    maxTickCount, \n    options\n  );\n\n  if (optimalScale) {\n    return optimalScale;\n  }\n\n  // Fallback calculation\n  return calculateFallbackScale(scaleParams.distanceToZero, minTickCount);\n};\n\n/**\n * Validates input parameters\n */\nfunction validateInputs(maxData: number, options?: AxisScaleOptions): void {\n  if (maxData < 0 && !options?.acceptNegative) {\n    throw new Error(\"maxData is less than 0 and acceptNegative is false\");\n  }\n  \n  if (options?.acceptNegative) {\n    if (isNil(options.minNegative)) {\n      throw new Error(\"minNegative is required when acceptNegative is true\");\n    }\n    if (maxData < options.minNegative) {\n      throw new Error(\"maxData is less than minNegative\");\n    }\n    if (options.minNegative >= 0) {\n      throw new Error(\"minNegative must be negative\");\n    }\n  }\n}\n\n/**\n * Calculates scale parameters for axis calculation\n */\nfunction calculateScaleParams(\n  maxData: number, \n  acceptNegative: boolean, \n  minNegative?: number, \n  stepCandidates?: number[]\n) {\n  let distanceToZero = maxData;\n  let reverse = 1;\n  let adjustedMaxData = maxData;\n\n  if (acceptNegative && !isNil(minNegative)) {\n    if (maxData === 0) {\n      adjustedMaxData = -1;\n    }\n\n    // Add negative step candidates\n    if (stepCandidates) {\n      stepCandidates.unshift(...stepCandidates.map(item => -item));\n    }\n\n    if (adjustedMaxData <= 0) {\n      distanceToZero = minNegative;\n    }\n    \n    if (distanceToZero > NEGATIVE_THRESHOLD) {\n      distanceToZero = FALLBACK_NEGATIVE_VALUE;\n    }\n    \n    if (adjustedMaxData > 0) {\n      distanceToZero = adjustedMaxData + Math.abs(minNegative);\n      reverse = -1;\n    }\n  }\n\n  if (Math.abs(distanceToZero) < MIN_DISTANCE_TO_ZERO) {\n    distanceToZero = MIN_DISTANCE_TO_ZERO;\n  }\n\n  return { distanceToZero, reverse, adjustedMaxData };\n}\n\n/**\n * Finds optimal scale from step candidates\n */\nfunction findOptimalScale(\n  scaleParams: ReturnType<typeof calculateScaleParams>,\n  stepCandidates: number[],\n  minTickCount: number,\n  maxTickCount: number,\n  options?: AxisScaleOptions\n): AxisScaleResult | null {\n  const { distanceToZero, reverse, adjustedMaxData } = scaleParams;\n\n  for (const step of stepCandidates) {\n    let tickCount = Math.abs(Math.ceil(distanceToZero / step)) + (reverse === -1 ? 2 : 1);\n    let maxValue = adjustedMaxData <= 0 ? 0 : step * tickCount * reverse;\n    let minValue = 0;\n\n    if (tickCount >= minTickCount && tickCount <= maxTickCount && adjustedMaxData < maxValue) {\n      if (options?.acceptNegative) {\n        minValue = calculateMinValue(step, tickCount, options.minNegative);\n      }\n      \n      // Adjust tick count based on distance calculation\n      const distanceCheck = distanceToZero - (tickCount - 1) * step;\n      if (distanceCheck < -1 * (step / 4)) {\n        tickCount -= 1;\n      }\n      \n      maxValue = (step * tickCount * reverse) - (minValue * reverse);\n      \n      return {\n        stepSize: Math.abs(step),\n        max: maxValue,\n        min: minValue,\n        tickAmount: tickCount\n      };\n    }\n  }\n\n  return null;\n}\n\n/**\n * Calculates minimum value for negative acceptance\n */\nfunction calculateMinValue(step: number, tickCount: number, minNegative?: number): number {\n  let minValue = 0;\n  \n  if (!isNil(minNegative)) {\n    let tick = 1;\n    while (tick <= tickCount && minValue >= minNegative) {\n      minValue = tick * step;\n      tick++;\n    }\n  }\n  \n  return minValue;\n}\n\n/**\n * Calculates fallback scale when no optimal scale is found\n */\nfunction calculateFallbackScale(distanceToZero: number, minTickCount: number): AxisScaleResult {\n  let step = Math.ceil(distanceToZero / minTickCount) || 1;\n  let maxValue = step * minTickCount;\n  \n  if (distanceToZero === maxValue) {\n    step = step + Math.ceil(step / 10);\n    maxValue = step * minTickCount;\n  }\n  \n  return {\n    stepSize: Math.abs(step),\n    max: maxValue,\n    min: 0,\n    tickAmount: minTickCount\n  };\n}\n\n/**\n * Generates step candidates with performance optimizations\n */\nfunction generateStepCandidates(\n  maxData: number, \n  minStep: number, \n  minNegative?: number, \n  acceptStepIsTypeFloat?: boolean\n): number[] {\n  const stepCandidates: number[] = [];\n  const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;\n\n  // Pre-populate power cache for better performance\n  for (let powNumber = 0; powNumber < MAX_POW_NUMBER; powNumber++) {\n    if (!POWER_CACHE.has(powNumber)) {\n      POWER_CACHE.set(powNumber, Math.pow(10, powNumber));\n    }\n\n    const powByTemp = POWER_CACHE.get(powNumber)!;\n\n    for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {\n      if (acceptStepIsTypeFloat) {\n        const floatStep = powByTemp * (((templateNumber - 1) * 2 + 1) / 2);\n        stepCandidates.push(floatStep);\n      }\n      \n      const step = powByTemp * templateNumber;\n      stepCandidates.push(step);\n      \n      // Early termination for performance\n      if (step >= maxValueStep) {\n        return stepCandidates;\n      }\n    }\n  }\n\n  return stepCandidates;\n}"]}
+};
+/**
+ * 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");
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-smart-axis-scale.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/get-smart-axis-scale.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNil } from \"./helpers\";\nconst DEFAULT_MIN_TICK_COUNT = 5;\nconst DEFAULT_MAX_TICK_COUNT = 10;\nconst MIN_DISTANCE_TO_ZERO = 3;\nconst NEGATIVE_THRESHOLD = -5;\nconst FALLBACK_NEGATIVE_VALUE = -4;\nconst MAX_POW_NUMBER = 14;\nconst MAX_TEMPLATE_NUMBER = 10;\n\n// ✅ Thêm interfaces để tăng cường type safety\ninterface AxisScaleOptions {\n  minTickCount?: number; // Số lượng tick tối thiểu\n  maxTickCount?: number; // Số lượng tick tối đa\n  stepCandidates?: number[]; // Danh sách các step candidates tùy chỉnh\n  acceptNegative?: boolean; // Có chấp nhận giá trị âm không\n  minNegative?: number; // Giá trị âm tối thiểu\n  acceptStepIsTypeFloat?: boolean; // Có chấp nhận step là số thập phân không\n}\n\ninterface AxisScaleResult {\n  stepSize: number; // Kích thước bước\n  max: number; // Giá trị tối đa của trục\n  min: number; // Giá trị tối thiểu của trục\n  tickAmount: number; // Số lượng tick\n}\n\n/**\n * Tính toán smart axis scale cho biểu đồ\n * \n * @param maxData - Giá trị tối đa của dữ liệu\n * @param options - Các tùy chọn cấu hình axis scale\n * @returns Cấu hình axis scale bao gồm stepSize, max, min, tickAmount\n * \n * @throws {Error} INVALID_NEGATIVE_DATA - khi maxData < 0 mà acceptNegative = false\n * @throws {Error} MISSING_MIN_NEGATIVE - khi acceptNegative = true nhưng thiếu minNegative\n * @throws {Error} INVALID_RANGE - khi maxData < minNegative\n * @throws {Error} INVALID_MIN_NEGATIVE - khi minNegative >= 0\n * \n * @example\n * ```typescript\n * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });\n * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }\n * ```\n */\nexport const getSmartAxisScale = (originalMaxData: number, options?: AxisScaleOptions): AxisScaleResult => {\n  let maxData = originalMaxData;\n  \n  validateInputs(maxData, options);\n  const minTickCount = options?.minTickCount || DEFAULT_MIN_TICK_COUNT;\n  const maxTickCount = options?.maxTickCount || DEFAULT_MAX_TICK_COUNT;\n  \n  let scaleDirection = 1;\n  let rangeDistance = maxData;\n  \n  \n  if (options?.acceptNegative && !isNil(options.minNegative)) {\n    if (maxData === 0) {\n      maxData = -1;\n    }\n    if (maxData <= 0) {\n      rangeDistance = options.minNegative;\n    }\n    if (rangeDistance > NEGATIVE_THRESHOLD) {\n      rangeDistance = FALLBACK_NEGATIVE_VALUE;\n    }\n    if (maxData > 0) {\n      rangeDistance = maxData + Math.abs(options.minNegative);\n      scaleDirection = -1;\n    }\n  }\n  if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {\n    rangeDistance = MIN_DISTANCE_TO_ZERO;\n  }\n  \n  const stepCandidates = getStepCandidates(\n    maxData,\n    minTickCount,\n    options?.minNegative || 0,\n    options?.acceptStepIsTypeFloat,\n    options?.stepCandidates,\n    options?.acceptNegative\n  );\n  for (const step of stepCandidates) {\n    let tickCount = Math.abs(Math.ceil(rangeDistance / step)) + (scaleDirection === -1 ? 2 : 1);\n    let maxValue = maxData <= 0 ? 0 : step * tickCount * scaleDirection;\n    let minValue = 0;\n\n    if (tickCount >= minTickCount && tickCount <= maxTickCount) {\n      if (maxData < maxValue) {\n        if (options?.acceptNegative) {\n          let tick = 1;\n          while (!isNil(options.minNegative) && tick <= tickCount && minValue >= options.minNegative) {\n            minValue = tick * step;\n            tick++;\n          }\n        }\n        const maxValuePositive = maxValue - Math.abs(minValue);\n        tickCount = maxValuePositive - originalMaxData > Math.abs(step) && tickCount - 1 >= minTickCount ? tickCount - 1 : tickCount;\n\n        maxValue = (step * tickCount * scaleDirection) - (minValue * scaleDirection);\n        return {\n          stepSize: Math.abs(step),\n          max: maxValue,\n          min: minValue,\n          tickAmount: tickCount\n        };\n      }\n    }\n  }\n\n  let step = Math.ceil(rangeDistance / minTickCount) || 1;\n  let maxValue = step * minTickCount;\n  if (rangeDistance === maxValue) {\n    step = step + Math.ceil(step / 10);\n    maxValue = step * minTickCount;\n  }\n  return {\n    stepSize: Math.abs(step),\n    max: maxValue,\n    min: 0,\n    tickAmount: minTickCount\n  };\n}\n\n// Cache cho các giá trị lũy thừa 10 để tối ưu hiệu suất\nconst POWER_CACHE = new Map<number, number>();\n\n/**\n * Tạo danh sách các step candidates cho việc tính toán scale\n * @param maxData - Giá trị dữ liệu tối đa\n * @param minStep - Số bước tối thiểu\n * @param minNegative - Giá trị âm tối thiểu\n * @param acceptStepIsTypeFloat - Có chấp nhận step thập phân không\n * @param stepCandidatesByOptions - Step candidates do người dùng cung cấp\n * @param includeNegativeSteps - Có bao gồm các step âm không\n * @returns Danh sách các step candidates\n */\nconst getStepCandidates = (\n  maxData: number,\n  minStep: number,\n  minNegative: number,\n  acceptStepIsTypeFloat = false,\n  stepCandidatesByOptions?: number[],\n  includeNegativeSteps = false\n): number[] => {\n  // Nếu có step candidates tùy chỉnh, sử dụng chúng\n  if(stepCandidatesByOptions && stepCandidatesByOptions.length > 0){\n    return stepCandidatesByOptions;\n  }\n  \n  const stepCandidates= new Array<number>();\n  const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;\n\n  // Tạo step candidates dựa trên lũy thừa của 10\n  for (let powNumber = 0; powNumber <= MAX_POW_NUMBER; powNumber++) {\n    // Sử dụng cache để tối ưu hiệu suất\n    if(!POWER_CACHE.has(powNumber)){\n      POWER_CACHE.set(powNumber,Math.pow(10,powNumber));\n    }\n    const powValue = POWER_CACHE.get(powNumber) as number;\n    \n    for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {\n      // Thêm step thập phân nếu được chấp nhận\n      if (acceptStepIsTypeFloat) {\n        const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);\n        stepCandidates.push(step);\n      }\n      \n      const step = powValue * templateNumber;\n      stepCandidates.push(step);\n\n      // Dừng khi step đã đủ lớn\n      if (step >= maxValueStep) {\n        checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);\n        return stepCandidates;\n      }\n    }\n  }\n  \n  checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);\n  return stepCandidates;\n}\n\n/**\n * Kiểm tra và thêm các step âm vào danh sách candidates nếu cần\n * @param stepCandidates - Danh sách step candidates hiện tại\n * @param acceptNegative - Có chấp nhận giá trị âm không\n * @param minNegative - Giá trị âm tối thiểu\n */\nconst checkAndSetNegativeSteps = (stepCandidates: number[], acceptNegative: boolean, minNegative: number): void => {\n  if (acceptNegative && minNegative < 0) {\n    // Tạo các step âm và thêm vào đầu danh sách\n    const negativeSteps = [...stepCandidates].map(step => -step);\n    stepCandidates.unshift(...negativeSteps);\n  }\n} \n\n/**\n * Kiểm tra tính hợp lệ của các tham số đầu vào\n * @param maxData - Giá trị dữ liệu tối đa\n * @param options - Các tùy chọn cấu hình\n * @throws {Error} Khi các tham số không hợp lệ\n */\nconst validateInputs = (maxData: number, options?: AxisScaleOptions): void => {\n  // Kiểm tra maxData âm khi không chấp nhận giá trị âm\n  if (maxData < 0 && !options?.acceptNegative) {\n    throw new Error(\"maxData is less than 0 and acceptNegative is false\");\n  }\n  \n  if (options?.acceptNegative) {\n    // Kiểm tra minNegative có được cung cấp không\n    if (isNil(options.minNegative)) {\n      throw new Error(\"minNegative is required when acceptNegative is true\");\n    }\n\n    // Kiểm tra maxData phải >= minNegative\n    if (maxData < options.minNegative) {\n      throw new Error(\"maxData is less than minNegative\");\n    }\n\n    // Kiểm tra minNegative phải là số âm\n    if (options.minNegative >= 0) {\n      throw new Error(\"minNegative must be negative\");\n    }\n  }\n} "]}