@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/shared-string-registry.js

@@ -0,0 +1,248 @@
+import { produceWithPatches } from "immer";
+import { canonicalizeRichSharedString, contentHash } from "@rowsncolumns/utils";
+const SHARED_STRING_ID_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const SHARED_STRING_ID_LENGTH = 5;
+const MAX_SHORT_ID_ATTEMPTS = 32;
+export class SharedStringRegistry {
+    onChangeSharedStrings;
+    sharedStrings;
+    // Buffer of newly-interned entries flushed into `onChangeSharedStrings`
+    // on commit. Holds both plain strings and rich `{ text, runs }`
+    // values — the type widens to match `SharedStrings`.
+    incomingStrings = new Map();
+    constructor(sharedStrings, onChangeSharedStrings) {
+        this.onChangeSharedStrings = onChangeSharedStrings;
+        this.sharedStrings = sharedStrings;
+    }
+    get active() {
+        return !!(this.onChangeSharedStrings || this.sharedStrings);
+    }
+    getSharedStrings() {
+        return this.sharedStrings;
+    }
+    registerCell(sheetCell) {
+        if (!this.active) {
+            return;
+        }
+        const candidate = sheetCell.getSharedStringCandidate();
+        if (!sheetCell.shouldUseSharedStrings(candidate)) {
+            sheetCell.applySharedStringIndex(undefined);
+            return;
+        }
+        const existingIndex = sheetCell.getSharedStringIndex();
+        if (existingIndex != null) {
+            return;
+        }
+        if (!candidate) {
+            sheetCell.applySharedStringIndex(undefined);
+            return;
+        }
+        // Rich-text cells route through a parallel path that interns the
+        // text + runs together (matches XLSX `<si><r>` semantics, lets the
+        // renderer drop the per-cell `tf` field for SST-backed cells).
+        // Optional-chained so older mocks / non-SheetCell shapes that
+        // don't implement the helper still register as plain entries.
+        const richRuns = sheetCell.getSharedStringRichRuns?.();
+        const index = richRuns && richRuns.length > 0
+            ? this.getOrCreateRichIndex(candidate, richRuns)
+            : this.getOrCreateIndex(candidate);
+        sheetCell.applySharedStringIndex(index);
+    }
+    /**
+     * Get-or-create a rich shared-string slot. The hash input is the
+     * canonical (text + runs) form, so:
+     *   - rich entries dedupe with identical-content rich entries (one
+     *     slot for 1000 cells of bold "abc"),
+     *   - rich entries can't collide with a plain entry of the same
+     *     text (the canonical's `RICH_MARKER` prefix is never a valid
+     *     plain string), and
+     *   - two rich entries with same text but different runs land at
+     *     different ids.
+     */
+    getOrCreateRichIndex(text, runs) {
+        const canonical = canonicalizeRichSharedString(text, runs);
+        const existing = this.findExistingRichIndex(canonical);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const newId = this.createUniqueId(canonical);
+        this.incomingStrings.set(newId, { text, runs });
+        return newId;
+    }
+    findExistingRichIndex(canonical) {
+        const hashId = contentHash(canonical);
+        const matches = (entry) => !!entry &&
+            typeof entry === "object" &&
+            typeof entry.text === "string" &&
+            Array.isArray(entry.runs) &&
+            canonicalizeRichSharedString(entry.text, entry.runs) === canonical;
+        // Fast path: hash-derived id lives at exactly this key.
+        if (this.sharedStrings instanceof Map) {
+            if (matches(this.sharedStrings.get(hashId)))
+                return hashId;
+        }
+        if (matches(this.incomingStrings.get(hashId)))
+            return hashId;
+        // Slow path: legacy random-id rich entries (created before
+        // canonical hashing) — full scan, only used until those entries
+        // age out of the SST.
+        if (this.sharedStrings instanceof Map) {
+            for (const [id, value] of this.sharedStrings.entries()) {
+                if (matches(value))
+                    return id;
+            }
+        }
+        for (const [id, value] of this.incomingStrings) {
+            if (matches(value))
+                return id;
+        }
+        return undefined;
+    }
+    setSharedStrings(sharedStrings) {
+        this.sharedStrings = sharedStrings;
+    }
+    getOrCreateIndex(value) {
+        const existing = this.findExistingIndex(value);
+        if (existing !== undefined) {
+            return existing;
+        }
+        // Content hash gives stable IDs across sessions / clients / languages.
+        // Falls back to a random ID only if the hash collides with an existing
+        // *different* value (astronomically rare with 62^8 ids).
+        const newId = this.createUniqueId(value);
+        this.incomingStrings.set(newId, value);
+        return newId;
+    }
+    idExists(id) {
+        const sharedStrings = this.sharedStrings;
+        const mapLike = sharedStrings;
+        const arrayLike = sharedStrings;
+        return (this.incomingStrings.has(id) ||
+            Boolean(mapLike && mapLike instanceof Map && mapLike.has(id)) ||
+            Boolean(Array.isArray(arrayLike) &&
+                Number.isInteger(Number(id)) &&
+                Number(id) >= 0 &&
+                Number(id) < arrayLike.length &&
+                arrayLike[Number(id)] !== undefined));
+    }
+    createShortId() {
+        if (globalThis.crypto?.getRandomValues) {
+            const bytes = new Uint8Array(SHARED_STRING_ID_LENGTH);
+            globalThis.crypto.getRandomValues(bytes);
+            let id = "";
+            for (let i = 0; i < bytes.length; i += 1) {
+                id +=
+                    SHARED_STRING_ID_ALPHABET[bytes[i] % SHARED_STRING_ID_ALPHABET.length];
+            }
+            return id;
+        }
+        let id = "";
+        for (let i = 0; i < SHARED_STRING_ID_LENGTH; i += 1) {
+            id +=
+                SHARED_STRING_ID_ALPHABET[Math.floor(Math.random() * SHARED_STRING_ID_ALPHABET.length)];
+        }
+        return id;
+    }
+    createUniqueId(value) {
+        // Legacy array mode still exists in some tests/call sites. Keep numeric IDs there.
+        if (Array.isArray(this.sharedStrings)) {
+            let nextIndex = this.sharedStrings.length;
+            while (this.idExists(String(nextIndex))) {
+                nextIndex += 1;
+            }
+            return String(nextIndex);
+        }
+        // Try content hash first when we have the value. `findExistingIndex`
+        // already deduped same-value entries, so if the hash id is taken it must
+        // belong to a *different* value — fall through to the random path.
+        if (value !== undefined) {
+            const hashId = contentHash(value);
+            if (!this.idExists(hashId)) {
+                return hashId;
+            }
+        }
+        for (let i = 0; i < MAX_SHORT_ID_ATTEMPTS; i += 1) {
+            const shortId = this.createShortId();
+            if (!this.idExists(shortId)) {
+                return shortId;
+            }
+        }
+        const randomUuid = globalThis.crypto?.randomUUID?.();
+        if (randomUuid) {
+            const fallbackId = `s_${randomUuid}`;
+            if (!this.idExists(fallbackId)) {
+                return fallbackId;
+            }
+        }
+        let fallbackId = "";
+        do {
+            fallbackId = `s_${Date.now().toString(36)}_${Math.random()
+                .toString(36)
+                .slice(2, 12)}`;
+        } while (this.idExists(fallbackId));
+        return fallbackId;
+    }
+    findExistingIndex(value) {
+        const sharedStrings = this.sharedStrings;
+        // Only dedup against PLAIN entries. A rich entry that happens to
+        // share the same plain text MUST NOT be reused — doing so would
+        // silently inherit its formatting onto a cell that asked for
+        // plain text. Rich entries skip dedup entirely (each rich cell
+        // gets its own slot via `createRichEntry`).
+        const isPlainMatch = (entry) => typeof entry === "string" && entry === value;
+        // Fast path: any plain value added via content hash lives at this id.
+        if (sharedStrings instanceof Map) {
+            const hashId = contentHash(value);
+            if (isPlainMatch(sharedStrings.get(hashId)))
+                return hashId;
+            if (isPlainMatch(this.incomingStrings.get(hashId)))
+                return hashId;
+        }
+        // Slow path: scan for legacy random-id entries that predate content
+        // hashing. Same rule — only PLAIN entries are dedup candidates.
+        if (sharedStrings && sharedStrings instanceof Map) {
+            for (const [id, str] of sharedStrings.entries()) {
+                if (isPlainMatch(str)) {
+                    return id;
+                }
+            }
+        }
+        if (Array.isArray(sharedStrings)) {
+            for (let i = 0; i < sharedStrings.length; i += 1) {
+                if (sharedStrings[i] === value) {
+                    return String(i);
+                }
+            }
+        }
+        for (const [id, incomingValue] of this.incomingStrings) {
+            if (isPlainMatch(incomingValue)) {
+                return id;
+            }
+        }
+        return undefined;
+    }
+    getPatches(saveHistory) {
+        if (!this.onChangeSharedStrings) {
+            this.incomingStrings.clear();
+            return;
+        }
+        if (this.incomingStrings.size === 0) {
+            return;
+        }
+        const incomingSharedStrings = Array.from(this.incomingStrings.entries());
+        this.onChangeSharedStrings((prev) => {
+            // Immer supports both Map and Array
+            const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                for (const [id, value] of incomingSharedStrings) {
+                    draft.set(id, value);
+                }
+                this.incomingStrings.clear();
+            });
+            saveHistory({
+                sharedStrings: { patches, inversePatches },
+            });
+            this.sharedStrings = nextState;
+            return nextState;
+        });
+    }
+}

package/dist/esm/sheet-cell.d.ts

@@ -0,0 +1,310 @@
+import type { CellInterface, GridRange, HyperlinkValue } from "@rowsncolumns/common-types";
+import type { Border, Borders, CellData, CellFormat, ConditionValue, DataValidationRule, DataValidationRuleRecord, ExtendedValue, FormattingType, FormattingValue, HorizontalAlign, NumberFormat, NumberFormatType, PivotTable, StyleReference, TextFormat } from "@rowsncolumns/spreadsheet";
+import type { TextFormatRun } from "@rowsncolumns/ui";
+import { type Draft } from "immer";
+import type { FormulaToRelativeReferenceOptions } from "./api/formula";
+import type { CalculationResult } from "./hooks/use-calculation";
+import type { CellXfsRegistry } from "./hooks/use-cellxfs-registry";
+import type { SharedStringRegistry } from "./hooks/use-ss-registry";
+import type { SharedStrings } from "./types";
+export declare const defaultSheetId = 1;
+export declare const defaultCellCoords: CellInterface;
+type SheetCellOptions = {
+    getRangeValues?: (address: string) => ConditionValue[];
+    locale?: string;
+    use1904?: boolean;
+    lenientGrouping?: boolean;
+    enableAtFormula?: boolean;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDataValidationById?: (id: DataValidationRuleRecord["id"]) => DataValidationRuleRecord | undefined;
+};
+export declare function isStyleReference(obj: any): obj is StyleReference;
+/**
+ * Marker persisted as `fv` on cells whose calculation is in flight (set by
+ * `setLoading()`). Exported so other modules can detect the loading state
+ * from cellData without a stringly-typed comparison.
+ */
+export declare const LOADING_VALUE = "Loading...";
+export declare class SheetCell<T extends CellData = CellData> {
+    private static defaultSharedStrings;
+    private static defaultEnableAtFormula;
+    sheetId: number;
+    coords: CellInterface;
+    value: string | undefined;
+    userEnteredValue: ExtendedValue | undefined | null;
+    effectiveValue: T["effectiveValue"] | undefined;
+    formattedValue: string | undefined | null;
+    textFormatRuns: TextFormatRun[] | undefined | null;
+    userEnteredFormat: CellFormat | undefined | null;
+    dataValidationId: DataValidationRuleRecord["id"] | undefined;
+    dataValidationRule: DataValidationRuleRecord | undefined | DataValidationRule;
+    conditionalFormattingResultById: T["conditionalFormattingResultById"] | undefined;
+    dataValidationResult: T["dataValidationResult"] | undefined;
+    defaultPattern: string;
+    loadingValue: string;
+    isLoading: boolean;
+    hyperlink: string | HyperlinkValue | undefined;
+    imageUrl?: string;
+    getRangeValues?: (address: string) => ConditionValue[];
+    locale: string | undefined;
+    use1904: boolean | undefined;
+    lenientGrouping: boolean | undefined;
+    note: string | undefined;
+    commentThreadId: string | number | undefined;
+    citationId: string | undefined;
+    metaType: string | undefined;
+    expandable: boolean | undefined;
+    expanded: boolean | undefined;
+    cellData: T | Draft<T> | undefined | null;
+    formatColor: string | undefined;
+    cellXfsRegistry: CellXfsRegistry | undefined;
+    sharedStringRegistry: SharedStringRegistry | undefined;
+    sharedStrings: SharedStrings | undefined | null;
+    sharedStringIndex: number | string | undefined;
+    enableAtFormula: boolean | undefined;
+    originalUserEnteredFormat: CellFormat | StyleReference | undefined | null;
+    pivotId?: PivotTable["pivotId"] | null;
+    groupKeys?: string[] | null;
+    version?: number | undefined | null;
+    updatedAt?: number | undefined | null;
+    arrayFormulaRef: string | undefined;
+    sharedFormulaSpec: {
+        si: number;
+        ref?: string;
+    } | undefined;
+    setVersion(version?: number | null): void;
+    setUpdatedAt(timestamp?: number | null): void;
+    static setDefaultSharedStrings(sharedStrings?: SharedStrings | null): void;
+    static setDefaultEnableAtFormula(enable?: boolean): void;
+    constructor(sheetId?: number, coords?: CellInterface, cellData?: Draft<T> | T | undefined | null, options?: SheetCellOptions);
+    setLocale(locale?: string): void;
+    setUse1904(use1904?: boolean): void;
+    assign(sheetId?: number, coords?: CellInterface, cellData?: Draft<T> | T | undefined | null, options?: SheetCellOptions): this;
+    get key(): string;
+    cloneWithFormatting(): this;
+    updateNote(note: string | undefined): void;
+    updateCommentThreadId(commentThreadId: string | number | undefined): void;
+    clearCommentThreadId(): void;
+    updateCitationId(citationId: string | undefined): void;
+    clearCitationId(): void;
+    static generateCellKey(sheetId: number, rowIndex: number, columnIndex: number): string;
+    /**
+     * Clears the cell's content (value, formatted value, links,
+     * notes, comments, shared-string refs, etc.).
+     *
+     * Formatting behavior is intentionally Del-key-compatible by
+     * default — Excel's Delete clears value but keeps bold / fill /
+     * etc. so users don't lose their styling when they wipe a cell.
+     * Pass `clearFormat: true` for callers that want unconditional
+     * full-clear semantics (e.g. pivot tear-down regenerating cells,
+     * "Clear All" toolbar action).
+     *
+     * Even without `clearFormat`, the method still strips
+     * `userEnteredFormat` when the existing numberFormat is one of
+     * the implicit defaults (`NUMBER` with `pattern_number` /
+     * `pattern_number_thousands`, or `TEXT`) — those formats are
+     * auto-applied based on the value's type and shouldn't outlive
+     * the value. Explicit user-applied formats (bold, fill,
+     * custom number formats) are preserved.
+     */
+    deleteContents(options?: {
+        preserveTextNumberFormat?: boolean;
+        clearFormat?: boolean;
+        clearDataValidation?: boolean;
+    }): void;
+    deleteUserEnteredFormat(): void;
+    /**
+     * Copy a `userEnteredFormat` from a source format onto this cell.
+     * No-op when this cell already has a format, or when the source is
+     * empty. Used by table row-expansion to propagate column-consistent
+     * formats onto newly added rows (Excel parity).
+     */
+    inheritFormat(format: CellFormat | StyleReference | undefined | null): void;
+    changeFormulaSheetName(name: string, oldName: string): void;
+    changeNamedRangeName(name: string, oldName: string): void;
+    changeFormulaColumnName(name: string, previousName: string): void;
+    setLoading(): void;
+    hideLoading(): void;
+    get formula(): string | undefined;
+    get error(): any;
+    /**
+     * True when the current value violates the cell's data-validation rule
+     * AND the rule blocks entry. Excel's default errorStyle is "stop" — only
+     * an explicit warning/information alert downgrades the rule (mirroring
+     * the agent-write guard's strictness).
+     *
+     * Unlike `validate()`, this checks the rule SYNCHRONOUSLY via
+     * `checkBooleanRule` even for condition types that `validate()` routes
+     * through the calculator (ONE_OF_LIST dropdowns etc.) — a programmatic
+     * write path needs the verdict before committing, not one calc tick
+     * later. CUSTOM_FORMULA rules (calculator-only), rules that error while
+     * evaluating, and ONE_OF_RANGE without a range resolver all fail open,
+     * matching the agent-write guard. Used by `changeBatchStream` with
+     * `skipInvalidValues` to drop the write silently; interactive editing
+     * keeps its dialog flow.
+     */
+    get failsBlockingValidation(): boolean;
+    static getRelativeFormula(value: any, from: CellInterface, to: CellInterface, activeSheetName?: string, exclusionRange?: GridRange, ignoreCircular?: boolean, rowCount?: number, columnCount?: number, preserveAbsolutes?: boolean): string | undefined;
+    moveFormula(from: CellInterface, to: CellInterface, activeSheetName: string, options?: FormulaToRelativeReferenceOptions): void;
+    isFormula(): boolean;
+    isStructuredReferenceFormula(): boolean | "" | undefined;
+    ephemeral(): boolean | undefined;
+    isEmpty(): boolean;
+    isNumberType<T extends NumberFormatType>(numType: T | undefined): numType is T;
+    changeDecimals(delta?: number): void;
+    decreaseDecimals(): void;
+    increaseDecimals(): void;
+    setBorder(position: keyof Borders, border: Border): void;
+    setUserEnteredBorder(position: keyof Borders, border: Border): void;
+    setAllBorders(border: Border): void;
+    clearAllBorders(): void;
+    setImage(imageUrl: string): void;
+    isMultiline(): boolean;
+    /**
+     * Over write formatted value
+     * @param value
+     */
+    setFormattedValue(value: string | undefined): void;
+    setUserEnteredValue(value: string | number | boolean | Date | undefined | null, textFormatRuns?: TextFormatRun[] | null, options?: {
+        disableTypeInference?: boolean;
+    }): this;
+    private clearUserEnteredValue;
+    clearEffectiveValueForFormula(): void;
+    private setUserEnteredValueByType;
+    private ensureUserEnteredFormatMutable;
+    private ensureFormatsMutable;
+    private setBooleanValue;
+    private setNumberValue;
+    private normalizeUserEnteredNumber;
+    private shouldPreserveExistingFormat;
+    private getStringValueForFormat;
+    setFormulaValue(formulaValue: string, clearEffectiveValue?: boolean): void;
+    private setStringValue;
+    getSharedStringCandidate(): string | undefined;
+    /**
+     * Runs attached to this cell at write-time. The shared-string
+     * registry calls this to decide whether to intern a plain or rich
+     * SST entry. Returns `undefined` when the cell has no per-segment
+     * formatting (plain interning path stays unchanged).
+     */
+    getSharedStringRichRuns(): TextFormatRun[] | undefined;
+    shouldUseSharedStrings(candidate?: string | null): boolean;
+    getSharedStringIndex(): string | number | undefined;
+    applySharedStringIndex(index?: number | string): void;
+    clearSharedStringIndex(): void;
+    private hydrateSharedStringValue;
+    validate(): void;
+    setConditionalFormatResult(ruleId: number | string, value: CalculationResult): void;
+    clearConditionalFormatResults(): void;
+    setDataValidationResult(value: CalculationResult): void;
+    /**
+     * Refresh formatted value
+     * from effective value and effective format
+     */
+    refreshFormattedValue(): void;
+    setEffectiveValue(value: CalculationResult, isPreview?: boolean, preserveStringLiteral?: boolean): this;
+    private clearEffectiveValue;
+    private setErrorValue;
+    private removeErrorValue;
+    setStructuredValue(structuredValue: NonNullable<NonNullable<T["effectiveValue"]>["structuredValue"]>): void;
+    private setEffectiveNumberValue;
+    private setEffectiveStringValue;
+    private setEffectiveBooleanValue;
+    setHyperlink(hyperlink: string | HyperlinkValue, title?: string | null): void;
+    setUrl(url: string, title?: string | null): void;
+    deleteUrl(): void;
+    setDataValidation(dataValidationId: DataValidationRuleRecord["id"], dataValidationRule?: DataValidationRuleRecord): void;
+    deleteDataValidation(): void;
+    clearUserEnteredFormat(): void;
+    setUserEnteredFormat<T extends FormattingType>(type: T, value: FormattingValue<T>): void;
+    private setTextFormat;
+    private setBorders;
+    private setNumberFormat;
+    private formatAsText;
+    private formatAsNumber;
+    getEffectiveValue(): string | number | boolean | undefined;
+    getUserEnteredValue(): string | number | boolean | undefined;
+    getNumberFormat(): import("@rowsncolumns/spreadsheet").Maybe<NumberFormat>;
+    processDerivedCell(cellData: Draft<T>): void;
+    isDate(numberFormat: NumberFormat | undefined | null): boolean;
+    isDateTime(numberFormat: NumberFormat | undefined | null): boolean;
+    isText(numberFormat: NumberFormat | undefined | null): boolean;
+    setGroupKeys(groupKeys: string[] | undefined | null): void;
+    changeIndent(size?: number): void;
+    setPivotId(pivotId: PivotTable["pivotId"] | undefined | null): void;
+    expand(): void;
+    collapse(): void;
+    setExpandable(expandable: boolean): void;
+    setArrayFormulaRef(ref: string | undefined | null): void;
+    clearArrayFormulaRef(): void;
+    setSharedFormulaSpec(spec: {
+        si: number;
+        ref?: string;
+    } | undefined | null): void;
+    clearSharedFormulaSpec(): void;
+    increaseIndent(): void;
+    decreaseIndent(): void;
+    clearFormatting(): void;
+    clearHyperlink(): void;
+    inheritCellData(cellData: T | Draft<T> | null | undefined): void;
+    getUserCellData(): any;
+    extendCellData(newCellData: T | null | undefined): void;
+    getUserEnteredFormat(): CellFormat | StyleReference | null | undefined;
+    /**
+     * Returns the user-entered format. The "effective" format (uf + auto-
+     * derived alignment / pattern color / formula-precedent number format /
+     * conditional formatting) is computed at render time by
+     * `useSheetProperties.getEffectiveFormat`. SheetCell no longer maintains
+     * a separate in-memory effective format.
+     *
+     * Loading-state alignment override is preserved for legacy callers that
+     * sniff this method while a cell is being recalculated.
+     */
+    getEffectiveCellFormat(): CellFormat | undefined;
+    getCellFormats(disableRegistry?: boolean): {
+        uf?: undefined;
+    } | {
+        uf: {
+            backgroundColor?: import("@rowsncolumns/spreadsheet").Maybe<import("@rowsncolumns/spreadsheet").Color>;
+            borders?: import("@rowsncolumns/spreadsheet").Maybe<Borders>;
+            textFormat?: import("@rowsncolumns/spreadsheet").Maybe<TextFormat>;
+            numberFormat?: import("@rowsncolumns/spreadsheet").Maybe<NumberFormat>;
+            horizontalAlignment?: import("@rowsncolumns/spreadsheet").Maybe<HorizontalAlign>;
+            verticalAlignment?: import("@rowsncolumns/spreadsheet").Maybe<import("@rowsncolumns/spreadsheet").VerticalAlign>;
+            wrapStrategy?: import("@rowsncolumns/spreadsheet").Maybe<import("@rowsncolumns/spreadsheet").WrapStrategy>;
+            indent?: import("@rowsncolumns/spreadsheet").Maybe<number>;
+            relativeIndent?: import("@rowsncolumns/spreadsheet").Maybe<number>;
+            textRotation?: import("@rowsncolumns/spreadsheet").Maybe<number | "vertical">;
+            shrinkToFit?: import("@rowsncolumns/spreadsheet").Maybe<boolean>;
+            fillPattern?: import("@rowsncolumns/spreadsheet").Maybe<import("@rowsncolumns/spreadsheet").FillPattern>;
+            foregroundColor?: import("@rowsncolumns/spreadsheet").Maybe<import("@rowsncolumns/spreadsheet").Color>;
+            gradient?: import("@rowsncolumns/spreadsheet").Maybe<import("@rowsncolumns/spreadsheet").GradientFill>;
+            conditionalIcon?: import("@rowsncolumns/spreadsheet").Maybe<{
+                glyph: string;
+                color?: import("@rowsncolumns/spreadsheet").Maybe<string>;
+                iconSet?: import("@rowsncolumns/spreadsheet").Maybe<string>;
+                iconId?: import("@rowsncolumns/spreadsheet").Maybe<number>;
+            }>;
+            conditionalDataBar?: import("@rowsncolumns/spreadsheet").Maybe<{
+                color: string;
+                fillFraction: number;
+                negative?: boolean;
+                borderColor?: string;
+                direction?: "leftToRight" | "rightToLeft";
+            }>;
+        } | {
+            styleId: string;
+            sid?: import("@rowsncolumns/common-types").Maybe<string>;
+        } | {
+            styleId?: import("@rowsncolumns/common-types").Maybe<string>;
+            sid: string;
+        };
+    };
+    get isModified(): boolean;
+    getCellData(options?: {
+        disableRegistry?: boolean;
+    }): Draft<T> | null;
+}
+export {};
+//# sourceMappingURL=sheet-cell.d.ts.map

package/dist/esm/sheet-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet-cell.d.ts","sourceRoot":"","sources":["../../sheet-cell.ts"],"names":[],"mappings":"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"}