@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/fill.js

@@ -0,0 +1,919 @@
+import { Direction } from "@rowsncolumns/common-types";
+import { toDate } from "@rowsncolumns/utils";
+import { SheetCell } from "../sheet-cell";
+// Helper functions for pattern detection and fill operations
+/**
+ * Extract numeric value from a string that may contain text
+ */
+const extractNumber = (value) => {
+    const match = value.match(/-?\d+\.?\d*/);
+    return match ? parseFloat(match[0]) : null;
+};
+const TEXT_NUMBER_PATTERN_REGEX = /^(.*?)(-?\d+(?:\.\d+)?)(.*)$/;
+const MONTH_NAME_REGEX = /\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i;
+const WEEKDAY_NAME_REGEX = /\b(?:mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:rs(?:day)?)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b/i;
+const ISO_DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2}(?:[tT ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+const NUMERIC_DATE_REGEX = /^\d{1,4}[\/.-]\d{1,2}(?:[\/.-]\d{1,4})?(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/;
+const extractTextNumberPattern = (value) => {
+    const match = value.match(TEXT_NUMBER_PATTERN_REGEX);
+    if (!match)
+        return null;
+    const [, prefix, numericPortion, suffix] = match;
+    if (!prefix && !suffix)
+        return null;
+    const parsed = parseFloat(numericPortion);
+    if (Number.isNaN(parsed))
+        return null;
+    return {
+        prefix,
+        suffix,
+        number: parsed,
+    };
+};
+const isLikelyDateString = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || /^\d+$/.test(trimmed)) {
+        return false;
+    }
+    if (ISO_DATE_TIME_REGEX.test(trimmed) || NUMERIC_DATE_REGEX.test(trimmed)) {
+        return true;
+    }
+    if (MONTH_NAME_REGEX.test(trimmed) || WEEKDAY_NAME_REGEX.test(trimmed)) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Check if a value is a date
+ */
+const _isDate = (value) => {
+    return (value instanceof Date || (!isNaN(Date.parse(value)) && isNaN(Number(value))));
+};
+/**
+ * Parse a date from various formats
+ */
+const parseDate = (value) => {
+    if (value instanceof Date)
+        return value;
+    // Don't try to parse numbers as dates
+    if (typeof value === "number")
+        return null;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!isLikelyDateString(trimmed))
+            return null;
+    }
+    const parsed = Date.parse(value);
+    return isNaN(parsed) ? null : new Date(parsed);
+};
+/**
+ * Get day names array
+ */
+const getDayNames = (locale = "en") => {
+    const days = [];
+    const date = new Date(2024, 0, 1); // Start with a Monday
+    for (let i = 0; i < 7; i++) {
+        days.push(date.toLocaleDateString(locale, { weekday: "long" }));
+        date.setDate(date.getDate() + 1);
+    }
+    return days;
+};
+/**
+ * Custom autofill list matching. Returns the matched list + the
+ * position in the list where the source values START, and the
+ * direction (ascending = source[0]→source[n-1] follows list order;
+ * descending = reverse).
+ *
+ * Match is case-insensitive on string values; non-string values
+ * (numbers, booleans, dates) never match. Excel's behaviour: source
+ * values must form a *contiguous* slice of the list (with wrap-around
+ * — "Sun, Mon" can extend into "Tue, Wed,...").
+ */
+const matchCustomList = (source, lists) => {
+    if (!lists || lists.length === 0 || source.length === 0)
+        return null;
+    const stringValues = source.map((v) => typeof v === "string" ? v.toLowerCase() : null);
+    if (stringValues.some((v) => v === null))
+        return null;
+    const lc = stringValues;
+    for (const list of lists) {
+        if (list.length < 2)
+            continue;
+        const listLower = list.map((s) => s.toLowerCase());
+        // Find ascending starting index where source[i] === listLower[(start + i) % N]
+        const findStart = (asc) => {
+            const len = listLower.length;
+            for (let start = 0; start < len; start++) {
+                let ok = true;
+                for (let i = 0; i < lc.length; i++) {
+                    const offset = asc ? i : -i;
+                    const idx = ((start + offset) % len + len) % len;
+                    if (lc[i] !== listLower[idx]) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok)
+                    return start;
+            }
+            return -1;
+        };
+        const ascStart = findStart(true);
+        if (ascStart !== -1) {
+            return { list, startIndex: ascStart, ascending: true };
+        }
+        if (lc.length >= 2) {
+            const descStart = findStart(false);
+            if (descStart !== -1) {
+                return { list, startIndex: descStart, ascending: false };
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Get month names array
+ */
+const getMonthNames = (locale = "en") => {
+    const months = [];
+    for (let i = 0; i < 12; i++) {
+        const date = new Date(2024, i, 1);
+        months.push(date.toLocaleDateString(locale, { month: "long" }));
+    }
+    return months;
+};
+const FLOAT_ROUNDING_DECIMALS = 12;
+const FLOAT_EPSILON_FACTOR = 10;
+const SIMPLE_INTEGER_SERIES_NUMBER_PATTERN_REGEX = /^(?:#|0|#,##0)$/i;
+const SIMPLE_DECIMAL_SERIES_NUMBER_PATTERN_REGEX = /^(?:#|0|#,##0)\.0+$/i;
+const getFloatTolerance = (value) => Number.EPSILON * Math.max(1, Math.abs(value)) * FLOAT_EPSILON_FACTOR;
+const normalizeSeriesNumber = (value) => {
+    if (!Number.isFinite(value)) {
+        return value;
+    }
+    const tolerance = getFloatTolerance(value);
+    const nearestInteger = Math.round(value);
+    if (Math.abs(value - nearestInteger) <= tolerance) {
+        return nearestInteger;
+    }
+    for (let decimals = 0; decimals <= FLOAT_ROUNDING_DECIMALS; decimals += 1) {
+        const rounded = Number(value.toFixed(decimals));
+        if (Math.abs(value - rounded) <= tolerance) {
+            return rounded;
+        }
+    }
+    return Number(value.toPrecision(15));
+};
+const isNearlyInteger = (value) => {
+    if (!Number.isFinite(value)) {
+        return false;
+    }
+    return Math.abs(value - Math.round(value)) <= getFloatTolerance(value);
+};
+const isSimpleIntegerSeriesNumberPattern = (pattern) => {
+    const normalizedPattern = pattern?.trim();
+    return Boolean(normalizedPattern &&
+        SIMPLE_INTEGER_SERIES_NUMBER_PATTERN_REGEX.test(normalizedPattern));
+};
+const isSimpleDecimalSeriesNumberPattern = (pattern) => {
+    const normalizedPattern = pattern?.trim() ?? "General";
+    return SIMPLE_DECIMAL_SERIES_NUMBER_PATTERN_REGEX.test(normalizedPattern);
+};
+const shouldNormalizeSeriesNumberFormat = (fillType, numberFormat, value) => {
+    if (fillType !== "FillSeries") {
+        return false;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return false;
+    }
+    if (!numberFormat || numberFormat.type !== "NUMBER") {
+        return false;
+    }
+    const pattern = numberFormat.pattern;
+    if (isSimpleIntegerSeriesNumberPattern(pattern) && !isNearlyInteger(value)) {
+        return true;
+    }
+    if (isSimpleDecimalSeriesNumberPattern(pattern) && isNearlyInteger(value)) {
+        return true;
+    }
+    return false;
+};
+const getCellNumberFormat = (sheetCell) => {
+    const effectiveNumberFormat = sheetCell.getNumberFormat();
+    if (effectiveNumberFormat) {
+        return effectiveNumberFormat;
+    }
+    const userEnteredFormat = sheetCell.getUserEnteredFormat();
+    if (userEnteredFormat &&
+        typeof userEnteredFormat === "object" &&
+        "numberFormat" in userEnteredFormat) {
+        return userEnteredFormat.numberFormat;
+    }
+    return undefined;
+};
+const shouldNormalizeSeriesNumberFormatForCell = (sheetCell, fillType, value) => {
+    const numberFormat = getCellNumberFormat(sheetCell);
+    return shouldNormalizeSeriesNumberFormat(fillType, numberFormat, value);
+};
+const clearCellNumberFormatForSeries = (sheetCell) => {
+    if (sheetCell.userEnteredFormat) {
+        if (!Object.isExtensible(sheetCell.userEnteredFormat)) {
+            sheetCell.userEnteredFormat = { ...sheetCell.userEnteredFormat };
+        }
+        delete sheetCell.userEnteredFormat.numberFormat;
+    }
+};
+/**
+ * Detect the fill type based on selection data
+ */
+export const detectFillType = (selectionData, locale = "en", customAutofillLists) => {
+    if (!selectionData.length || !selectionData[0]?.length) {
+        return "FillCopy";
+    }
+    // Flatten the selection to analyze patterns
+    const values = selectionData.flat().filter((v) => v != null);
+    if (values.length === 0)
+        return "FillCopy";
+    // Custom autofill lists take precedence over the built-in heuristics
+    // (matches Excel — a user-defined list like ["Q1","Q2","Q3","Q4"]
+    // wins over "FillSeries" or "FillDefault" interpretations).
+    if (matchCustomList(values, customAutofillLists)) {
+        return "FillCustomList";
+    }
+    // Helper to check for day/month names
+    const dayNames = getDayNames(locale);
+    const monthNames = getMonthNames(locale);
+    if (values.length === 1) {
+        const singleValue = values[0];
+        if (singleValue instanceof Date) {
+            return "FillDays";
+        }
+        // Single numbers → FillCopy (Excel standard: need 2+ cells for series)
+        if (typeof singleValue === "number") {
+            return "FillCopy";
+        }
+        if (typeof singleValue === "string") {
+            // Single number strings → FillCopy (Excel standard)
+            const extractedNum = extractNumber(singleValue);
+            if (extractedNum !== null &&
+                singleValue.trim() === String(extractedNum)) {
+                return "FillCopy";
+            }
+            // Single text with number (e.g. "hello 1") should continue the numeric suffix.
+            if (extractTextNumberPattern(singleValue) &&
+                !isLikelyDateString(singleValue)) {
+                return "FillSeries";
+            }
+            // Check for day name
+            const lowerValue = singleValue.toLowerCase();
+            if (lowerValue.length >= 3 &&
+                dayNames.some((day) => day.toLowerCase().startsWith(lowerValue) ||
+                    lowerValue.startsWith(day.toLowerCase().substring(0, 3)))) {
+                return "FillDays";
+            }
+            // Check for month name
+            if (lowerValue.length >= 3 &&
+                monthNames.some((month) => month.toLowerCase().startsWith(lowerValue) ||
+                    lowerValue.startsWith(month.toLowerCase().substring(0, 3)))) {
+                return "FillMonths";
+            }
+            const singleDate = parseDate(singleValue);
+            if (singleDate) {
+                return "FillDays";
+            }
+        }
+        return "FillCopy";
+    }
+    // Check for dates first (before numeric series to avoid Date objects being treated as numbers)
+    const dates = values
+        .map((v) => parseDate(v))
+        .filter((d) => d !== null);
+    // Debug logging removed
+    if (dates.length >= 2) {
+        const firstDate = dates[0];
+        const secondDate = dates[1];
+        const timeDiff = secondDate.getTime() - firstDate.getTime();
+        const dayDiff = timeDiff / (1000 * 60 * 60 * 24);
+        if (Math.abs(dayDiff - 1) < 0.1)
+            return "FillDays";
+        if (Math.abs(dayDiff - 7) < 0.1)
+            return "FillWeekdays";
+        const sameDayOfMonth = firstDate.getDate() === secondDate.getDate();
+        const sameMonth = firstDate.getMonth() === secondDate.getMonth();
+        const monthDiff = (secondDate.getFullYear() - firstDate.getFullYear()) * 12 +
+            (secondDate.getMonth() - firstDate.getMonth());
+        if (sameDayOfMonth && monthDiff === 1)
+            return "FillMonths";
+        if (sameDayOfMonth &&
+            sameMonth &&
+            secondDate.getFullYear() - firstDate.getFullYear() === 1)
+            return "FillYears";
+        return "FillDays";
+    }
+    // Check for numeric series (after dates to avoid Date objects being treated as timestamps)
+    const nonDateValues = values.filter((v) => !(v instanceof Date));
+    const numbers = nonDateValues
+        .map((v) => (typeof v === "number" ? v : extractNumber(String(v))))
+        .filter((n) => n !== null);
+    // Debug logging removed
+    // Only consider it a series if ALL non-Date values can be converted to numbers
+    if (numbers.length >= 2 && numbers.length === nonDateValues.length) {
+        const diff = numbers[1] - numbers[0];
+        const isLinearSeries = numbers.every((num, i) => i === 0 || Math.abs(num - numbers[i - 1] - diff) < 0.0001);
+        // Debug logging removed
+        if (isLinearSeries && diff !== 0) {
+            return "FillSeries";
+        }
+    }
+    // Check for text patterns (days/months)
+    const textValues = values.map((v) => String(v).toLowerCase());
+    // Debug logging removed
+    if (textValues.some((v) => v.length >= 3 &&
+        dayNames.some((day) => day.toLowerCase().includes(v) || v.includes(day.toLowerCase())))) {
+        return "FillDays";
+    }
+    if (textValues.some((v) => v.length >= 3 &&
+        monthNames.some((month) => month.toLowerCase().includes(v) || v.includes(month.toLowerCase())))) {
+        return "FillMonths";
+    }
+    return "FillDefault";
+};
+/**
+ * Generate fill values based on type and pattern
+ */
+export const generateFillValues = (sourceValues, fillType, count, locale, customAutofillLists) => {
+    const result = [];
+    switch (fillType) {
+        case "FillCustomList": {
+            const match = matchCustomList(sourceValues, customAutofillLists);
+            if (!match) {
+                // Fell out of sync (e.g. caller passed FillCustomList but the
+                // values don't match a list anymore). Degrade to copy.
+                for (let i = 0; i < count; i++) {
+                    result.push(sourceValues[i % sourceValues.length]);
+                }
+                break;
+            }
+            const { list, startIndex, ascending } = match;
+            const len = list.length;
+            // Continue from where the source slice ended.
+            const nextOffset = ascending
+                ? startIndex + sourceValues.length
+                : startIndex - sourceValues.length;
+            for (let i = 0; i < count; i++) {
+                const step = ascending ? i : -i;
+                const idx = (((nextOffset + step) % len) + len) % len;
+                result.push(list[idx]);
+            }
+            break;
+        }
+        case "FillCopy": {
+            for (let i = 0; i < count; i++) {
+                result.push(sourceValues[i % sourceValues.length]);
+            }
+            break;
+        }
+        case "FillSeries": {
+            const textPatterns = sourceValues
+                .map((value) => typeof value === "string" ? extractTextNumberPattern(value) : null)
+                .filter((pattern) => pattern !== null);
+            if (textPatterns.length === sourceValues.length &&
+                textPatterns.length > 0) {
+                const [firstPattern, ...restPatterns] = textPatterns;
+                const hasConsistentAffixes = restPatterns.every(({ prefix, suffix }) => prefix === firstPattern.prefix && suffix === firstPattern.suffix);
+                if (hasConsistentAffixes) {
+                    const numbers = textPatterns.map((pattern) => pattern.number);
+                    const diff = numbers.length >= 2
+                        ? normalizeSeriesNumber(numbers[1] - numbers[0])
+                        : 1;
+                    const lastValue = normalizeSeriesNumber(numbers[numbers.length - 1]);
+                    for (let i = 0; i < count; i++) {
+                        const nextNumber = normalizeSeriesNumber(lastValue + diff * (i + 1));
+                        result.push(`${firstPattern.prefix}${String(nextNumber)}${firstPattern.suffix}`);
+                    }
+                    break;
+                }
+            }
+            const numbers = sourceValues
+                .map((v) => (typeof v === "number" ? v : extractNumber(String(v))))
+                .filter((n) => n !== null);
+            if (numbers.length >= 1) {
+                // Default increment is 1 for single values, or calculated diff for 2+ values
+                const diff = numbers.length >= 2
+                    ? normalizeSeriesNumber(numbers[1] - numbers[0])
+                    : 1;
+                const lastValue = normalizeSeriesNumber(numbers[numbers.length - 1]);
+                for (let i = 0; i < count; i++) {
+                    result.push(normalizeSeriesNumber(lastValue + diff * (i + 1)));
+                }
+            }
+            else {
+                result.push(...Array(count).fill(sourceValues[sourceValues.length - 1]));
+            }
+            break;
+        }
+        case "FillDays": {
+            const parsedDates = sourceValues
+                .map((value) => parseDate(value))
+                .filter((date) => date !== null);
+            if (parsedDates.length) {
+                const lastDate = parsedDates[parsedDates.length - 1];
+                const previousDate = parsedDates.length >= 2 ? parsedDates[parsedDates.length - 2] : null;
+                const dayMs = 1000 * 60 * 60 * 24;
+                let dayIncrement = 1;
+                if (previousDate) {
+                    const diff = Math.round((lastDate.getTime() - previousDate.getTime()) / dayMs);
+                    if (diff !== 0) {
+                        dayIncrement = diff;
+                    }
+                }
+                const currentDate = new Date(lastDate);
+                for (let i = 0; i < count; i++) {
+                    currentDate.setDate(currentDate.getDate() + dayIncrement);
+                    result.push(currentDate.toLocaleDateString(locale));
+                }
+            }
+            else {
+                const lastDayValue = sourceValues[sourceValues.length - 1];
+                if (typeof lastDayValue === "string") {
+                    // Handle day names (like "Mon", "Tue", "Wed")
+                    const allDayNames = getDayNames(locale);
+                    const allDayAbbrevs = allDayNames.map((d) => d.substring(0, 3));
+                    // Find which day we're at
+                    const lastDayLower = lastDayValue.toLowerCase();
+                    const dayIndex = allDayNames.findIndex((d) => d.toLowerCase().includes(lastDayLower) ||
+                        lastDayLower.includes(d.toLowerCase()));
+                    if (dayIndex !== -1) {
+                        // Determine if we're using full names or abbreviations
+                        const isAbbreviated = lastDayValue.length <= 3;
+                        for (let i = 0; i < count; i++) {
+                            const nextDayIndex = (dayIndex + i + 1) % 7;
+                            const dayName = isAbbreviated
+                                ? allDayAbbrevs[nextDayIndex]
+                                : allDayNames[nextDayIndex];
+                            result.push(dayName);
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case "FillWeekdays": {
+            const lastWeekday = parseDate(sourceValues[sourceValues.length - 1]);
+            if (lastWeekday) {
+                const currentDate = new Date(lastWeekday);
+                for (let i = 0; i < count; i++) {
+                    do {
+                        currentDate.setDate(currentDate.getDate() + 1);
+                    } while (currentDate.getDay() === 0 || currentDate.getDay() === 6); // Skip weekends
+                    result.push(new Date(currentDate).toLocaleDateString(locale));
+                }
+            }
+            break;
+        }
+        case "FillMonths": {
+            // Check if we're dealing with month names (text) or actual dates
+            const lastValue = sourceValues[sourceValues.length - 1];
+            const lastMonth = parseDate(lastValue);
+            if (lastMonth) {
+                // Handle actual dates
+                for (let i = 0; i < count; i++) {
+                    const newDate = new Date(lastMonth);
+                    newDate.setMonth(lastMonth.getMonth() + i + 1);
+                    result.push(newDate.toLocaleDateString(locale));
+                }
+            }
+            else if (typeof lastValue === "string") {
+                // Handle month names (like "Jan", "Feb", "Mar")
+                const allMonthNames = getMonthNames(locale);
+                const allMonthAbbrevs = allMonthNames.map((m) => m.substring(0, 3));
+                // Find which month we're at
+                const lastValueLower = lastValue.toLowerCase();
+                const monthIndex = allMonthNames.findIndex((m) => m.toLowerCase().includes(lastValueLower) ||
+                    lastValueLower.includes(m.toLowerCase()));
+                if (monthIndex !== -1) {
+                    // Determine if we're using full names or abbreviations
+                    const isAbbreviated = lastValue.length <= 3;
+                    for (let i = 0; i < count; i++) {
+                        const nextMonthIndex = (monthIndex + i + 1) % 12;
+                        const monthName = isAbbreviated
+                            ? allMonthAbbrevs[nextMonthIndex]
+                            : allMonthNames[nextMonthIndex];
+                        result.push(monthName);
+                    }
+                }
+            }
+            break;
+        }
+        case "FillYears": {
+            const lastYear = parseDate(sourceValues[sourceValues.length - 1]);
+            if (lastYear) {
+                for (let i = 0; i < count; i++) {
+                    const newDate = new Date(lastYear);
+                    newDate.setFullYear(lastYear.getFullYear() + i + 1);
+                    result.push(newDate.toLocaleDateString(locale));
+                }
+            }
+            break;
+        }
+        case "LinearTrend": {
+            const numValues = sourceValues
+                .map((v) => (typeof v === "number" ? v : parseFloat(String(v))))
+                .filter((n) => !isNaN(n));
+            if (numValues.length >= 2) {
+                // Simple linear regression
+                const n = numValues.length;
+                const sumX = numValues.reduce((sum, _, i) => sum + i, 0);
+                const sumY = numValues.reduce((sum, val) => sum + val, 0);
+                const sumXY = numValues.reduce((sum, val, i) => sum + i * val, 0);
+                const sumXX = numValues.reduce((sum, _, i) => sum + i * i, 0);
+                const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+                const intercept = (sumY - slope * sumX) / n;
+                for (let i = 0; i < count; i++) {
+                    const x = numValues.length + i;
+                    result.push(slope * x + intercept);
+                }
+            }
+            break;
+        }
+        case "GrowthTrend": {
+            const growthValues = sourceValues
+                .map((v) => (typeof v === "number" ? v : parseFloat(String(v))))
+                .filter((n) => !isNaN(n) && n > 0);
+            if (growthValues.length >= 2) {
+                // Calculate growth rate
+                const ratios = [];
+                for (let i = 1; i < growthValues.length; i++) {
+                    ratios.push(growthValues[i] / growthValues[i - 1]);
+                }
+                const avgRatio = ratios.reduce((sum, ratio) => sum + ratio, 0) / ratios.length;
+                let lastValue = growthValues[growthValues.length - 1];
+                for (let i = 0; i < count; i++) {
+                    lastValue *= avgRatio;
+                    result.push(lastValue);
+                }
+            }
+            break;
+        }
+        case "FillValues": {
+            // Similar to FillSeries but preserves text formatting
+            for (let i = 0; i < count; i++) {
+                const sourceIndex = i % sourceValues.length;
+                let value = sourceValues[sourceIndex];
+                if (typeof value === "string") {
+                    const num = extractNumber(value);
+                    if (num !== null && sourceValues.length >= 2) {
+                        const nextNum = extractNumber(String(sourceValues[(sourceIndex + 1) % sourceValues.length]));
+                        if (nextNum !== null) {
+                            const diff = nextNum - num;
+                            const cycles = Math.floor(i / sourceValues.length);
+                            const newNum = num + diff * (cycles + 1);
+                            value = value.replace(String(num), String(newNum));
+                        }
+                    }
+                }
+                result.push(value);
+            }
+            break;
+        }
+        case "FillFormats": {
+            // Only copy formatting, not values - this would need format information
+            result.push(...Array(count).fill(""));
+            break;
+        }
+        case "FlashFill": {
+            // Advanced pattern recognition - simplified implementation
+            result.push(...Array(count).fill(sourceValues[sourceValues.length - 1]));
+            break;
+        }
+        default:
+            // FillDefault - intelligent copy
+            for (let i = 0; i < count; i++) {
+                result.push(sourceValues[i % sourceValues.length]);
+            }
+    }
+    return result;
+};
+/**
+ * Get auto fill values
+ * @returns T[][]
+ */
+export const getAutoFillValues = async ({ sheetId, direction, selection, fillBounds, getCellData, getEffectiveValue, getFormattedValue, getSheetName, getDataValidationById, cellXfsRegistry, locale, fillType, customAutofillLists, }) => {
+    // Create a cell helper
+    const sheetCell = new SheetCell();
+    const activeSheetName = getSheetName(sheetId);
+    const textCell = new SheetCell();
+    const getTextInfo = (cells) => {
+        for (const { rowIndex, columnIndex } of cells) {
+            const cellData = getCellData(sheetId, rowIndex, columnIndex);
+            textCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                locale,
+                cellXfsRegistry,
+                getDataValidationById,
+            });
+            if (textCell.getNumberFormat()?.type === "TEXT") {
+                const fallback = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                return {
+                    isText: true,
+                    textValue: textCell.getUserEnteredValue() ??
+                        textCell.getEffectiveValue() ??
+                        String(fallback ?? ""),
+                    pattern: textCell.getNumberFormat()?.pattern ?? "General",
+                };
+            }
+        }
+        return { isText: false, textValue: "", pattern: "General" };
+    };
+    const buildTextCell = (sourceCellData, value, pattern) => {
+        const newCell = new SheetCell();
+        newCell.assign(sheetId, { rowIndex: selection.range.startRowIndex, columnIndex: 0 }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
+        newCell.setUserEnteredFormat("numberFormat", {
+            type: "TEXT",
+            pattern,
+        });
+        newCell.setUserEnteredValue(value);
+        return newCell.getCellData();
+    };
+    const getFillSourceValue = (sheetId, rowIndex, columnIndex) => {
+        const cellData = getCellData(sheetId, rowIndex, columnIndex);
+        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+            locale,
+            cellXfsRegistry,
+            getDataValidationById,
+        });
+        const numFmtType = sheetCell.getNumberFormat()?.type;
+        const isDateTime = numFmtType === "DATE" || numFmtType === "DATE_TIME";
+        const isText = numFmtType === "TEXT";
+        if (isDateTime) {
+            const effectiveValue = getEffectiveValue?.(sheetId, rowIndex, columnIndex);
+            if (typeof effectiveValue === "number") {
+                return toDate(effectiveValue, sheetCell.use1904);
+            }
+            return getFormattedValue?.(sheetId, rowIndex, columnIndex);
+        }
+        const cellValue = isText
+            ? sheetCell.getUserEnteredValue()
+            : getEffectiveValue?.(sheetId, rowIndex, columnIndex);
+        return cellValue;
+    };
+    // Get selection data for pattern analysis
+    const selectionData = [];
+    for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+        const rowData = [];
+        for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+            const cellData = getFillSourceValue(sheetId, rowIndex, columnIndex);
+            rowData.push(cellData || null);
+        }
+        selectionData.push(rowData);
+    }
+    // Calculate fill dimensions
+    const selectionRows = selection.range.endRowIndex - selection.range.startRowIndex + 1;
+    const selectionCols = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+    const fillValues = [];
+    switch (direction) {
+        case Direction.Down: {
+            const fillCount = fillBounds.endRowIndex - selection.range.endRowIndex;
+            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                // Get source values for this column
+                const sourceValues = [];
+                const sourceCells = [];
+                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    // Check data type
+                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                    sourceValues.push(cellValue);
+                    sourceCells.push({ rowIndex, columnIndex });
+                }
+                const textInfo = getTextInfo(sourceCells);
+                // Detect fill type for this specific column
+                const columnData = [sourceValues]; // Convert to 2D array for detectFillType
+                const actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
+                // Generate fill values for this column
+                let newValues = textInfo.isText
+                    ? Array(fillCount).fill(textInfo.textValue)
+                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
+                // Fallback to FillDefault if no values were generated
+                if (newValues.length === 0 && actualFillType !== "FillDefault") {
+                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
+                }
+                // Apply the values
+                for (let i = 0; i < fillCount; i++) {
+                    const targetRowIndex = selection.range.endRowIndex + 1 + i;
+                    const targetColumnIndex = columnIndex;
+                    if (!fillValues[i])
+                        fillValues[i] = [];
+                    if (actualFillType === "FillFormats") {
+                        // Copy format but not value
+                        fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
+                            "";
+                    }
+                    else {
+                        // Get a source cell for formatting/properties
+                        const sourceRowIndex = selection.range.startRowIndex + (i % selectionRows);
+                        const sourceCellData = getCellData?.(sheetId, sourceRowIndex, columnIndex);
+                        sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
+                        if (sheetCell.isFormula()) {
+                            sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex }, { rowIndex: targetRowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
+                            // Remove effective value for formulas
+                            sheetCell.clearEffectiveValueForFormula();
+                        }
+                        else if (textInfo.isText) {
+                            fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
+                                buildTextCell(sourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
+                            continue;
+                        }
+                        else {
+                            // Use the generated fill value instead of source cell value
+                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                            if (shouldNormalizeSeriesNumberFormat) {
+                                clearCellNumberFormatForSeries(sheetCell);
+                            }
+                            sheetCell.setUserEnteredValue(newValues[i]);
+                        }
+                        fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
+                            sheetCell.getCellData();
+                    }
+                }
+            }
+            break;
+        }
+        case Direction.Up: {
+            const fillCount = selection.range.startRowIndex - fillBounds.startRowIndex;
+            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                // Get source values for this column (in reverse order for up direction)
+                const sourceValues = [];
+                const sourceCells = [];
+                for (let rowIndex = selection.range.endRowIndex; rowIndex >= selection.range.startRowIndex; rowIndex--) {
+                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                    sourceValues.push(cellValue);
+                    sourceCells.push({ rowIndex, columnIndex });
+                }
+                const textInfo = getTextInfo(sourceCells);
+                // Detect fill type for this specific column
+                const columnData = [sourceValues]; // Convert to 2D array for detectFillType
+                const actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
+                // Generate fill values for this column
+                let newValues = textInfo.isText
+                    ? Array(fillCount).fill(textInfo.textValue)
+                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
+                // Fallback to FillDefault if no values were generated
+                if (newValues.length === 0 && actualFillType !== "FillDefault") {
+                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
+                }
+                // Apply the values (in reverse order)
+                for (let i = 0; i < fillCount; i++) {
+                    const targetRowIndex = selection.range.startRowIndex - 1 - i;
+                    const targetColumnIndex = columnIndex;
+                    if (!fillValues[fillCount - 1 - i])
+                        fillValues[fillCount - 1 - i] = [];
+                    if (actualFillType === "FillFormats") {
+                        fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = "";
+                    }
+                    else {
+                        const sourceRowIndex = selection.range.endRowIndex - (i % selectionRows);
+                        const sourceCellData = getCellData?.(sheetId, sourceRowIndex, columnIndex);
+                        sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
+                        if (sheetCell.isFormula()) {
+                            sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex }, { rowIndex: targetRowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
+                            // Remove effective value for formulas
+                            sheetCell.clearEffectiveValueForFormula();
+                        }
+                        else if (textInfo.isText) {
+                            fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = buildTextCell(sourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
+                            continue;
+                        }
+                        else {
+                            // Use the generated fill value instead of source cell value
+                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                            if (shouldNormalizeSeriesNumberFormat) {
+                                clearCellNumberFormatForSeries(sheetCell);
+                            }
+                            sheetCell.setUserEnteredValue(newValues[i]);
+                        }
+                        fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = sheetCell.getCellData();
+                    }
+                }
+            }
+            break;
+        }
+        case Direction.Right: {
+            const fillCount = fillBounds.endColumnIndex - selection.range.endColumnIndex;
+            for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                // Get source values for this row
+                const sourceValues = [];
+                const sourceCells = [];
+                const textSourceCellData = getCellData?.(sheetId, rowIndex, selection.range.startColumnIndex);
+                for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                    sourceValues.push(cellValue);
+                    sourceCells.push({ rowIndex, columnIndex });
+                }
+                const textInfo = getTextInfo(sourceCells);
+                // Detect fill type for this specific row
+                const rowData = [sourceValues]; // Convert to 2D array for detectFillType
+                const actualFillType = fillType || detectFillType(rowData, locale);
+                // Generate fill values for this row
+                let newValues = textInfo.isText
+                    ? Array(fillCount).fill(textInfo.textValue)
+                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
+                // Fallback to FillDefault if no values were generated
+                if (newValues.length === 0 && actualFillType !== "FillDefault") {
+                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
+                }
+                // Apply the values
+                const targetRowIndex = rowIndex - fillBounds.startRowIndex;
+                if (!fillValues[targetRowIndex])
+                    fillValues[targetRowIndex] = [];
+                for (let i = 0; i < fillCount; i++) {
+                    const targetColumnIndex = selection.range.endColumnIndex + 1 + i;
+                    if (actualFillType === "FillFormats") {
+                        fillValues[targetRowIndex][i] = "";
+                    }
+                    else if (textInfo.isText) {
+                        fillValues[targetRowIndex][i] = buildTextCell(textSourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
+                    }
+                    else {
+                        const sourceColumnIndex = selection.range.startColumnIndex + (i % selectionCols);
+                        const sourceCellData = getCellData?.(sheetId, rowIndex, sourceColumnIndex);
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
+                        if (sheetCell.isFormula()) {
+                            sheetCell.moveFormula({ rowIndex, columnIndex: sourceColumnIndex }, { rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
+                            // Remove effective value for formulas
+                            sheetCell.clearEffectiveValueForFormula();
+                        }
+                        else {
+                            // Use the generated fill value instead of source cell value
+                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                            if (shouldNormalizeSeriesNumberFormat) {
+                                clearCellNumberFormatForSeries(sheetCell);
+                            }
+                            sheetCell.setUserEnteredValue(newValues[i]);
+                        }
+                        fillValues[targetRowIndex][i] = sheetCell.getCellData();
+                    }
+                }
+            }
+            break;
+        }
+        case Direction.Left: {
+            const fillCount = selection.range.startColumnIndex - fillBounds.startColumnIndex;
+            for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                // Get source values for this row (in reverse order for left direction)
+                const sourceValues = [];
+                const sourceCells = [];
+                const textSourceCellData = getCellData?.(sheetId, rowIndex, selection.range.endColumnIndex);
+                for (let columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                    sourceValues.push(cellValue);
+                    sourceCells.push({ rowIndex, columnIndex });
+                }
+                const textInfo = getTextInfo(sourceCells);
+                // Detect fill type for this specific row
+                const rowData = [sourceValues]; // Convert to 2D array for detectFillType
+                const actualFillType = fillType || detectFillType(rowData, locale);
+                // Generate fill values for this row
+                let newValues = textInfo.isText
+                    ? Array(fillCount).fill(textInfo.textValue)
+                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
+                // Fallback to FillDefault if no values were generated
+                if (newValues.length === 0 && actualFillType !== "FillDefault") {
+                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
+                }
+                // Apply the values (in reverse order)
+                const targetRowIndex = rowIndex - fillBounds.startRowIndex;
+                if (!fillValues[targetRowIndex])
+                    fillValues[targetRowIndex] = [];
+                for (let i = 0; i < fillCount; i++) {
+                    const targetColumnIndex = selection.range.startColumnIndex - 1 - i;
+                    if (actualFillType === "FillFormats") {
+                        fillValues[targetRowIndex][fillCount - 1 - i] = "";
+                    }
+                    else if (textInfo.isText) {
+                        fillValues[targetRowIndex][fillCount - 1 - i] = buildTextCell(textSourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
+                    }
+                    else {
+                        const sourceColumnIndex = selection.range.endColumnIndex - (i % selectionCols);
+                        const sourceCellData = getCellData?.(sheetId, rowIndex, sourceColumnIndex);
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
+                        if (sheetCell.isFormula()) {
+                            sheetCell.moveFormula({ rowIndex, columnIndex: sourceColumnIndex }, { rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
+                            // Remove effective value for formulas
+                            sheetCell.clearEffectiveValueForFormula();
+                        }
+                        else {
+                            // Use the generated fill value instead of source cell value
+                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                            if (shouldNormalizeSeriesNumberFormat) {
+                                clearCellNumberFormatForSeries(sheetCell);
+                            }
+                            sheetCell.setUserEnteredValue(newValues[i]);
+                        }
+                        fillValues[targetRowIndex][fillCount - 1 - i] =
+                            sheetCell.getCellData();
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return fillValues;
+};