{
  "version": 3,
  "sources": ["../../../../../src/functions/array/sequence/sequence.ts"],
  "sourcesContent": [
    "import {\n  FormulaError,\n  type CellAddress,\n  type CellInRangeResult,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type SpilledValuesEvaluationResult,\n  type SpreadsheetRange,\n} from \"../../../core/types.mjs\";\nimport { getRangeIntersection, isRangeOneCell } from \"../../../core/utils.mjs\";\nimport { EvaluationError } from \"../../../evaluator/evaluation-error.mjs\";\n\n/**\n * SEQUENCE(rows, [columns], [start], [step])\n * Generates a sequence of numbers in an array.\n *\n * @param rows - The number of rows to return (can be array - uses origin value)\n * @param columns - [Optional] The number of columns to return (default: 1, can be array - uses origin value)\n * @param start - [Optional] The first number in the sequence (default: 1, can be array - uses origin value)\n * @param step - [Optional] The amount to increment each subsequent value (default: 1, can be array - uses origin value)\n *\n * Returns a spilled array of sequential numbers.\n * When any argument is an array, the result is broadcast over the largest input spill area.\n */\nexport const SEQUENCE: FunctionDefinition = {\n  name: \"SEQUENCE\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 1 || node.args.length > 4) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"SEQUENCE function takes 1 to 4 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate all arguments and check for array inputs\n    const argResults: FunctionEvaluationResult[] = [];\n    let largestSpillArea: SpreadsheetRange | null = null;\n    let hasArrayInput = false;\n\n    for (let i = 0; i < node.args.length; i++) {\n      const result = this.evaluateNode(node.args[i]!, context);\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n      argResults.push(result);\n\n      if (result.type === \"spilled-values\") {\n        hasArrayInput = true;\n        const spillArea = result.spillArea(context.cellAddress);\n        if (!largestSpillArea) {\n          largestSpillArea = spillArea;\n        } else {\n          // Use the larger spill area (more cells)\n          const currentCols =\n            spillArea.end.col.type === \"number\"\n              ? spillArea.end.col.value\n              : Infinity;\n          const currentRows =\n            spillArea.end.row.type === \"number\"\n              ? spillArea.end.row.value\n              : Infinity;\n          const currentSize =\n            (currentCols - spillArea.start.col + 1) *\n            (currentRows - spillArea.start.row + 1);\n\n          const largestCols =\n            largestSpillArea.end.col.type === \"number\"\n              ? largestSpillArea.end.col.value\n              : Infinity;\n          const largestRows =\n            largestSpillArea.end.row.type === \"number\"\n              ? largestSpillArea.end.row.value\n              : Infinity;\n          const largestSize =\n            (largestCols - largestSpillArea.start.col + 1) *\n            (largestRows - largestSpillArea.start.row + 1);\n\n          if (currentSize > largestSize) {\n            largestSpillArea = spillArea;\n          }\n        }\n      }\n    }\n\n    // Extract values from arguments (using origin values for arrays)\n    const rowsResult = argResults[0];\n    if (!rowsResult) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Missing rows argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    let rowsValue: number | \"infinity\" = 0;\n    let isRowsInfinite = false;\n\n    if (\n      rowsResult.type === \"awaiting-evaluation\" ||\n      rowsResult.type === \"error\"\n    ) {\n      return rowsResult;\n    }\n\n    if (rowsResult.type === \"spilled-values\") {\n      throw new Error(\"Sequences cannot contain spilled values\");\n    } else if (rowsResult.type === \"value\") {\n      if (rowsResult.result.type === \"infinity\") {\n        rowsValue = \"infinity\";\n        isRowsInfinite = true;\n      } else if (rowsResult.result.type === \"number\") {\n        rowsValue = rowsResult.result.value;\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Rows argument must be a number or INFINITY\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    const rows = isRowsInfinite ? Infinity : Math.floor(rowsValue as number);\n    if (!isRowsInfinite && rows < 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Rows must be greater than 0\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate columns argument (optional, default: 1)\n    let columns = 1;\n    let isColumnsInfinite = false;\n    if (node.args.length > 1) {\n      const columnsResult = argResults[1];\n      if (!columnsResult) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Missing columns argument\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (columnsResult.type === \"spilled-values\") {\n        throw new Error(\"Sequences cannot contain spilled values\");\n      } else if (columnsResult.type === \"value\") {\n        if (columnsResult.result.type === \"infinity\") {\n          columns = Infinity;\n          isColumnsInfinite = true;\n        } else if (columnsResult.result.type === \"number\") {\n          columns = Math.floor(columnsResult.result.value);\n        } else {\n          return {\n            type: \"error\",\n            err: FormulaError.VALUE,\n            message: \"Columns argument must be a number or INFINITY\",\n            errAddress: context.dependencyNode,\n          };\n        }\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Columns argument must be a number or INFINITY\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (!isColumnsInfinite && columns < 1) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Columns must be greater than 0\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // Evaluate start argument (optional, default: 1)\n    let start = 1;\n    if (node.args.length > 2) {\n      const startResult = argResults[2];\n      if (!startResult) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Missing start argument\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (startResult.type === \"spilled-values\") {\n        throw new Error(\"Sequences cannot contain spilled values\");\n      } else if (\n        startResult.type === \"value\" &&\n        startResult.result.type === \"number\"\n      ) {\n        start = startResult.result.value;\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Start argument must be a number\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // Evaluate step argument (optional, default: 1)\n    let step = 1;\n    if (node.args.length > 3) {\n      const stepResult = argResults[3];\n      if (!stepResult) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Missing step argument\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (stepResult.type === \"spilled-values\") {\n        throw new Error(\"Sequences cannot contain spilled values\");\n      } else if (\n        stepResult.type === \"value\" &&\n        stepResult.result.type === \"number\"\n      ) {\n        step = stepResult.result.value;\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Step argument must be a number\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // Create the spill area - if there are array inputs, use the largest input spill area\n    // Otherwise, create a new spill area based on the SEQUENCE dimensions\n    const spillArea = (origin: CellAddress): SpreadsheetRange => {\n      return hasArrayInput && largestSpillArea\n        ? largestSpillArea\n        : {\n            start: {\n              col: origin.colIndex,\n              row: origin.rowIndex,\n            },\n            end: {\n              col: isColumnsInfinite\n                ? { type: \"infinity\", sign: \"positive\" }\n                : { type: \"number\", value: origin.colIndex + columns - 1 },\n              row: isRowsInfinite\n                ? { type: \"infinity\", sign: \"positive\" }\n                : { type: \"number\", value: origin.rowIndex + rows - 1 },\n            },\n          };\n    };\n\n    // Calculate the origin result (top-left cell value)\n    const originResult: CellNumber = {\n      type: \"number\",\n      value: start,\n    };\n\n    if (isRangeOneCell(spillArea(context.cellAddress))) {\n      return {\n        type: \"value\",\n        result: originResult,\n      };\n    }\n\n    return {\n      type: \"spilled-values\",\n      spillArea,\n      source: \"SEQUENCE function\",\n      evaluate: (spillOffset, context) => {\n        if (hasArrayInput) {\n          // When we have array inputs, all cells in the broadcast area get the same SEQUENCE result\n          // The SEQUENCE is calculated once using the origin values from the input arrays\n\n          // For broadcasting, we always return the same sequence across all spilled cells\n          // Calculate the value for the origin cell of the SEQUENCE (always (0,0))\n          const x = 0;\n          const y = 0;\n\n          // Check if the origin cell is within our intended SEQUENCE area\n          if (\n            (!isColumnsInfinite && x >= columns) ||\n            (!isRowsInfinite && y >= rows)\n          ) {\n            return {\n              type: \"error\",\n              err: FormulaError.ERROR,\n              message: \"Error evaluating SEQUENCE\",\n              errAddress: context.dependencyNode,\n            };\n          }\n\n          // Calculate the sequential value for origin cell\n          // Since this is for broadcasting, we always use the origin (0,0) value\n          const sequenceIndex = 0;\n          const value = start + sequenceIndex * step;\n\n          return {\n            type: \"value\",\n            result: {\n              type: \"number\",\n              value,\n            },\n          };\n        } else {\n          // Normal SEQUENCE behavior - calculate the value for this spilled cell based on its offset\n          const x = spillOffset.x;\n          const y = spillOffset.y;\n\n          // Check if the spilled cell is within our intended area\n          if (\n            (!isColumnsInfinite && x >= columns) ||\n            (!isRowsInfinite && y >= rows)\n          ) {\n            return {\n              type: \"error\",\n              err: FormulaError.ERROR,\n              message: \"Error evaluating SEQUENCE\",\n              errAddress: context.dependencyNode,\n            };\n          }\n\n          // Calculate the sequential value\n          // Values are filled row by row: (0,0), (0,1), (0,2), ..., (1,0), (1,1), etc.\n          let sequenceIndex: number;\n          if (isColumnsInfinite && isRowsInfinite) {\n            // For infinite 2D sequences, we can't calculate a single index\n            // We'll use a simple pattern based on position\n            sequenceIndex = y + x;\n          } else if (isColumnsInfinite) {\n            // For infinite columns, sequence goes horizontally\n            sequenceIndex = x;\n          } else if (isRowsInfinite) {\n            // For infinite rows, sequence goes vertically\n            sequenceIndex = y;\n          } else {\n            // Finite dimensions - normal calculation\n            sequenceIndex = y * columns + x;\n          }\n\n          const value = start + sequenceIndex * step;\n\n          return {\n            type: \"value\",\n            result: {\n              type: \"number\",\n              value,\n            },\n          };\n        }\n      },\n      evaluateAllCells: function ({ evaluate, intersection, context, origin }) {\n        const results: CellInRangeResult[] = [];\n        let range = spillArea(origin);\n        if (intersection) {\n          const newRange = getRangeIntersection(range, intersection);\n          if (!newRange) {\n            throw new Error(\"Intersection is not valid #2\");\n          }\n          range = newRange;\n        }\n        if (\n          range.end.row.type === \"infinity\" ||\n          range.end.col.type === \"infinity\"\n        ) {\n          throw new EvaluationError(\n            FormulaError.REF,\n            `Can not evaluate all cells over an infinite range`\n          );\n        }\n\n        for (let i = range.start.row; i <= range.end.row.value; i++) {\n          for (let j = range.start.col; j <= range.end.col.value; j++) {\n            const offsetLeft = j - origin.colIndex;\n            const offsetTop = i - origin.rowIndex;\n\n            const evaled = evaluate({ x: offsetLeft, y: offsetTop }, context);\n            const relativePos = { x: offsetLeft, y: offsetTop };\n            results.push({ result: evaled, relativePos });\n          }\n        }\n\n        return { type: \"values\", values: results };\n      },\n    };\n  },\n};\n"
  ],
  "mappings": "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",
  "debugId": "F8677D1ADD5AA85464756E2164756E21",
  "names": []
}