@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/api/fill.js

@@ -0,0 +1,959 @@
+import { __assign, __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+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
+ */
+var extractNumber = function (value) {
+    var match = value.match(/-?\d+\.?\d*/);
+    return match ? parseFloat(match[0]) : null;
+};
+var TEXT_NUMBER_PATTERN_REGEX = /^(.*?)(-?\d+(?:\.\d+)?)(.*)$/;
+var 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;
+var WEEKDAY_NAME_REGEX = /\b(?:mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:rs(?:day)?)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b/i;
+var 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})?)?$/;
+var NUMERIC_DATE_REGEX = /^\d{1,4}[\/.-]\d{1,2}(?:[\/.-]\d{1,4})?(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/;
+var extractTextNumberPattern = function (value) {
+    var match = value.match(TEXT_NUMBER_PATTERN_REGEX);
+    if (!match)
+        return null;
+    var _a = __read(match, 4), prefix = _a[1], numericPortion = _a[2], suffix = _a[3];
+    if (!prefix && !suffix)
+        return null;
+    var parsed = parseFloat(numericPortion);
+    if (Number.isNaN(parsed))
+        return null;
+    return {
+        prefix: prefix,
+        suffix: suffix,
+        number: parsed,
+    };
+};
+var isLikelyDateString = function (value) {
+    var 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
+ */
+var _isDate = function (value) {
+    return (value instanceof Date || (!isNaN(Date.parse(value)) && isNaN(Number(value))));
+};
+/**
+ * Parse a date from various formats
+ */
+var parseDate = function (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") {
+        var trimmed = value.trim();
+        if (!isLikelyDateString(trimmed))
+            return null;
+    }
+    var parsed = Date.parse(value);
+    return isNaN(parsed) ? null : new Date(parsed);
+};
+/**
+ * Get day names array
+ */
+var getDayNames = function (locale) {
+    if (locale === void 0) { locale = "en"; }
+    var days = [];
+    var date = new Date(2024, 0, 1); // Start with a Monday
+    for (var 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,...").
+ */
+var matchCustomList = function (source, lists) {
+    var e_1, _a;
+    if (!lists || lists.length === 0 || source.length === 0)
+        return null;
+    var stringValues = source.map(function (v) {
+        return typeof v === "string" ? v.toLowerCase() : null;
+    });
+    if (stringValues.some(function (v) { return v === null; }))
+        return null;
+    var lc = stringValues;
+    var _loop_1 = function (list) {
+        if (list.length < 2)
+            return "continue";
+        var listLower = list.map(function (s) { return s.toLowerCase(); });
+        // Find ascending starting index where source[i] === listLower[(start + i) % N]
+        var findStart = function (asc) {
+            var len = listLower.length;
+            for (var start = 0; start < len; start++) {
+                var ok = true;
+                for (var i = 0; i < lc.length; i++) {
+                    var offset = asc ? i : -i;
+                    var idx = ((start + offset) % len + len) % len;
+                    if (lc[i] !== listLower[idx]) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok)
+                    return start;
+            }
+            return -1;
+        };
+        var ascStart = findStart(true);
+        if (ascStart !== -1) {
+            return { value: { list: list, startIndex: ascStart, ascending: true } };
+        }
+        if (lc.length >= 2) {
+            var descStart = findStart(false);
+            if (descStart !== -1) {
+                return { value: { list: list, startIndex: descStart, ascending: false } };
+            }
+        }
+    };
+    try {
+        for (var lists_1 = __values(lists), lists_1_1 = lists_1.next(); !lists_1_1.done; lists_1_1 = lists_1.next()) {
+            var list = lists_1_1.value;
+            var state_1 = _loop_1(list);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (lists_1_1 && !lists_1_1.done && (_a = lists_1.return)) _a.call(lists_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return null;
+};
+/**
+ * Get month names array
+ */
+var getMonthNames = function (locale) {
+    if (locale === void 0) { locale = "en"; }
+    var months = [];
+    for (var i = 0; i < 12; i++) {
+        var date = new Date(2024, i, 1);
+        months.push(date.toLocaleDateString(locale, { month: "long" }));
+    }
+    return months;
+};
+var FLOAT_ROUNDING_DECIMALS = 12;
+var FLOAT_EPSILON_FACTOR = 10;
+var SIMPLE_INTEGER_SERIES_NUMBER_PATTERN_REGEX = /^(?:#|0|#,##0)$/i;
+var SIMPLE_DECIMAL_SERIES_NUMBER_PATTERN_REGEX = /^(?:#|0|#,##0)\.0+$/i;
+var getFloatTolerance = function (value) {
+    return Number.EPSILON * Math.max(1, Math.abs(value)) * FLOAT_EPSILON_FACTOR;
+};
+var normalizeSeriesNumber = function (value) {
+    if (!Number.isFinite(value)) {
+        return value;
+    }
+    var tolerance = getFloatTolerance(value);
+    var nearestInteger = Math.round(value);
+    if (Math.abs(value - nearestInteger) <= tolerance) {
+        return nearestInteger;
+    }
+    for (var decimals = 0; decimals <= FLOAT_ROUNDING_DECIMALS; decimals += 1) {
+        var rounded = Number(value.toFixed(decimals));
+        if (Math.abs(value - rounded) <= tolerance) {
+            return rounded;
+        }
+    }
+    return Number(value.toPrecision(15));
+};
+var isNearlyInteger = function (value) {
+    if (!Number.isFinite(value)) {
+        return false;
+    }
+    return Math.abs(value - Math.round(value)) <= getFloatTolerance(value);
+};
+var isSimpleIntegerSeriesNumberPattern = function (pattern) {
+    var normalizedPattern = pattern === null || pattern === void 0 ? void 0 : pattern.trim();
+    return Boolean(normalizedPattern &&
+        SIMPLE_INTEGER_SERIES_NUMBER_PATTERN_REGEX.test(normalizedPattern));
+};
+var isSimpleDecimalSeriesNumberPattern = function (pattern) {
+    var _a;
+    var normalizedPattern = (_a = pattern === null || pattern === void 0 ? void 0 : pattern.trim()) !== null && _a !== void 0 ? _a : "General";
+    return SIMPLE_DECIMAL_SERIES_NUMBER_PATTERN_REGEX.test(normalizedPattern);
+};
+var shouldNormalizeSeriesNumberFormat = function (fillType, numberFormat, value) {
+    if (fillType !== "FillSeries") {
+        return false;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return false;
+    }
+    if (!numberFormat || numberFormat.type !== "NUMBER") {
+        return false;
+    }
+    var pattern = numberFormat.pattern;
+    if (isSimpleIntegerSeriesNumberPattern(pattern) && !isNearlyInteger(value)) {
+        return true;
+    }
+    if (isSimpleDecimalSeriesNumberPattern(pattern) && isNearlyInteger(value)) {
+        return true;
+    }
+    return false;
+};
+var getCellNumberFormat = function (sheetCell) {
+    var effectiveNumberFormat = sheetCell.getNumberFormat();
+    if (effectiveNumberFormat) {
+        return effectiveNumberFormat;
+    }
+    var userEnteredFormat = sheetCell.getUserEnteredFormat();
+    if (userEnteredFormat &&
+        typeof userEnteredFormat === "object" &&
+        "numberFormat" in userEnteredFormat) {
+        return userEnteredFormat.numberFormat;
+    }
+    return undefined;
+};
+var shouldNormalizeSeriesNumberFormatForCell = function (sheetCell, fillType, value) {
+    var numberFormat = getCellNumberFormat(sheetCell);
+    return shouldNormalizeSeriesNumberFormat(fillType, numberFormat, value);
+};
+var clearCellNumberFormatForSeries = function (sheetCell) {
+    if (sheetCell.userEnteredFormat) {
+        if (!Object.isExtensible(sheetCell.userEnteredFormat)) {
+            sheetCell.userEnteredFormat = __assign({}, sheetCell.userEnteredFormat);
+        }
+        delete sheetCell.userEnteredFormat.numberFormat;
+    }
+};
+/**
+ * Detect the fill type based on selection data
+ */
+export var detectFillType = function (selectionData, locale, customAutofillLists) {
+    var _a;
+    if (locale === void 0) { locale = "en"; }
+    if (!selectionData.length || !((_a = selectionData[0]) === null || _a === void 0 ? void 0 : _a.length)) {
+        return "FillCopy";
+    }
+    // Flatten the selection to analyze patterns
+    var values = selectionData.flat().filter(function (v) { return 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
+    var dayNames = getDayNames(locale);
+    var monthNames = getMonthNames(locale);
+    if (values.length === 1) {
+        var 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)
+            var 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
+            var lowerValue_1 = singleValue.toLowerCase();
+            if (lowerValue_1.length >= 3 &&
+                dayNames.some(function (day) {
+                    return day.toLowerCase().startsWith(lowerValue_1) ||
+                        lowerValue_1.startsWith(day.toLowerCase().substring(0, 3));
+                })) {
+                return "FillDays";
+            }
+            // Check for month name
+            if (lowerValue_1.length >= 3 &&
+                monthNames.some(function (month) {
+                    return month.toLowerCase().startsWith(lowerValue_1) ||
+                        lowerValue_1.startsWith(month.toLowerCase().substring(0, 3));
+                })) {
+                return "FillMonths";
+            }
+            var singleDate = parseDate(singleValue);
+            if (singleDate) {
+                return "FillDays";
+            }
+        }
+        return "FillCopy";
+    }
+    // Check for dates first (before numeric series to avoid Date objects being treated as numbers)
+    var dates = values
+        .map(function (v) { return parseDate(v); })
+        .filter(function (d) { return d !== null; });
+    // Debug logging removed
+    if (dates.length >= 2) {
+        var firstDate = dates[0];
+        var secondDate = dates[1];
+        var timeDiff = secondDate.getTime() - firstDate.getTime();
+        var dayDiff = timeDiff / (1000 * 60 * 60 * 24);
+        if (Math.abs(dayDiff - 1) < 0.1)
+            return "FillDays";
+        if (Math.abs(dayDiff - 7) < 0.1)
+            return "FillWeekdays";
+        var sameDayOfMonth = firstDate.getDate() === secondDate.getDate();
+        var sameMonth = firstDate.getMonth() === secondDate.getMonth();
+        var 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)
+    var nonDateValues = values.filter(function (v) { return !(v instanceof Date); });
+    var numbers = nonDateValues
+        .map(function (v) { return (typeof v === "number" ? v : extractNumber(String(v))); })
+        .filter(function (n) { return 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) {
+        var diff_1 = numbers[1] - numbers[0];
+        var isLinearSeries = numbers.every(function (num, i) { return i === 0 || Math.abs(num - numbers[i - 1] - diff_1) < 0.0001; });
+        // Debug logging removed
+        if (isLinearSeries && diff_1 !== 0) {
+            return "FillSeries";
+        }
+    }
+    // Check for text patterns (days/months)
+    var textValues = values.map(function (v) { return String(v).toLowerCase(); });
+    // Debug logging removed
+    if (textValues.some(function (v) {
+        return v.length >= 3 &&
+            dayNames.some(function (day) {
+                return day.toLowerCase().includes(v) || v.includes(day.toLowerCase());
+            });
+    })) {
+        return "FillDays";
+    }
+    if (textValues.some(function (v) {
+        return v.length >= 3 &&
+            monthNames.some(function (month) {
+                return month.toLowerCase().includes(v) || v.includes(month.toLowerCase());
+            });
+    })) {
+        return "FillMonths";
+    }
+    return "FillDefault";
+};
+/**
+ * Generate fill values based on type and pattern
+ */
+export var generateFillValues = function (sourceValues, fillType, count, locale, customAutofillLists) {
+    var result = [];
+    switch (fillType) {
+        case "FillCustomList": {
+            var 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 (var i = 0; i < count; i++) {
+                    result.push(sourceValues[i % sourceValues.length]);
+                }
+                break;
+            }
+            var list = match.list, startIndex = match.startIndex, ascending = match.ascending;
+            var len = list.length;
+            // Continue from where the source slice ended.
+            var nextOffset = ascending
+                ? startIndex + sourceValues.length
+                : startIndex - sourceValues.length;
+            for (var i = 0; i < count; i++) {
+                var step = ascending ? i : -i;
+                var idx = (((nextOffset + step) % len) + len) % len;
+                result.push(list[idx]);
+            }
+            break;
+        }
+        case "FillCopy": {
+            for (var i = 0; i < count; i++) {
+                result.push(sourceValues[i % sourceValues.length]);
+            }
+            break;
+        }
+        case "FillSeries": {
+            var textPatterns = sourceValues
+                .map(function (value) {
+                return typeof value === "string" ? extractTextNumberPattern(value) : null;
+            })
+                .filter(function (pattern) { return pattern !== null; });
+            if (textPatterns.length === sourceValues.length &&
+                textPatterns.length > 0) {
+                var _a = __read(textPatterns), firstPattern_1 = _a[0], restPatterns = _a.slice(1);
+                var hasConsistentAffixes = restPatterns.every(function (_a) {
+                    var prefix = _a.prefix, suffix = _a.suffix;
+                    return prefix === firstPattern_1.prefix && suffix === firstPattern_1.suffix;
+                });
+                if (hasConsistentAffixes) {
+                    var numbers_1 = textPatterns.map(function (pattern) { return pattern.number; });
+                    var diff = numbers_1.length >= 2
+                        ? normalizeSeriesNumber(numbers_1[1] - numbers_1[0])
+                        : 1;
+                    var lastValue = normalizeSeriesNumber(numbers_1[numbers_1.length - 1]);
+                    for (var i = 0; i < count; i++) {
+                        var nextNumber = normalizeSeriesNumber(lastValue + diff * (i + 1));
+                        result.push("".concat(firstPattern_1.prefix).concat(String(nextNumber)).concat(firstPattern_1.suffix));
+                    }
+                    break;
+                }
+            }
+            var numbers = sourceValues
+                .map(function (v) { return (typeof v === "number" ? v : extractNumber(String(v))); })
+                .filter(function (n) { return n !== null; });
+            if (numbers.length >= 1) {
+                // Default increment is 1 for single values, or calculated diff for 2+ values
+                var diff = numbers.length >= 2
+                    ? normalizeSeriesNumber(numbers[1] - numbers[0])
+                    : 1;
+                var lastValue = normalizeSeriesNumber(numbers[numbers.length - 1]);
+                for (var i = 0; i < count; i++) {
+                    result.push(normalizeSeriesNumber(lastValue + diff * (i + 1)));
+                }
+            }
+            else {
+                result.push.apply(result, __spreadArray([], __read(Array(count).fill(sourceValues[sourceValues.length - 1])), false));
+            }
+            break;
+        }
+        case "FillDays": {
+            var parsedDates = sourceValues
+                .map(function (value) { return parseDate(value); })
+                .filter(function (date) { return date !== null; });
+            if (parsedDates.length) {
+                var lastDate = parsedDates[parsedDates.length - 1];
+                var previousDate = parsedDates.length >= 2 ? parsedDates[parsedDates.length - 2] : null;
+                var dayMs = 1000 * 60 * 60 * 24;
+                var dayIncrement = 1;
+                if (previousDate) {
+                    var diff = Math.round((lastDate.getTime() - previousDate.getTime()) / dayMs);
+                    if (diff !== 0) {
+                        dayIncrement = diff;
+                    }
+                }
+                var currentDate = new Date(lastDate);
+                for (var i = 0; i < count; i++) {
+                    currentDate.setDate(currentDate.getDate() + dayIncrement);
+                    result.push(currentDate.toLocaleDateString(locale));
+                }
+            }
+            else {
+                var lastDayValue = sourceValues[sourceValues.length - 1];
+                if (typeof lastDayValue === "string") {
+                    // Handle day names (like "Mon", "Tue", "Wed")
+                    var allDayNames = getDayNames(locale);
+                    var allDayAbbrevs = allDayNames.map(function (d) { return d.substring(0, 3); });
+                    // Find which day we're at
+                    var lastDayLower_1 = lastDayValue.toLowerCase();
+                    var dayIndex = allDayNames.findIndex(function (d) {
+                        return d.toLowerCase().includes(lastDayLower_1) ||
+                            lastDayLower_1.includes(d.toLowerCase());
+                    });
+                    if (dayIndex !== -1) {
+                        // Determine if we're using full names or abbreviations
+                        var isAbbreviated = lastDayValue.length <= 3;
+                        for (var i = 0; i < count; i++) {
+                            var nextDayIndex = (dayIndex + i + 1) % 7;
+                            var dayName = isAbbreviated
+                                ? allDayAbbrevs[nextDayIndex]
+                                : allDayNames[nextDayIndex];
+                            result.push(dayName);
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case "FillWeekdays": {
+            var lastWeekday = parseDate(sourceValues[sourceValues.length - 1]);
+            if (lastWeekday) {
+                var currentDate = new Date(lastWeekday);
+                for (var 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
+            var lastValue = sourceValues[sourceValues.length - 1];
+            var lastMonth = parseDate(lastValue);
+            if (lastMonth) {
+                // Handle actual dates
+                for (var i = 0; i < count; i++) {
+                    var 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")
+                var allMonthNames = getMonthNames(locale);
+                var allMonthAbbrevs = allMonthNames.map(function (m) { return m.substring(0, 3); });
+                // Find which month we're at
+                var lastValueLower_1 = lastValue.toLowerCase();
+                var monthIndex = allMonthNames.findIndex(function (m) {
+                    return m.toLowerCase().includes(lastValueLower_1) ||
+                        lastValueLower_1.includes(m.toLowerCase());
+                });
+                if (monthIndex !== -1) {
+                    // Determine if we're using full names or abbreviations
+                    var isAbbreviated = lastValue.length <= 3;
+                    for (var i = 0; i < count; i++) {
+                        var nextMonthIndex = (monthIndex + i + 1) % 12;
+                        var monthName = isAbbreviated
+                            ? allMonthAbbrevs[nextMonthIndex]
+                            : allMonthNames[nextMonthIndex];
+                        result.push(monthName);
+                    }
+                }
+            }
+            break;
+        }
+        case "FillYears": {
+            var lastYear = parseDate(sourceValues[sourceValues.length - 1]);
+            if (lastYear) {
+                for (var i = 0; i < count; i++) {
+                    var newDate = new Date(lastYear);
+                    newDate.setFullYear(lastYear.getFullYear() + i + 1);
+                    result.push(newDate.toLocaleDateString(locale));
+                }
+            }
+            break;
+        }
+        case "LinearTrend": {
+            var numValues = sourceValues
+                .map(function (v) { return (typeof v === "number" ? v : parseFloat(String(v))); })
+                .filter(function (n) { return !isNaN(n); });
+            if (numValues.length >= 2) {
+                // Simple linear regression
+                var n = numValues.length;
+                var sumX = numValues.reduce(function (sum, _, i) { return sum + i; }, 0);
+                var sumY = numValues.reduce(function (sum, val) { return sum + val; }, 0);
+                var sumXY = numValues.reduce(function (sum, val, i) { return sum + i * val; }, 0);
+                var sumXX = numValues.reduce(function (sum, _, i) { return sum + i * i; }, 0);
+                var slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+                var intercept = (sumY - slope * sumX) / n;
+                for (var i = 0; i < count; i++) {
+                    var x = numValues.length + i;
+                    result.push(slope * x + intercept);
+                }
+            }
+            break;
+        }
+        case "GrowthTrend": {
+            var growthValues = sourceValues
+                .map(function (v) { return (typeof v === "number" ? v : parseFloat(String(v))); })
+                .filter(function (n) { return !isNaN(n) && n > 0; });
+            if (growthValues.length >= 2) {
+                // Calculate growth rate
+                var ratios = [];
+                for (var i = 1; i < growthValues.length; i++) {
+                    ratios.push(growthValues[i] / growthValues[i - 1]);
+                }
+                var avgRatio = ratios.reduce(function (sum, ratio) { return sum + ratio; }, 0) / ratios.length;
+                var lastValue = growthValues[growthValues.length - 1];
+                for (var i = 0; i < count; i++) {
+                    lastValue *= avgRatio;
+                    result.push(lastValue);
+                }
+            }
+            break;
+        }
+        case "FillValues": {
+            // Similar to FillSeries but preserves text formatting
+            for (var i = 0; i < count; i++) {
+                var sourceIndex = i % sourceValues.length;
+                var value = sourceValues[sourceIndex];
+                if (typeof value === "string") {
+                    var num = extractNumber(value);
+                    if (num !== null && sourceValues.length >= 2) {
+                        var nextNum = extractNumber(String(sourceValues[(sourceIndex + 1) % sourceValues.length]));
+                        if (nextNum !== null) {
+                            var diff = nextNum - num;
+                            var cycles = Math.floor(i / sourceValues.length);
+                            var 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.apply(result, __spreadArray([], __read(Array(count).fill("")), false));
+            break;
+        }
+        case "FlashFill": {
+            // Advanced pattern recognition - simplified implementation
+            result.push.apply(result, __spreadArray([], __read(Array(count).fill(sourceValues[sourceValues.length - 1])), false));
+            break;
+        }
+        default:
+            // FillDefault - intelligent copy
+            for (var i = 0; i < count; i++) {
+                result.push(sourceValues[i % sourceValues.length]);
+            }
+    }
+    return result;
+};
+/**
+ * Get auto fill values
+ * @returns T[][]
+ */
+export var getAutoFillValues = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var sheetCell, activeSheetName, textCell, getTextInfo, buildTextCell, getFillSourceValue, selectionData, rowIndex, rowData, columnIndex, cellData, selectionRows, selectionCols, fillValues, fillCount, columnIndex, sourceValues, sourceCells, rowIndex, cellValue, textInfo, columnData, actualFillType, newValues, i, targetRowIndex, targetColumnIndex, sourceRowIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_1, fillCount, columnIndex, sourceValues, sourceCells, rowIndex, cellValue, textInfo, columnData, actualFillType, newValues, i, targetRowIndex, targetColumnIndex, sourceRowIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_2, fillCount, rowIndex, sourceValues, sourceCells, textSourceCellData, columnIndex, cellValue, textInfo, rowData, actualFillType, newValues, targetRowIndex, i, targetColumnIndex, sourceColumnIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_3, fillCount, rowIndex, sourceValues, sourceCells, textSourceCellData, columnIndex, cellValue, textInfo, rowData, actualFillType, newValues, targetRowIndex, i, targetColumnIndex, sourceColumnIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_4;
+    var _c, _d, _e, _f;
+    var sheetId = _b.sheetId, direction = _b.direction, selection = _b.selection, fillBounds = _b.fillBounds, getCellData = _b.getCellData, getEffectiveValue = _b.getEffectiveValue, getFormattedValue = _b.getFormattedValue, getSheetName = _b.getSheetName, getDataValidationById = _b.getDataValidationById, cellXfsRegistry = _b.cellXfsRegistry, locale = _b.locale, fillType = _b.fillType, customAutofillLists = _b.customAutofillLists;
+    return __generator(this, function (_g) {
+        sheetCell = new SheetCell();
+        activeSheetName = getSheetName(sheetId);
+        textCell = new SheetCell();
+        getTextInfo = function (cells) {
+            var e_2, _a;
+            var _b, _c, _d, _e, _f;
+            try {
+                for (var cells_1 = __values(cells), cells_1_1 = cells_1.next(); !cells_1_1.done; cells_1_1 = cells_1.next()) {
+                    var _g = cells_1_1.value, rowIndex = _g.rowIndex, columnIndex = _g.columnIndex;
+                    var cellData = getCellData(sheetId, rowIndex, columnIndex);
+                    textCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                        locale: locale,
+                        cellXfsRegistry: cellXfsRegistry,
+                        getDataValidationById: getDataValidationById,
+                    });
+                    if (((_b = textCell.getNumberFormat()) === null || _b === void 0 ? void 0 : _b.type) === "TEXT") {
+                        var fallback = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                        return {
+                            isText: true,
+                            textValue: (_d = (_c = textCell.getUserEnteredValue()) !== null && _c !== void 0 ? _c : textCell.getEffectiveValue()) !== null && _d !== void 0 ? _d : String(fallback !== null && fallback !== void 0 ? fallback : ""),
+                            pattern: (_f = (_e = textCell.getNumberFormat()) === null || _e === void 0 ? void 0 : _e.pattern) !== null && _f !== void 0 ? _f : "General",
+                        };
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (cells_1_1 && !cells_1_1.done && (_a = cells_1.return)) _a.call(cells_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return { isText: false, textValue: "", pattern: "General" };
+        };
+        buildTextCell = function (sourceCellData, value, pattern) {
+            var newCell = new SheetCell();
+            newCell.assign(sheetId, { rowIndex: selection.range.startRowIndex, columnIndex: 0 }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+            newCell.setUserEnteredFormat("numberFormat", {
+                type: "TEXT",
+                pattern: pattern,
+            });
+            newCell.setUserEnteredValue(value);
+            return newCell.getCellData();
+        };
+        getFillSourceValue = function (sheetId, rowIndex, columnIndex) {
+            var _a;
+            var cellData = getCellData(sheetId, rowIndex, columnIndex);
+            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                locale: locale,
+                cellXfsRegistry: cellXfsRegistry,
+                getDataValidationById: getDataValidationById,
+            });
+            var numFmtType = (_a = sheetCell.getNumberFormat()) === null || _a === void 0 ? void 0 : _a.type;
+            var isDateTime = numFmtType === "DATE" || numFmtType === "DATE_TIME";
+            var isText = numFmtType === "TEXT";
+            if (isDateTime) {
+                var effectiveValue = getEffectiveValue === null || getEffectiveValue === void 0 ? void 0 : getEffectiveValue(sheetId, rowIndex, columnIndex);
+                if (typeof effectiveValue === "number") {
+                    return toDate(effectiveValue, sheetCell.use1904);
+                }
+                return getFormattedValue === null || getFormattedValue === void 0 ? void 0 : getFormattedValue(sheetId, rowIndex, columnIndex);
+            }
+            var cellValue = isText
+                ? sheetCell.getUserEnteredValue()
+                : getEffectiveValue === null || getEffectiveValue === void 0 ? void 0 : getEffectiveValue(sheetId, rowIndex, columnIndex);
+            return cellValue;
+        };
+        selectionData = [];
+        for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+            rowData = [];
+            for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                cellData = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                rowData.push(cellData || null);
+            }
+            selectionData.push(rowData);
+        }
+        selectionRows = selection.range.endRowIndex - selection.range.startRowIndex + 1;
+        selectionCols = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+        fillValues = [];
+        switch (direction) {
+            case Direction.Down: {
+                fillCount = fillBounds.endRowIndex - selection.range.endRowIndex;
+                for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                    sourceValues = [];
+                    sourceCells = [];
+                    for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                        sourceValues.push(cellValue);
+                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
+                    }
+                    textInfo = getTextInfo(sourceCells);
+                    columnData = [sourceValues];
+                    actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
+                    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 (i = 0; i < fillCount; i++) {
+                        targetRowIndex = selection.range.endRowIndex + 1 + i;
+                        targetColumnIndex = columnIndex;
+                        if (!fillValues[i])
+                            fillValues[i] = [];
+                        if (actualFillType === "FillFormats") {
+                            // Copy format but not value
+                            fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
+                                "";
+                        }
+                        else {
+                            sourceRowIndex = selection.range.startRowIndex + (i % selectionRows);
+                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, sourceRowIndex, columnIndex);
+                            sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex: columnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                            if (sheetCell.isFormula()) {
+                                sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex: 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((_c = newValues[i]) !== null && _c !== void 0 ? _c : ""), textInfo.pattern);
+                                continue;
+                            }
+                            else {
+                                shouldNormalizeSeriesNumberFormat_1 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                                if (shouldNormalizeSeriesNumberFormat_1) {
+                                    clearCellNumberFormatForSeries(sheetCell);
+                                }
+                                sheetCell.setUserEnteredValue(newValues[i]);
+                            }
+                            fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
+                                sheetCell.getCellData();
+                        }
+                    }
+                }
+                break;
+            }
+            case Direction.Up: {
+                fillCount = selection.range.startRowIndex - fillBounds.startRowIndex;
+                for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                    sourceValues = [];
+                    sourceCells = [];
+                    for (rowIndex = selection.range.endRowIndex; rowIndex >= selection.range.startRowIndex; rowIndex--) {
+                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                        sourceValues.push(cellValue);
+                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
+                    }
+                    textInfo = getTextInfo(sourceCells);
+                    columnData = [sourceValues];
+                    actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
+                    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 (i = 0; i < fillCount; i++) {
+                        targetRowIndex = selection.range.startRowIndex - 1 - i;
+                        targetColumnIndex = columnIndex;
+                        if (!fillValues[fillCount - 1 - i])
+                            fillValues[fillCount - 1 - i] = [];
+                        if (actualFillType === "FillFormats") {
+                            fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = "";
+                        }
+                        else {
+                            sourceRowIndex = selection.range.endRowIndex - (i % selectionRows);
+                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, sourceRowIndex, columnIndex);
+                            sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex: columnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                            if (sheetCell.isFormula()) {
+                                sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex: 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((_d = newValues[i]) !== null && _d !== void 0 ? _d : ""), textInfo.pattern);
+                                continue;
+                            }
+                            else {
+                                shouldNormalizeSeriesNumberFormat_2 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                                if (shouldNormalizeSeriesNumberFormat_2) {
+                                    clearCellNumberFormatForSeries(sheetCell);
+                                }
+                                sheetCell.setUserEnteredValue(newValues[i]);
+                            }
+                            fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = sheetCell.getCellData();
+                        }
+                    }
+                }
+                break;
+            }
+            case Direction.Right: {
+                fillCount = fillBounds.endColumnIndex - selection.range.endColumnIndex;
+                for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    sourceValues = [];
+                    sourceCells = [];
+                    textSourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, selection.range.startColumnIndex);
+                    for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                        sourceValues.push(cellValue);
+                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
+                    }
+                    textInfo = getTextInfo(sourceCells);
+                    rowData = [sourceValues];
+                    actualFillType = fillType || detectFillType(rowData, locale);
+                    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);
+                    }
+                    targetRowIndex = rowIndex - fillBounds.startRowIndex;
+                    if (!fillValues[targetRowIndex])
+                        fillValues[targetRowIndex] = [];
+                    for (i = 0; i < fillCount; i++) {
+                        targetColumnIndex = selection.range.endColumnIndex + 1 + i;
+                        if (actualFillType === "FillFormats") {
+                            fillValues[targetRowIndex][i] = "";
+                        }
+                        else if (textInfo.isText) {
+                            fillValues[targetRowIndex][i] = buildTextCell(textSourceCellData, String((_e = newValues[i]) !== null && _e !== void 0 ? _e : ""), textInfo.pattern);
+                        }
+                        else {
+                            sourceColumnIndex = selection.range.startColumnIndex + (i % selectionCols);
+                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, sourceColumnIndex);
+                            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                            if (sheetCell.isFormula()) {
+                                sheetCell.moveFormula({ rowIndex: rowIndex, columnIndex: sourceColumnIndex }, { rowIndex: rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
+                                // Remove effective value for formulas
+                                sheetCell.clearEffectiveValueForFormula();
+                            }
+                            else {
+                                shouldNormalizeSeriesNumberFormat_3 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                                if (shouldNormalizeSeriesNumberFormat_3) {
+                                    clearCellNumberFormatForSeries(sheetCell);
+                                }
+                                sheetCell.setUserEnteredValue(newValues[i]);
+                            }
+                            fillValues[targetRowIndex][i] = sheetCell.getCellData();
+                        }
+                    }
+                }
+                break;
+            }
+            case Direction.Left: {
+                fillCount = selection.range.startColumnIndex - fillBounds.startColumnIndex;
+                for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    sourceValues = [];
+                    sourceCells = [];
+                    textSourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, selection.range.endColumnIndex);
+                    for (columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
+                        sourceValues.push(cellValue);
+                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
+                    }
+                    textInfo = getTextInfo(sourceCells);
+                    rowData = [sourceValues];
+                    actualFillType = fillType || detectFillType(rowData, locale);
+                    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);
+                    }
+                    targetRowIndex = rowIndex - fillBounds.startRowIndex;
+                    if (!fillValues[targetRowIndex])
+                        fillValues[targetRowIndex] = [];
+                    for (i = 0; i < fillCount; i++) {
+                        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((_f = newValues[i]) !== null && _f !== void 0 ? _f : ""), textInfo.pattern);
+                        }
+                        else {
+                            sourceColumnIndex = selection.range.endColumnIndex - (i % selectionCols);
+                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, sourceColumnIndex);
+                            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                            if (sheetCell.isFormula()) {
+                                sheetCell.moveFormula({ rowIndex: rowIndex, columnIndex: sourceColumnIndex }, { rowIndex: rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
+                                // Remove effective value for formulas
+                                sheetCell.clearEffectiveValueForFormula();
+                            }
+                            else {
+                                shouldNormalizeSeriesNumberFormat_4 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
+                                if (shouldNormalizeSeriesNumberFormat_4) {
+                                    clearCellNumberFormatForSeries(sheetCell);
+                                }
+                                sheetCell.setUserEnteredValue(newValues[i]);
+                            }
+                            fillValues[targetRowIndex][fillCount - 1 - i] =
+                                sheetCell.getCellData();
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        return [2 /*return*/, fillValues];
+    });
+}); };