SheetXL - v1.0.2
    Preparing search index...

    Variable FeatureConst

    Feature: {
        Alignment: "alignment";
        Anomalies: "anomalies";
        AutoTable: "autoTable";
        Borders: "borders";
        CalcError: "calcError";
        CalcStatus: "calcStatus";
        CellControl: "cellControl";
        Circular: "circular";
        Comments: "comments";
        Conditionals: "conditionals";
        Contentful: "contentful";
        DataValidations: "dataValidations";
        DateFormat: "dateFormat";
        Error: "error";
        Fill: "fill";
        Font: "font";
        Formula: "formula";
        Hyperlink: "hyperlink";
        IgnoredErrors: "ignoredErrors";
        Kind: "kind";
        Merge: "merge";
        NumberFormat: "numberFormat";
        Pivot: "pivot";
        Protection: "protection";
        Role: "role";
        Sparkline: "sparkline";
        Spills: "spills";
        Table: "table";
        Unlock: "unlock";
    } = ...

    The public feature vocabulary — what a cell or range carries, as a queryable dimension.

    Type Declaration

    • ReadonlyAlignment: "alignment"

      Direct alignment.

    • ReadonlyAnomalies: "anomalies"

      Cells where an error check fires — what breaks the pattern around it. Regions group by the check and its evidence, so a filled row that breaks the same way is one region; the anchor cell's ICell.getAnomalies is the payload.

      Excel's background error checks, run over this vocabulary's own partitions rather than cell by cell: a formula region whose neighbors on both sides agree with each other and not with it (formula), a range that stops one number short (formulaRange), text that reads as a number (numberStoredAsText), a reference to an empty cell (emptyCellReference), a formula left unlocked (unlockedFormula). The first of these is one rule SheetXL runs on other layers too: a typed value in a run of formulas (hardcodeInRun), and an authored format that breaks the run around it (styleBreak); and a format part paired with the cell's role, a link left black where links are green (styleRole). Then SheetXL's own, read from what a formula says: a cell counted twice in one sum (repeatedReference), an aggregate of one cell or of typed numbers (degenerateCall), a sum holding its own subtotal (sumIncludesSubtotal), a total that also adds a cell outside its block (misalignedReference), a nearest-key lookup (approximateMatch), lookup arrays that do not line up (lookupShape), a reference outside the workbook (externalReference); and from labels: a link whose target row is labeled otherwise (linkLabelMismatch), a lookup key that is not the row's or column's label (keyLabelMismatch), a link with the other sign from its siblings (signVsSiblings); and from the numbers: a typed number in a formula equal to an input nothing reads (literalMatchesInput), twin formulas that differ in a unit literal or a sign (twinBlockDivergence), a percent typed as a whole number (scaleOutlier), every constant a formula types with how often the workbook types it (constantFrequency). An ignored check (ICellRange.setErrorIgnored) does not fire.

      Regions list highest rank first (ICell.Anomaly.rank), unless an axis is asked for.

      The checks that read a formula need the calculation engine to have loaded its parser, and those that read its references need it to have compiled the formula; with the engine off they do not fire.

      Derived on first read and cached until the sheet changes, so ICellRange.getCounts counts it only when asked for by name; otherwise its key is absent, never 0.

    • ReadonlyAutoTable: "autoTable"

      Auto-table membership.

    • ReadonlyBorders: "borders"

      Direct borders.

    • ReadonlyCalcError: "calcError"

      Evaluated state: cells whose calculation itself failed. Distinct from Feature.Error: #DIV/0! is a successfully calculated error VALUE (the Error kind); CalcError is the engine failing to evaluate at all. A reference cycle is not a failure — its cells evaluate, to 0 — and is Feature.Circular.

    • ReadonlyCalcStatus: "calcStatus"

      Evaluated state: cells whose result has not settled. Regions group by status — a cell whose own function has not answered yet (ICalculation.ResultStatus.Pending), or one calculated from such a value and calculated again when it arrives (ICalculation.ResultStatus.Waiting). The anchor's getCalculationStatus() is the payload. Empty once every answer has landed.

    • ReadonlyCellControl: "cellControl"

      Cells under a cell control (ICellRange.setControl). Regions group by the control's definition (its type and properties), so adjacent checkboxes set in two strokes are one region and a checkbox beside a rating are two; the anchor cell's ICell.getControl is the payload. Whether a cell draws its control depends on its value, which is a Kind question: ask for both to split a column of checkboxes from the text cells among them.

    • ReadonlyCircular: "circular"

      Evaluated state: cells in a reference cycle, or downstream of one. Both evaluate to 0 (Excel, iterative calculation off) with nothing else to show for it — this is the marker. Regions group by cycle and by kind (member | downstream), so a block that reads one bad cell is ONE region, and each region's payload is the cycle itself (ICalculation.ICircularReference — members, counts, whether iteration settled it).

    • ReadonlyComments: "comments"

      Has comments.

    • ReadonlyConditionals: "conditionals"

      Cells under conditional-format rules.

    • ReadonlyContentful: "contentful"

      Occupancy — splits on blank/non-blank, Excel CurrentRegion semantics.

    • ReadonlyDataValidations: "dataValidations"

      Cells under data-validation rules.

    • ReadonlyDateFormat: "dateFormat"

      A date-category number format, given directly or by a named style — yyyy-mm-dd, mm/dd/yyyy, and the like.

      A formatting predicate, not a value kind: a blank cell or a text cell formatted this way carries DateFormat too, the same way a blank cell can carry Fill. It says nothing about whether the cell holds a genuine date — that is a question about the VALUE (numeric value under this format), answered by getInteropType() on the cell, not by this feature. See this enum's own remarks for why the two are kept apart rather than fused into one "Date" concept.

    • ReadonlyError: "error"

      Scalar kind: error values (#DIV/0!, #N/A, …), literal or calculated.

    • ReadonlyFill: "fill"

      Direct fill.

    • ReadonlyFont: "font"

      Direct font.

    • ReadonlyFormula: "formula"

      Has a formula. Regions group by canonical R1C1 — a shared formula block is one region.

    • Has a hyperlink. Regions group by what the link says, so the same link set twice is one region.

    • ReadonlyIgnoredErrors: "ignoredErrors"

      Ignores one or more of Excel's error checks. Regions group by the set of checks ignored.

    • ReadonlyKind: "kind"

      What a cell holds: a number, a date, text, text that would enter as a number, a boolean, an error or rich data. A formula cell is the kind of its result.

      Regions group by kind, so a column of numbers with one text cell in it is three regions. A date is a number under a date or time format (the cell's getInteropType() is date). Text that a typed entry would read as a number ('123, a number imported as text) is a kind of its own, apart from other text: it is Excel's number stored as text. The anchor's getInteropType() names the kind of every other region.

      Derived from the values on first read and cached until the sheet changes.

    • ReadonlyMerge: "merge"

      Merged spans.

    • ReadonlyNumberFormat: "numberFormat"

      A number format given directly or by a named style, not one left at Normal's. Region payloads carry the format string and its category, so a block with 0% set directly and one with the Percent style are one region.

    • ReadonlyPivot: "pivot"

      Cells a pivot table is laid out over, the page fields above it included. A blocked table covers none; ICellRange.getPivotTables names the tables over a range.

    • ReadonlyProtection: "protection"

      Direct cell protection format (ICellStyle.getProtection()): always unlocked, show formulas. A cell with none of its own reads its named style's, then Normal's.

    • ReadonlyRole: "role"

      A cell's job in the model (ICell.Role): a typed label or input, a link to another sheet, a reference on this sheet, a computed cell or an output, from what the cell reads and who reads it. The anchor's ICell.getRole is the payload.

      The kind layer refined by the formulas: a column of typed numbers a model reads is one input region, the links beside it another. Crossed with a format (['role', 'font']) it is the census a color convention is judged by, and what the styleRole check reads.

      Derived on first read (the formulas parsed once) and cached until the sheet changes, so ICellRange.getCounts counts it only when asked for by name, like anomalies.

    • ReadonlySparkline: "sparkline"

      Cells with a sparkline (IWorksheet.getSparklineGroups). Regions group by the sparkline group, so two groups side by side are two regions.

    • ReadonlySpills: "spills"

      Cells inside a dynamic-array spill zone. Writing into one is a real failure mode.

    • ReadonlyTable: "table"

      Table membership.

    • ReadonlyUnlock: "unlock"

      Unlocked cells — covered by an unlocked range, or with an always-unlocked style. Can I write here is a precondition, not a detail.

    This is the agent-facing read vocabulary: getCounts, getRegions and isContentful select by it, and the agent read tools (grep, the regions read) use the same words. It is deliberately distinct from ICell.Content, the transfer vocabulary (clear, copyFrom) — "paste formats" is a coarse transfer bucket, while querying wants the split parts (Fill, Border, NumberFormat…). One enum serving both jobs is how the vocabulary got muddy the first time.

    Members map onto the engine's per-feature spatial indexes. The mapping is internal and not one-to-one: several features may project from one index (NumberFormat/Alignment/Font over the content-style map). Notes joins when the backing is implemented; a feature that silently reports nothing is worse than a missing one.

    String/Number/Boolean are deliberately absent as separate members, even though they are real ScalarType values. "How many numbers" is a count read straight off the values, which is exactly the one pass IRangeStats.getTypedCounts() already makes, richer (it composes with aggregates and frequencies for free, in the same call) — range.getStats() is the vocabulary for that. Where the numbers are is a partition, and that is the one Feature.Kind answers: a typed row inside a block of text is a region of its own.

    Error stays, for a reason unrelated to the above: it has real spatial identity of its own (the reconciled error view) and partitions like any stored feature — it was never in the same boat as the other three. DateFormat stays too, but as exactly what its name says: a formatting predicate, the same tier as NumberFormat/Alignment/Font, not a value kind — it answers "does this cell carry a date-category number format", nothing about what the value underneath actually is. A caller after "how many cells are genuinely dates" (numeric value AND that format) composes it: DateFormat regions intersected with getStats().getTypedCounts()'s Number — there is deliberately no single feature that already does that intersection, because "is this a date" is a computed fact about a cell's value, read through getInteropType(), not a thing this vocabulary partitions on.