@canvas-components/utils 0.2.1 → 0.2.2

package/dist/index.js

@@ -265,6 +265,161 @@ function getValueByDataIndex(source, dataIndex) {
   return current;
 }
 
+// src/date/index.ts
+var DATE_TIME_FORMAT_TOKEN = /Y{2,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|m{1,2}|s{1,2}|S{1,3}|A|a/;
+var FORMAT_TOKEN = /\[[^\]]*\]|YYYY|MMMM|MMM|dddd|ddd|SSS|YY|MM|DD|dd|HH|hh|mm|ss|SS|M|D|d|H|h|m|s|S|A|a/g;
+var ZH_WEEKDAYS = [
+  "\u661F\u671F\u65E5",
+  "\u661F\u671F\u4E00",
+  "\u661F\u671F\u4E8C",
+  "\u661F\u671F\u4E09",
+  "\u661F\u671F\u56DB",
+  "\u661F\u671F\u4E94",
+  "\u661F\u671F\u516D"
+];
+var ZH_WEEKDAYS_SHORT = [
+  "\u5468\u65E5",
+  "\u5468\u4E00",
+  "\u5468\u4E8C",
+  "\u5468\u4E09",
+  "\u5468\u56DB",
+  "\u5468\u4E94",
+  "\u5468\u516D"
+];
+var EN_WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+var EN_MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function resolveDateValue(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value !== "string" && typeof value !== "number") {
+    return null;
+  }
+  if (typeof value === "string") {
+    const localDate = resolveLocalDateString(value);
+    if (localDate) {
+      return localDate;
+    }
+  }
+  const resolved = new Date(value);
+  return Number.isNaN(resolved.getTime()) ? null : resolved;
+}
+function isDateTimeFormatPattern(pattern) {
+  return DATE_TIME_FORMAT_TOKEN.test(pattern.replace(/\[[^\]]*\]/g, ""));
+}
+function formatDateTimeValue(value, pattern, locale = "zh-cn") {
+  const date = resolveDateValue(value);
+  const normalizedPattern = pattern.trim();
+  if (!date || !normalizedPattern) {
+    return null;
+  }
+  const year = date.getFullYear();
+  const monthIndex = date.getMonth();
+  const month = monthIndex + 1;
+  const day = date.getDate();
+  const weekdayIndex = date.getDay();
+  const hour = date.getHours();
+  const hour12 = hour % 12 || 12;
+  const minute = date.getMinutes();
+  const second = date.getSeconds();
+  const millisecond = date.getMilliseconds();
+  const chinese = locale.toLowerCase().startsWith("zh");
+  const marker = hour >= 12 ? chinese ? "\u4E0B\u5348" : "PM" : chinese ? "\u4E0A\u5348" : "AM";
+  const weekday = chinese ? ZH_WEEKDAYS[weekdayIndex] ?? "" : EN_WEEKDAYS[weekdayIndex] ?? "";
+  const weekdayShort = chinese ? ZH_WEEKDAYS_SHORT[weekdayIndex] ?? "" : weekday.slice(0, 3);
+  const monthName = chinese ? `${month}\u6708` : EN_MONTHS[monthIndex] ?? "";
+  const values = {
+    YYYY: String(year).padStart(4, "0"),
+    YY: String(year).slice(-2),
+    M: String(month),
+    MM: padNumber(month),
+    MMM: chinese ? monthName : monthName.slice(0, 3),
+    MMMM: monthName,
+    D: String(day),
+    DD: padNumber(day),
+    d: String(weekdayIndex),
+    dd: chinese ? weekdayShort.slice(-1) : weekday.slice(0, 2),
+    ddd: weekdayShort,
+    dddd: weekday,
+    H: String(hour),
+    HH: padNumber(hour),
+    h: String(hour12),
+    hh: padNumber(hour12),
+    m: String(minute),
+    mm: padNumber(minute),
+    s: String(second),
+    ss: padNumber(second),
+    S: String(Math.floor(millisecond / 100)),
+    SS: String(Math.floor(millisecond / 10)).padStart(2, "0"),
+    SSS: String(millisecond).padStart(3, "0"),
+    A: marker,
+    a: marker.toLowerCase()
+  };
+  return normalizedPattern.replace(
+    FORMAT_TOKEN,
+    (token) => token.startsWith("[") && token.endsWith("]") ? token.slice(1, -1) : values[token] ?? token
+  );
+}
+function padNumber(value) {
+  return String(value).padStart(2, "0");
+}
+function resolveLocalDateString(value) {
+  const match = value.trim().match(
+    /^(\d{4})[-/](\d{1,2})[-/](\d{1,2})(?:[ T](\d{1,2}):?(\d{2})?(?::?(\d{2}))?(?:\.(\d{1,3}))?)?$/
+  );
+  if (!match) {
+    return null;
+  }
+  const [
+    ,
+    yearText,
+    monthText,
+    dayText,
+    hourText,
+    minuteText,
+    secondText,
+    millisecondText
+  ] = match;
+  const year = Number(yearText);
+  const monthIndex = Number(monthText) - 1;
+  const day = Number(dayText);
+  const hour = Number(hourText ?? 0);
+  const minute = Number(minuteText ?? 0);
+  const second = Number(secondText ?? 0);
+  const millisecond = Number((millisecondText ?? "0").padEnd(3, "0"));
+  const resolved = new Date(
+    year,
+    monthIndex,
+    day,
+    hour,
+    minute,
+    second,
+    millisecond
+  );
+  return resolved.getFullYear() === year && resolved.getMonth() === monthIndex && resolved.getDate() === day && resolved.getHours() === hour && resolved.getMinutes() === minute && resolved.getSeconds() === second ? resolved : null;
+}
+
 // src/geometry/index.ts
 function clamp(value, minimum, maximum) {
   return Math.min(Math.max(value, minimum), maximum);
@@ -273,6 +428,387 @@ function isPointInRect(x, y, rect) {
   return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
 }
 
-export { buildCsvContent, buildTxtContent, clamp, copyJson, copyRows, copyText, copyTextSync, downloadJsonFile, exportTableToCsv, exportTableToTxt, exportTableToXlsx, formatRowsForClipboard, getValueByDataIndex, isPointInRect, isSameDataIndex, mapRowsToExportRecords, serializeCsvRows, stringifyDataIndex };
+// src/number/precise.ts
+function addPreciseNumbers(left, right) {
+  const leftParts = parseDecimal(left);
+  const rightParts = parseDecimal(right);
+  if (!leftParts || !rightParts) return null;
+  return formatDecimal(addParts(leftParts, rightParts));
+}
+function sumPreciseNumbers(values) {
+  let result = { coefficient: 0n, scale: 0 };
+  let count = 0;
+  for (const value of values) {
+    const parts = parseDecimal(value);
+    if (!parts) continue;
+    result = addParts(result, parts);
+    count += 1;
+  }
+  return count === 0 ? null : formatDecimal(result);
+}
+function comparePreciseNumbers(left, right) {
+  const leftParts = parseDecimal(left);
+  const rightParts = parseDecimal(right);
+  if (!leftParts || !rightParts) return null;
+  const scale = Math.max(leftParts.scale, rightParts.scale);
+  const leftValue = leftParts.coefficient * 10n ** BigInt(scale - leftParts.scale);
+  const rightValue = rightParts.coefficient * 10n ** BigInt(scale - rightParts.scale);
+  return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+}
+function dividePreciseNumber(value, divisor, precision = 20) {
+  const valueParts = parseDecimal(value);
+  const divisorParts = parseDecimal(divisor);
+  if (!valueParts || !divisorParts || divisorParts.coefficient === 0n)
+    return null;
+  const places = normalizePrecision(precision);
+  const scale = places + divisorParts.scale - valueParts.scale;
+  const factor = 10n ** BigInt(Math.max(scale, 0));
+  const numerator = valueParts.coefficient * factor;
+  const denominator = divisorParts.coefficient;
+  const quotient = numerator / denominator;
+  const remainder = numerator % denominator;
+  const rounded = remainder === 0n ? quotient : quotient + (numerator < 0n === denominator < 0n ? 1n : -1n) * (abs(remainder) * 2n >= abs(denominator) ? 1n : 0n);
+  return formatDecimal({ coefficient: rounded, scale: Math.max(places, 0) });
+}
+function roundPreciseNumber(value, precision, mode = "round") {
+  const parts = parseDecimal(value);
+  if (!parts) return null;
+  const places = normalizePrecision(precision);
+  if (parts.scale <= places)
+    return formatDecimal(
+      {
+        ...parts,
+        coefficient: parts.coefficient * 10n ** BigInt(places - parts.scale)
+      },
+      places
+    );
+  const factor = 10n ** BigInt(parts.scale - places);
+  let quotient = parts.coefficient / factor;
+  const remainder = parts.coefficient % factor;
+  if (remainder !== 0n) {
+    const isNegative = parts.coefficient < 0n;
+    const direction = isNegative ? -1n : 1n;
+    if (mode === "ceil" && !isNegative || mode === "floor" && isNegative || mode === "round" && abs(remainder) * 2n >= factor) {
+      quotient += direction;
+    }
+  }
+  return formatDecimal({ coefficient: quotient, scale: places }, places);
+}
+function formatPreciseNumber(value, precision, preserveTrailingZeros = false) {
+  const parts = parseDecimal(value);
+  if (!parts) return null;
+  return precision == null ? formatDecimal(parts, preserveTrailingZeros ? parts.scale : 0) : roundPreciseNumber(value, precision);
+}
+function parseDecimal(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return null;
+    value = String(value);
+  } else if (typeof value === "bigint") {
+    return { coefficient: value, scale: 0 };
+  }
+  const match = value.trim().match(/^([+-]?)(\d+)(?:\.(\d*))?(?:e([+-]?\d+))?$/i);
+  if (!match) return null;
+  const fraction = match[3] ?? "";
+  const exponent = Number(match[4] ?? 0);
+  if (!Number.isSafeInteger(exponent)) return null;
+  const scale = fraction.length - exponent;
+  const coefficient = BigInt(
+    `${match[1] === "-" ? "-" : ""}${match[2]}${fraction}`
+  );
+  return scale >= 0 ? { coefficient, scale } : { coefficient: coefficient * 10n ** BigInt(-scale), scale: 0 };
+}
+function addParts(left, right) {
+  const scale = Math.max(left.scale, right.scale);
+  return {
+    coefficient: left.coefficient * 10n ** BigInt(scale - left.scale) + right.coefficient * 10n ** BigInt(scale - right.scale),
+    scale
+  };
+}
+function formatDecimal(parts, minimumScale = 0) {
+  const negative = parts.coefficient < 0n;
+  const digits = abs(parts.coefficient).toString().padStart(parts.scale + 1, "0");
+  const scale = Math.max(parts.scale, minimumScale);
+  const padded = digits.padStart(scale + 1, "0");
+  const integer = padded.slice(0, -scale || void 0) || "0";
+  const fraction = scale > 0 ? padded.slice(-scale).padEnd(scale, "0") : "";
+  const displayFraction = minimumScale > 0 ? fraction : fraction.replace(/0+$/, "");
+  return `${negative ? "-" : ""}${integer}${displayFraction ? `.${displayFraction}` : ""}`;
+}
+function normalizePrecision(value) {
+  return Math.min(
+    100,
+    Math.max(0, Math.trunc(Number.isFinite(value) ? value : 20))
+  );
+}
+function abs(value) {
+  return value < 0n ? -value : value;
+}
+
+// src/number/index.ts
+var COMMON_CHINESE_DIGITS = [
+  "\u96F6",
+  "\u4E00",
+  "\u4E8C",
+  "\u4E09",
+  "\u56DB",
+  "\u4E94",
+  "\u516D",
+  "\u4E03",
+  "\u516B",
+  "\u4E5D"
+];
+var FINANCIAL_CHINESE_DIGITS = [
+  "\u96F6",
+  "\u58F9",
+  "\u8D30",
+  "\u53C1",
+  "\u8086",
+  "\u4F0D",
+  "\u9646",
+  "\u67D2",
+  "\u634C",
+  "\u7396"
+];
+var COMMON_SECTION_UNITS = ["", "\u5341", "\u767E", "\u5343"];
+var FINANCIAL_SECTION_UNITS = ["", "\u62FE", "\u4F70", "\u4EDF"];
+var LARGE_CHINESE_UNITS = ["", "\u4E07", "\u4EBF", "\u5146", "\u4EAC"];
+var CHINESE_DIGIT_VALUES = {
+  \u96F6: 0,
+  "\u3007": 0,
+  \u4E00: 1,
+  \u58F9: 1,
+  \u4E8C: 2,
+  \u8D30: 2,
+  \u8CB3: 2,
+  \u4E24: 2,
+  \u5169: 2,
+  \u4E09: 3,
+  \u53C1: 3,
+  \u53C3: 3,
+  \u56DB: 4,
+  \u8086: 4,
+  \u4E94: 5,
+  \u4F0D: 5,
+  \u516D: 6,
+  \u9646: 6,
+  \u9678: 6,
+  \u4E03: 7,
+  \u67D2: 7,
+  \u516B: 8,
+  \u634C: 8,
+  \u4E5D: 9,
+  \u7396: 9
+};
+var CHINESE_SMALL_UNIT_VALUES = {
+  \u5341: 10,
+  \u62FE: 10,
+  \u767E: 100,
+  \u4F70: 100,
+  \u5343: 1e3,
+  \u4EDF: 1e3
+};
+var CHINESE_LARGE_UNIT_VALUES = {
+  \u4E07: 1e4,
+  \u842C: 1e4,
+  \u4EBF: 1e8,
+  \u5104: 1e8,
+  \u5146: 1e12
+};
+function parseNumberValue(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().replace(/,/g, "");
+  if (!normalized) return null;
+  const numericValue = Number(normalized);
+  return Number.isFinite(numericValue) ? numericValue : null;
+}
+function normalizeDecimalPlaces(decimalPlaces, fallback = 2) {
+  if (typeof decimalPlaces !== "number" || !Number.isFinite(decimalPlaces)) {
+    return fallback;
+  }
+  return Math.min(20, Math.max(Math.trunc(decimalPlaces), 0));
+}
+function formatNumberValue(value, options = {}) {
+  if (value == null || value === "") return "";
+  const numericValue = parseNumberValue(value);
+  if (numericValue == null) return String(value);
+  const separator = resolveThousandsSeparator(options.thousandsSeparator);
+  const decimalPlaces = options.decimalPlaces === "auto" ? void 0 : normalizeDecimalPlaces(options.decimalPlaces);
+  const absoluteText = decimalPlaces == null ? String(Math.abs(numericValue)) : Math.abs(numericValue).toFixed(decimalPlaces);
+  const [integerText = "0", decimalText] = absoluteText.split(".");
+  const formattedInteger = separator ? integerText.replace(/\B(?=(\d{3})+(?!\d))/g, separator) : integerText;
+  const sign = numericValue < 0 ? "-" : "";
+  return `${sign}${options.symbol ?? ""}${formattedInteger}${decimalText ? `.${decimalText}` : ""}`;
+}
+function formatPercentValue(value, decimalPlaces = 2) {
+  const numericValue = parseNumberValue(value);
+  if (numericValue == null) return String(value ?? "");
+  return `${(numericValue * 100).toFixed(normalizeDecimalPlaces(decimalPlaces))}%`;
+}
+function formatScientificValue(value, decimalPlaces = 2) {
+  const numericValue = parseNumberValue(value);
+  if (numericValue == null) return String(value ?? "");
+  const [mantissa, exponentText] = numericValue.toExponential(normalizeDecimalPlaces(decimalPlaces)).split("e");
+  const exponent = Number(exponentText ?? 0);
+  return `${mantissa}E${exponent >= 0 ? "+" : "-"}${String(Math.abs(exponent)).padStart(3, "0")}`;
+}
+function formatCustomNumberPattern(value, pattern) {
+  if (pattern.includes("@") || pattern.includes("\u901A\u7528\u683C\u5F0F")) {
+    return String(value ?? "");
+  }
+  const literalOnly = pattern.match(/^"([^"]*)"$/);
+  if (literalOnly) return literalOnly[1] ?? "";
+  const numericValue = parseNumberValue(value);
+  if (numericValue == null) return String(value ?? "");
+  const percent = pattern.includes("%");
+  const tenThousands = pattern.includes("\u4E07");
+  const decimalPlaces = pattern.match(/\.(0+)/)?.[1]?.length ?? 0;
+  const scaled = numericValue * (percent ? 100 : 1) / (tenThousands ? 1e4 : 1);
+  const symbol = pattern.includes("\xA5") ? "\xA5" : pattern.includes("$") ? "$" : "";
+  if (/e\+/i.test(pattern)) return formatScientificValue(scaled, decimalPlaces);
+  const text = formatNumberValue(scaled, {
+    decimalPlaces,
+    thousandsSeparator: pattern.includes(",") && !tenThousands,
+    symbol
+  });
+  return `${text}${tenThousands ? "\u4E07" : ""}${percent ? "%" : ""}`;
+}
+function formatChineseNumber(value, style = "financial") {
+  const numericValue = parseNumberValue(value) ?? (typeof value === "string" ? parseChineseNumber(value) : null);
+  if (numericValue == null || !Number.isFinite(numericValue)) return null;
+  const negative = numericValue < 0;
+  const absoluteValue = Math.abs(numericValue);
+  const [integerText, decimalText = ""] = toPlainNumberText(absoluteValue).split(".");
+  const digits = style === "financial" ? FINANCIAL_CHINESE_DIGITS : COMMON_CHINESE_DIGITS;
+  const sectionUnits = style === "financial" ? FINANCIAL_SECTION_UNITS : COMMON_SECTION_UNITS;
+  const integerResult = formatChineseInteger(
+    integerText ?? "0",
+    digits,
+    sectionUnits
+  );
+  const decimalResult = decimalText ? `\u70B9${Array.from(decimalText, (digit) => digits[Number(digit)] ?? "").join("")}` : "";
+  return `${negative ? "\u8D1F" : ""}${integerResult}${decimalResult}`;
+}
+function parseChineseNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+  let source = value.trim().replace(/[\s,，]/g, "");
+  if (!source) return null;
+  const negative = source.startsWith("\u8D1F") || source.startsWith("-");
+  if (negative) source = source.slice(1);
+  const [integerSource = "", decimalSource] = source.split(/[点\.]/, 2);
+  if (!integerSource) return null;
+  const integerValue = parseChineseInteger(integerSource);
+  if (integerValue == null) return null;
+  let decimalValue = 0;
+  if (decimalSource) {
+    let scale = 0.1;
+    for (const character of decimalSource) {
+      const digit = resolveChineseDigit(character);
+      if (digit == null) return null;
+      decimalValue += digit * scale;
+      scale /= 10;
+    }
+  }
+  const result = integerValue + decimalValue;
+  return negative ? -result : result;
+}
+function formatChineseInteger(integerText, digits, sectionUnits) {
+  const normalized = integerText.replace(/^0+(?=\d)/, "");
+  if (normalized === "0") return digits[0] ?? "\u96F6";
+  const sections = [];
+  for (let end = normalized.length; end > 0; end -= 4) {
+    sections.push(Number(normalized.slice(Math.max(0, end - 4), end)));
+  }
+  let result = "";
+  let pendingZero = false;
+  for (let index = sections.length - 1; index >= 0; index -= 1) {
+    const section = sections[index] ?? 0;
+    if (section === 0) {
+      if (result) pendingZero = true;
+      continue;
+    }
+    if (result && (pendingZero || section < 1e3)) result += digits[0] ?? "\u96F6";
+    result += formatChineseSection(section, digits, sectionUnits);
+    result += LARGE_CHINESE_UNITS[index] ?? "";
+    pendingZero = false;
+  }
+  return digits === COMMON_CHINESE_DIGITS && result.startsWith("\u4E00\u5341") ? result.slice(1) : result;
+}
+function formatChineseSection(section, digits, sectionUnits) {
+  let result = "";
+  let pendingZero = false;
+  for (let position = 3; position >= 0; position -= 1) {
+    const unitValue = 10 ** position;
+    const digit = Math.floor(section / unitValue) % 10;
+    if (digit === 0) {
+      if (result && section % unitValue !== 0) pendingZero = true;
+      continue;
+    }
+    if (pendingZero) result += digits[0] ?? "\u96F6";
+    result += `${digits[digit] ?? ""}${sectionUnits[position] ?? ""}`;
+    pendingZero = false;
+  }
+  return result;
+}
+function parseChineseInteger(source) {
+  const hasUnit = Array.from(source).some(
+    (character) => character in CHINESE_SMALL_UNIT_VALUES || character in CHINESE_LARGE_UNIT_VALUES
+  );
+  if (!hasUnit) {
+    let text = "";
+    for (const character of source) {
+      const digit2 = resolveChineseDigit(character);
+      if (digit2 == null) return null;
+      text += String(digit2);
+    }
+    return text ? Number(text) : null;
+  }
+  let total = 0;
+  let section = 0;
+  let digit = null;
+  for (const character of source) {
+    const digitValue = resolveChineseDigit(character);
+    if (digitValue != null) {
+      digit = digitValue;
+      continue;
+    }
+    const smallUnit = CHINESE_SMALL_UNIT_VALUES[character];
+    if (smallUnit) {
+      section += (digit ?? 1) * smallUnit;
+      digit = null;
+      continue;
+    }
+    const largeUnit = CHINESE_LARGE_UNIT_VALUES[character];
+    if (largeUnit) {
+      section += digit ?? 0;
+      total += section * largeUnit;
+      section = 0;
+      digit = null;
+      continue;
+    }
+    return null;
+  }
+  return total + section + (digit ?? 0);
+}
+function resolveChineseDigit(character) {
+  if (/\d/.test(character)) return Number(character);
+  return CHINESE_DIGIT_VALUES[character] ?? null;
+}
+function toPlainNumberText(value) {
+  const source = String(value);
+  if (!/[eE]/.test(source)) return source;
+  return value.toLocaleString("en-US", {
+    useGrouping: false,
+    maximumFractionDigits: 20
+  });
+}
+function resolveThousandsSeparator(separator) {
+  if (separator == null || separator === false) return "";
+  if (typeof separator === "string") return separator;
+  return ",";
+}
+
+export { addPreciseNumbers, buildCsvContent, buildTxtContent, clamp, comparePreciseNumbers, copyJson, copyRows, copyText, copyTextSync, dividePreciseNumber, downloadJsonFile, exportTableToCsv, exportTableToTxt, exportTableToXlsx, formatChineseNumber, formatCustomNumberPattern, formatDateTimeValue, formatNumberValue, formatPercentValue, formatPreciseNumber, formatRowsForClipboard, formatScientificValue, getValueByDataIndex, isDateTimeFormatPattern, isPointInRect, isSameDataIndex, mapRowsToExportRecords, normalizeDecimalPlaces, parseChineseNumber, parseNumberValue, resolveDateValue, roundPreciseNumber, serializeCsvRows, stringifyDataIndex, sumPreciseNumbers };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map