@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

package/types/src/sheet/style/SheetCellStyle.d.ts

@@ -0,0 +1,540 @@
+import { Properties as CSSProperties } from 'csstype';
+import { Scalar, IRange } from '@sheetxl/primitives';
+import { Size, Rectangle } from '@sheetxl/utils';
+import { IProperties } from '../../type';
+import { IColor } from '../../color';
+import { IFill } from '../../fill';
+import { IFont } from '../../font';
+import { ITextFrame, IStyledFont } from '../../text';
+import { IBorder } from '../../border';
+import { IStyle, IStyleCollection } from '../../style';
+export interface CreateCellStyleOptions {
+    styles: IStyleCollection;
+    /**
+     * Does not include empty or normal style
+     */
+    properties: IStyle.Properties | IStyle.Properties[];
+    /**
+     * Used if clone is called.
+     */
+    direct: IProperties.ICellRanged<IStyle.Properties, IStyle.Modifiers>;
+    /**
+     * A cell style is a specific coords (may be undefined for temporary/coordless cells)
+     */
+    range: IRange.Coords | undefined;
+    /**
+     * The range this style was **queried for**, when that is wider than the cell it materialized at.
+     *
+     * @remarks
+     * Every value on a style is the anchor cell's — that is the contract, and the ribbon behavior
+     * it models. The one exception is the inner border rules, which have no meaning at a cell and
+     * are read at the extent they were authored over. Undefined for a cell read, and for a
+     * multi-area selection (discontiguous areas have no single inside).
+     */
+    extent?: IRange.Coords;
+    /**
+     * For updating styles from accessors
+     */
+    updater: CellStyleUpdater;
+}
+export interface CellStyleUpdater {
+    (update: IStyle.Update, options?: IStyle.UpdateOptions, range?: IRange.Coords): IStyle;
+}
+/**
+ * This is for cell styles that don't have specific properties per row,column
+ */
+export declare function resolveStyleUpdate(update: IStyle.Update, prev: (() => IStyle) | IStyle): IStyle.Modifiers;
+declare class InheritableProperties<P, J> {
+    protected _p: readonly Readonly<P>[];
+    constructor(properties: Readonly<P> | readonly Readonly<P>[]);
+    /**
+     *  Use when returning a left value
+     * @param key
+     * @returns
+     */
+    value(key: keyof P): any;
+    /**
+     * Use when wrapping another object that will also inherit.
+     *
+     * @returns `undefined` if no layer defines the key.
+     */
+    values(key: keyof P): any[] | undefined;
+    getProperties(): P | null;
+    toJSON(): J;
+}
+/**
+ * This module has implementations of IStyles that are 'pipelined' together.
+ */
+/**
+ * Subclassed by items that have properties that can be inherited.
+ */
+declare class Inheritable<P, J> {
+    protected _o: CreateCellStyleOptions;
+    protected _p: readonly P[];
+    protected _c: IStyleCollection;
+    constructor(options: CreateCellStyleOptions, properties: P[]);
+    protected _setValue(key: keyof P, value: any): any;
+    /**
+     *  Use when returning a left value
+     * @param key
+     * @returns
+     */
+    protected _value(key: keyof P): any;
+    /**
+     * Use when wrapping another object that will also inherit.
+     *
+     * @returns `undefined` if no layer defines the key.
+     */
+    protected _values(key: keyof P): any[] | undefined;
+    getProperties(): P;
+    toJSON(): J;
+}
+export declare class CellBorderStroke extends Inheritable<IBorder.StrokeProperties, IBorder.StrokeJSON> implements IBorder.IStroke {
+    protected _edge: IBorder.Edge;
+    constructor(edge: IBorder.Edge, options: CreateCellStyleOptions, properties: IBorder.StrokeProperties[]);
+    /** {@inheritDoc IBorder.IStroke.getStyle} */
+    getStyle(): IBorder.StrokeStyle;
+    /** {@inheritDoc IBorder.IStroke.setStyle} */
+    setStyle(style: IBorder.StrokeStyle | string | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
+    /** {@inheritDoc IBorder.IStroke.getColor} */
+    getColor(): IColor;
+    /** {@inheritDoc IBorder.IStroke.setColor} */
+    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
+    /** {@inheritDoc IBorder.IStroke.isNone} */
+    isNone(): boolean;
+    /** {@inheritDoc IBorder.IStroke.toCSS} */
+    toCSS(): Partial<CSSStyleDeclaration>;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IBorder.IStroke.isIStroke} */
+    get isIStroke(): true;
+}
+export declare class CellBorder extends Inheritable<IBorder.Properties, IBorder.JSON> implements IBorder {
+    protected _left: IBorder.IStroke | undefined;
+    protected _right: IBorder.IStroke | undefined;
+    protected _top: IBorder.IStroke | undefined;
+    protected _bottom: IBorder.IStroke | undefined;
+    protected _diagUp: IBorder.IStroke | undefined;
+    protected _diagDown: IBorder.IStroke | undefined;
+    protected _isEmpty: boolean | undefined;
+    /** {@inheritDoc IBorder.getLeft} */
+    getLeft(): IBorder.IStroke;
+    /** {@inheritDoc IBorder.setLeft} */
+    setLeft(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.getRight} */
+    getRight(): IBorder.IStroke;
+    /** {@inheritDoc IBorder.setRight} */
+    setRight(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.getTop} */
+    getTop(): IBorder.IStroke;
+    /** {@inheritDoc IBorder.setTop} */
+    setTop(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.IStroke.getBottom} */
+    getBottom(): IBorder.IStroke;
+    /** {@inheritDoc IBorder.setBottom} */
+    setBottom(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.getHorizontal} */
+    getHorizontal(): IBorder.IStroke | null;
+    /** {@inheritDoc IBorder.getVertical} */
+    getVertical(): IBorder.IStroke | null;
+    /**
+     * The inner rule for an axis, read from the authored block rather than the cell.
+     *
+     * @remarks
+     * Not `_values(edge)`: the inheritance layers are the CELL's properties, where an inner rule
+     * has already been decomposed into the edges it produces. The rule only exists on the block,
+     * so this goes back to it — which is also why it needs `extent`, and answers `null` without one.
+     * @internal
+     */
+    private _inner;
+    /** {@inheritDoc IBorder.IStroke.getDiagonalUp} */
+    getDiagonalUp(): IBorder.IStroke;
+    /** {@inheritDoc IBorder.setDiagonalUp} */
+    setDiagonalUp(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.getDiagonalDown} */
+    getDiagonalDown(): IBorder.IStroke;
+    /** {@inheritDoc IBorder.setDiagonalDown} */
+    setDiagonalDown(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.setVertical} */
+    setVertical(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.setHorizontal} */
+    setHorizontal(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorder.setHorizontal} */
+    setOutline(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /**
+     * Resolves whether an edge's effective stroke style is `None` without allocating a
+     * `CellBorderStroke`. Mirrors `CellBorderStroke.getStyle()` (last-defined `style` across layers,
+     * honoring per-property inheritance).
+     */
+    protected _edgeStyleIsNone(edge: IBorder.Edge): boolean;
+    /** {@inheritDoc IBorder.IStroke.isEmpty} */
+    isEmpty(): boolean;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IBorder.IStroke.isIBorder} */
+    get isIBorder(): true;
+}
+export declare class CellAlignment extends Inheritable<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment.JSON> implements ITextFrame.IAlignment {
+    /** {@inheritDoc ITextBoxAlignment.getHorizontal} */
+    getHorizontal(): ITextFrame.HorizontalAlignment;
+    /** {@inheritDoc ITextBoxAlignment.setHorizontal} */
+    setHorizontal(horizontal: ITextFrame.HorizontalAlignment | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getVertical} */
+    getVertical(): ITextFrame.VerticalAlignment;
+    /** {@inheritDoc ITextBoxAlignment.setVertical} */
+    setVertical(vertical: ITextFrame.VerticalAlignment | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getIndent} */
+    getIndent(): number;
+    /** {@inheritDoc ITextBoxAlignment.setIndent} */
+    setIndent(indent: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getRelativeIndent} */
+    getRelativeIndent(): number;
+    /** {@inheritDoc ITextBoxAlignment.setRelativeIndent} */
+    setRelativeIndent(relativeIndent: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getOverflow} */
+    getOverflow(): ITextFrame.Overflow;
+    /** {@inheritDoc ITextBoxAlignment.setOverflow} */
+    setOverflow(overflow: ITextFrame.Overflow | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getRotation} */
+    getRotation(): number;
+    /** {@inheritDoc ITextBoxAlignment.setRotation} */
+    setRotation(rotation: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getStacked} */
+    getStacked(): boolean;
+    /** {@inheritDoc ITextBoxAlignment.setStacked} */
+    setStacked(stacked: boolean | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getJustifyLastLine} */
+    getJustifyLastLine(): boolean;
+    /** {@inheritDoc ITextBoxAlignment.setJustifyLastLine} */
+    setJustifyLastLine(justifyLastLine: boolean | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    /** {@inheritDoc ITextBoxAlignment.getReadingDirection} */
+    getReadingDirection(): ITextFrame.ReadingDirection;
+    /** {@inheritDoc ITextBoxAlignment.setReadingDirection} */
+    setReadingDirection(readingDirection: ITextFrame.ReadingDirection | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ITextBoxAlignment.isITextBoxAlignment} */
+    get isITextBoxAlignment(): true;
+}
+export declare class CellFont extends Inheritable<IStyledFont.Properties, IStyledFont.JSON> implements IStyledFont {
+    /** {@inheritDoc IStyle.isEqualMeasure} */
+    isEqualMeasure(other: IStyledFont): boolean;
+    /** {@inheritDoc IStyle.toCSS} */
+    toCSS(mode?: IColor.CSSMode, zoom?: number, ignoreNormal?: boolean): CSSProperties;
+    /** {@inheritDoc IStyle.isSuperSub} */
+    isSuperSub(): boolean;
+    /** {@inheritDoc IStyle.isSuperSub} */
+    isSuperScript(): boolean;
+    /** {@inheritDoc IStyle.getSuperSubScale} */
+    getSuperSubScale(): number;
+    /** {@inheritDoc IStyle.getSuperSubShift} */
+    getSuperSubShift(): number;
+    /**
+     * The theme font this font is a reference to, or `undefined` if it names its own family.
+     *
+     * A scheme font is the LIVE theme font: `family` is only a cached resolution of it (Excel writes
+     * the face for the authoring locale's script, so a workbook saved in Chinese caches `宋体`
+     * where an English one caches `Calibri`), and the scheme is what the reference actually is.
+     */
+    private _schemeFamily;
+    /** {@inheritDoc IStyle.getFamily} */
+    getFamily(): string;
+    /** {@inheritDoc IStyle.setFamily} */
+    setFamily(family: string | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getFallbacks} */
+    getFallbacks(): string[];
+    /** {@inheritDoc IStyle.setFamily} */
+    setFallbacks(fallbacks: string[] | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getSize} */
+    getSize(): number;
+    /** {@inheritDoc IStyle.setSize} */
+    setSize(size: number | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getWeight} */
+    getWeight(): number;
+    /** {@inheritDoc IStyle.setWeight} */
+    setWeight(weight: number | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyledFont.getBold} */
+    getBold(): boolean;
+    /** {@inheritDoc IStyledFont.setBold} */
+    setBold(bold: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getStyle} */
+    getStyle(): IFont.Style;
+    /** {@inheritDoc IStyle.setStyle} */
+    setStyle(style: IFont.Style | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyledFont.getItalic} */
+    getItalic(): boolean;
+    /** {@inheritDoc IStyledFont.setItalic} */
+    setItalic(italic: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getColor} */
+    getColor(): IColor;
+    /** {@inheritDoc IStyle.setColor} */
+    setColor(color: IColor | string | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getLetterSpacing} */
+    getLetterSpacing(): number;
+    /** {@inheritDoc IStyle.setLetterSpacing} */
+    setLetterSpacing(letterSpacing: number | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getUnderline} */
+    getUnderline(): IFont.UnderlineStyle;
+    /** {@inheritDoc IStyle.setUnderline} */
+    setUnderline(underline: IFont.UnderlineStyle | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getStrike} */
+    getStrike(): boolean;
+    /** {@inheritDoc IStyle.setStrike} */
+    setStrike(strike: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getScheme} */
+    getScheme(): IFont.Scheme;
+    /** {@inheritdoc IStyle.setScheme} */
+    setScheme(scheme: IFont.Scheme | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getVerticalAlignment} */
+    getVerticalAlignment(): IFont.VerticalAlignment;
+    /** {@inheritDoc IStyle.setVerticalAlignment} */
+    setVerticalAlignment(verticalAlign: IFont.VerticalAlignment | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getShadow} */
+    getShadow(): boolean;
+    /** {@inheritDoc IStyle.setShadow} */
+    setShadow(shadow: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getOutline} */
+    getOutline(): boolean;
+    /** {@inheritDoc IStyle.setOutline} */
+    setOutline(outline: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyle.getExtend} */
+    getExtend(): boolean;
+    /** {@inheritDoc IStyle.setExtend} */
+    setExtend(extend: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IStyledFont.getCharset} */
+    getCharset(): IFont.Charset | null;
+    /** {@inheritDoc IStyledFont.setCharset} */
+    setCharset(charset: IFont.Charset | null, options?: IStyle.UpdateOptions): IStyledFont;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc ICellRanges.toString} */
+    toString(): string;
+    /** {@inheritDoc IStyle.isIStyledFont} */
+    get isIStyledFont(): true;
+}
+export declare class NoneFill extends Inheritable<IFill.NoneProperties, IFill.NoneJSON> implements IFill.INone {
+    /** {@inheritDoc IFill.INone.getType} */
+    getType(): typeof IFill.Type.None;
+    /** {@inheritDoc IFill.INone.getColor} */
+    getColor(): IColor | null;
+    /** {@inheritDoc IFill.INone.setColor} */
+    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill;
+    /** {@inheritDoc IFill.INone.toCSS} */
+    toCSS(_mode?: IColor.CSSMode): CSSProperties;
+    /** {@inheritDoc IFill.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+    /** {@inheritDoc IFill.isEqual} */
+    isEqual(other: IFill | null): boolean;
+    /** {@inheritDoc IFill.INone.toJSON} */
+    toJSON(): IFill.NoneJSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IFill.isIFill} */
+    get isIFill(): true;
+}
+export declare class SolidFill extends Inheritable<IFill.SolidProperties, IFill.SolidJSON> implements IFill.ISolid {
+    /** {@inheritDoc IFill.ISolid.getType} */
+    getType(): typeof IFill.Type.Solid;
+    /** {@inheritDoc IFill.ISolid.getColor} */
+    getColor(): IColor;
+    /** {@inheritDoc IFill.ISolid.setColor} */
+    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.ISolid;
+    /** {@inheritDoc IFill.ISolid.toCSS} */
+    toCSS(mode?: IColor.CSSMode): CSSProperties;
+    /** {@inheritDoc IFill.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+    /** {@inheritDoc IFill.isEqual} */
+    isEqual(other: IFill | null): boolean;
+    /** {@inheritDoc IFill.ISolid.toJSON} */
+    toJSON(): IFill.SolidJSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IFill.isIFill} */
+    get isIFill(): true;
+}
+export declare class GradientStop extends Inheritable<IFill.GradientStopProperties, any> implements IFill.IGradientStop {
+    protected _i: number;
+    protected _l: number;
+    constructor(index: number, length: number, options: CreateCellStyleOptions, properties: IFill.GradientStopProperties[]);
+    /** {@inheritDoc IFill.IGradientStop.getOffset} */
+    getOffset(): number;
+    /** {@inheritDoc IFill.IGradientStop.getColor} */
+    getColor(): IColor;
+}
+export declare class GradientFill extends Inheritable<IFill.GradientProperties, IFill.GradientJSON> implements IFill.IGradient {
+    /** {@inheritDoc IFill.IGradient.getType} */
+    getType(): typeof IFill.Type.Gradient;
+    /** {@inheritDoc IFill.IGradient.getColor} */
+    getColor(): IColor | null;
+    /** {@inheritDoc IFill.IGradient.setColor} */
+    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getStops} */
+    getStops(): IFill.IGradientStop[];
+    /** {@inheritDoc IFill.IGradient.setStops} */
+    setStops(stops: IFill.IGradientStop[], options?: IStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getGradientType} */
+    getGradientType(): IFill.GradientType;
+    /** {@inheritDoc IFill.IGradient.setGradientType} */
+    setGradientType(gradientType: IFill.GradientType, options?: IStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getAngle} */
+    getAngle(): number;
+    /** {@inheritDoc IFill.IGradient.setAngle} */
+    setAngle(angle: number, options?: IStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getFocus} */
+    getFocus(): Rectangle;
+    /** {@inheritDoc IFill.IGradient.setFocus} */
+    setFocus(focus: Rectangle, options?: IStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.toCSS} */
+    toCSS(mode?: IColor.CSSMode, size?: Size): CSSProperties;
+    /** {@inheritDoc IFill.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+    /** {@inheritDoc IFill.isEqual} */
+    isEqual(other: IFill | null): boolean;
+    /** {@inheritDoc IFill.IGradient.toJSON} */
+    toJSON(): IFill.GradientJSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IFill.isIFill} */
+    get isIFill(): true;
+}
+export declare class PatternFill extends Inheritable<IFill.PatternProperties, IFill.PatternJSON> implements IFill.IPattern {
+    /** {@inheritDoc IFill.IPattern.getType} */
+    getType(): typeof IFill.Type.Pattern;
+    /** {@inheritDoc IFill.IPattern.getColor} */
+    getColor(): IColor;
+    /** {@inheritDoc IFill.IPattern.setColor} */
+    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.getBackground} */
+    getBackground(): IColor;
+    /** {@inheritDoc IFill.ISolid.setBackground} */
+    setBackground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.getForeground} */
+    getForeground(): IColor;
+    /** {@inheritDoc IFill.ISolid.setForeground} */
+    setForeground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.getPatternType} */
+    getPatternType(): IFill.BuiltInSheetPattern;
+    /** {@inheritDoc IFill.IGradient.setPatternType} */
+    setPatternType(patternType: IFill.BuiltInSheetPattern, options?: IStyle.UpdateOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.toCSS} */
+    toCSS(mode?: IColor.CSSMode): CSSProperties;
+    /** {@inheritDoc IFill.IPattern.toCSSMask} */
+    toCSSMask(mode?: IColor.CSSMode): {
+        base: CSSProperties;
+        marks: CSSProperties;
+    } | null;
+    /** {@inheritDoc IFill.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+    /** {@inheritDoc IFill.isEqual} */
+    isEqual(other: IFill | null): boolean;
+    /** {@inheritDoc IFill.IPattern.toJSON} */
+    toJSON(): IFill.PatternJSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IFill.isIFill} */
+    get isIFill(): true;
+}
+export declare class SheetCellStyle implements IStyle {
+    protected _o: CreateCellStyleOptions;
+    protected _p: InheritableProperties<IStyle.Properties, IStyle.JSON>;
+    protected _bestFit: Partial<Size> | undefined;
+    protected _insets: Rectangle | undefined;
+    protected _hasVisibleStyling: boolean | undefined;
+    protected _font: IStyledFont | undefined;
+    protected _alignment: ITextFrame.IAlignment | undefined;
+    protected _border: IBorder | undefined;
+    protected _fill: IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone | undefined;
+    constructor(options: CreateCellStyleOptions);
+    /** {@inheritDoc IStyle.toJSON} */
+    toJSON(): IStyle.JSON;
+    /** {@inheritDoc IStyle.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+    /** {@inheritDoc IStyle.isNormal} */
+    isNormal(): boolean;
+    /**
+     * The AUTHORED (explicit) properties of this style: the direct layer values plus the `named`
+     * reference. Never includes cascade-resolved values (named/table/conditional results) - those
+     * re-derive at read time from the destination's own cascade. This is what a write/copy of this
+     * style persists (see resolveStyleUpdate).
+     */
+    getAuthoredProperties(): IStyle.Properties;
+    /** {@inheritDoc IStyle.createStyle} */
+    createStyle(update: IStyle.Update): IStyle;
+    /** {@inheritDoc IStyle.measureText} */
+    measureText(text: string, size?: number, family?: string, options?: IFont.MetricOptions): IFont.ExtendedMetrics;
+    /** {@inheritDoc IStyle.createTextFrame} */
+    createTextFrame(text: string, allowWrap?: boolean): ITextFrame;
+    /** {@inheritDoc IStyle.update} */
+    update(update: IStyle.Update, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.clear} */
+    clear(): IStyle;
+    /** {@inheritDoc IStyle.getBestFit} */
+    getBestFit(): Partial<Size> | null;
+    /** {@inheritDoc IStyle.getInsets} */
+    getInsets(): Rectangle;
+    /** {@inheritDoc IStyle.getBorder} */
+    getBorder(): IBorder;
+    /** {@inheritDoc IStyle.setBorder} */
+    setBorder(border: IBorder.Update, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getFont} */
+    getFont(): IStyledFont;
+    /** {@inheritDoc IStyle.setFont} */
+    setFont(font: IStyledFont.Update, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getFill} */
+    getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
+    /** {@inheritDoc IStyle.setFill} */
+    setFill(fill: IFill.Update, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.setFill} */
+    setFillSolid(options?: IStyle.UpdateOptions): IFill.ISolid;
+    /** {@inheritDoc IStyle.setFill} */
+    setFillGradient(options?: IStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc IStyle.setFill} */
+    setFillPattern(options?: IStyle.UpdateOptions): IFill.IPattern;
+    /** {@inheritDoc IStyle.setFill} */
+    setFillNone(options?: IStyle.UpdateOptions): IFill.INone;
+    /** {@inheritDoc IStyle.getAlignment} */
+    getAlignment(): ITextFrame.IAlignment;
+    /** {@inheritDoc IStyle.setAlignment} */
+    setAlignment(alignment: ITextFrame.IAlignment.Update | string | null, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getNumberFormat} */
+    getNumberFormat(): string;
+    /** {@inheritDoc IStyle.setNumberFormat} */
+    setNumberFormat(numFmt: string | null, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getQuotePrefix} */
+    getQuotePrefix(): boolean;
+    /** {@inheritDoc IStyle.setQuotePrefix} */
+    setQuotePrefix(quotePrefix: boolean | null, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getNamed} */
+    getNamed(): IStyle.INamed;
+    /** {@inheritDoc IStyle.setNamed} */
+    setNamed(named: string | IStyle.INamed | null, options?: IStyle.UpdateOptions): IStyle;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IStyle.isIStyle} */
+    get isIStyle(): true;
+}
+/**
+ * Create an `IStyle` using the properties.
+ *
+ * @remarks
+ * Not part of the public interface.
+ */
+export declare function createCellStyle(value: Scalar | undefined, styles: IStyleCollection, layer: IProperties.ICellRanged<IStyle.Properties>, range?: Readonly<IRange.Coords>, updater?: CellStyleUpdater, extent?: Readonly<IRange.Coords>): IStyle;
+export declare class EmptyStyle extends SheetCellStyle {
+    /** {@inheritDoc IStyle.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+}
+export declare class NormalStyle extends SheetCellStyle {
+    /** {@inheritDoc IStyle.isNormal} */
+    isNormal(): boolean;
+    /**
+     * {@inheritDoc SheetCellStyle.getAuthoredProperties}
+     *
+     * Normal authors nothing: writing/copying the Normal style is a reset (`null` is the clear-all
+     * marker). Without this, a customized Normal's def values would be copied as explicit direct
+     * formatting (the `direct` layer here is the normal ranged def, not cell-authored values).
+     */
+    getAuthoredProperties(): IStyle.Properties;
+}
+export declare function ReadOnlyUpdater(update: IStyle.Update): IStyle;
+export {};
+//# sourceMappingURL=SheetCellStyle.d.ts.map

package/types/src/sheet/style/SheetDirectStyle.d.ts

@@ -0,0 +1,130 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+import { IProperties } from '../../type';
+import { IBorder } from '../../border';
+import { IStyle, IStyleCollection } from '../../style';
+import { ISpatialMap } from '../../collections/ISpatialMap';
+/**
+ * `SheetDirectStyle` represents a style that spans a range of cells.
+ *
+ * * It can generate a list of properties for each cell in the range.
+ */
+export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IProperties.ICellRanged<IStyle.Properties> {
+    protected _c: IStyleCollection;
+    protected _getEntireRange: (() => IRange.Coords) | null;
+    protected _r: IRange.Coords;
+    protected _p: IStyle.Properties | null;
+    protected _t: IRange.Coords | null;
+    protected _e: boolean;
+    protected _o: IRange.AxisSelection;
+    /**
+     * The 'update form': the resolved update INCLUDING explicit `null` clears (tombstones). Only
+     * present on update templates built via {@link cloneWithUpdate} with `keepNulls` (and their
+     * splits). `_p` stays clean (tombstones stripped) so a template stored directly for previously
+     * unstyled cells reads/persists correctly; intersect-merges consume `_u` so clears reach cells
+     * that DO have a previous style. See the ranged-style update in Sheet.ts.
+     */
+    protected _u: IStyle.Properties | undefined;
+    constructor(styles: IStyleCollection, getEntireRange: (() => IRange.Coords) | null, range: IRange.Coords, properties?: IStyle.Properties | null, tile?: IRange.Coords | null, axes?: IRange.AxisSelection);
+    isEmpty(): boolean;
+    getProperties(): IStyle.Properties | null;
+    /** {@inheritDoc IProperties.ICellRanged.getCoords} */
+    getCoords(): Readonly<IRange.Coords>;
+    /**
+     * The update form including explicit `null` clears; only present on update templates.
+     * @see {@link _u}
+     */
+    getUpdateProperties(): IStyle.Properties | undefined;
+    /** Category key partition for {@link splitByFeature} (SHEET-STYLE-SPLIT). Covers every
+     * `IStyle.Properties` key exactly once so the split is lossless. `protection` is future. */
+    static readonly BorderKeys: readonly (keyof IStyle.Properties)[];
+    static readonly FillKeys: readonly (keyof IStyle.Properties)[];
+    static readonly ContentKeys: readonly (keyof IStyle.Properties)[];
+    /**
+     * Split this style into up to three category-scoped copies (border / fill / content) for the
+     * per-feature style maps (SHEET-STYLE-SPLIT §4). The partition is **lossless** — every
+     * `IStyle.Properties` key goes to exactly one category — so merging the three reconstructs this
+     * style. Both the clean properties (`_p`) and the update form (`_u`, explicit `null` clears) are
+     * partitioned. A category with no present keys returns `null`.
+     * @internal
+     */
+    splitByFeature(): {
+        border: SheetDirectStyle | null;
+        fill: SheetDirectStyle | null;
+        content: SheetDirectStyle | null;
+    };
+    /**
+     * Inverse of {@link splitByFeature}: merge up to three category-scoped styles (border / fill /
+     * content) back into one for a read intersection (SHEET-STYLE-SPLIT step 3). The three parts are
+     * uniform over the composed region (a flattened read intersection), so a single merged `_p`
+     * reproduces the original blob style's per-cell resolution — EXCEPT border, which is range-relative:
+     * the merge keeps border's own range + tile so {@link getPropertiesAt} still localizes edges
+     * per-cell, while fill/content props are position-independent and merge in directly.
+     *
+     * Returns `null` when all three are absent, or the sole part unwrapped when only one is present (no
+     * allocation — the common single-category cell).
+     * @internal
+     */
+    static compose(border: SheetDirectStyle | null | undefined, fill: SheetDirectStyle | null | undefined, content: SheetDirectStyle | null | undefined): SheetDirectStyle | null;
+    /**
+     * Two-way overlay used to rebuild a merged (blob-shaped) style from the per-feature maps
+     * (SHEET-STYLE-SPLIT): merge `over`'s properties on top of `base`. Border is range-relative, so
+     * whichever side carries it owns the resulting range + tile (localization stays correct); all other
+     * keys are position-independent. Intended to be applied in border-last order (content, fill, border),
+     * so the bordered side wins the range/tile. Either side may be null.
+     * @internal
+     */
+    static mergeOverlay(base: SheetDirectStyle | null | undefined, over: SheetDirectStyle | null | undefined): SheetDirectStyle | null;
+    /**
+     * {@inheritDoc IProperties.ICellRanged.cloneWithUpdate}
+     *
+     * @param keepNulls Build an update template: explicit `null` clears in `updates` are preserved in
+     * the update form ({@link getUpdateProperties}) while the direct properties stay clean. Use when
+     * resolving an update against an empty previous style for later per-run merging.
+     */
+    cloneWithUpdate(updates: IStyle.Modifiers, keepNulls?: boolean): this;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.copyTo} */
+    copyTo(destination: IRange.Coords, options?: ISpatialMap.CopyOptions): ISpatialMap.Entry<this> | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.canTile} */
+    canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
+    protected _createShifted(coords: IRange.Coords): this;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | null;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(coords: [IRange.Coords, IRange.Coords], axis: IRange.Axis): [this, this];
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getMerged(other: this, destination: IRange.Coords, axis: IRange.Axis): this | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.hasTrailingEdge} */
+    hasTrailingEdge(): boolean;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.isMergeOnShift} */
+    isMergeOnShift(): boolean;
+    /**
+     * The **inner** border rules this block authors, localized to `range`.
+     *
+     * @returns The inner rules, or `null` when this block cannot answer for that extent.
+     *
+     * @remarks
+     * The extent-scoped counterpart of {@link getPropertiesAt}, and the only read that can see
+     * `horizontal`/`vertical` at all: the per-cell localization decomposes them into the edges
+     * they produce (a cell has no inside), so by the time a cell style exists they are gone.
+     *
+     * `range` must be **fully contained** in this block, or the answer is `null`. A range reaching
+     * outside it covers cells this block says nothing about, and reporting the block's rule for
+     * them would claim an inner grid over cells that have none — the same lie the region work
+     * exists to prevent.
+     * @internal
+     */
+    getInnerBorder(range: IRange.Coords): Readonly<Partial<IBorder.Properties>> | null;
+    protected _localizeBorderRange(unscoped: Readonly<IBorder.Properties>, rangeUnscoped: IRange.Coords, range: IRange.Coords): Partial<IBorder.Properties> | null | undefined;
+    /**
+     * Localizes the border to the cell coords.
+     * Returns border properties, null, or undefined.
+     * * If undefined then there was no border to localize.
+     * * `null` is localize to none.
+     */
+    protected _localizeBorder(unscoped: IBorder.Properties, range: IRange.Coords, rowIndex: number, colIndex: number): Partial<IBorder.Properties> | null | undefined;
+    /** {@inheritDoc IProperties.ICellRanged.getPropertiesAt} */
+    getPropertiesAt(rowIndex: number, colIndex: number, value: Scalar): Readonly<IStyle.Properties>;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.toJSON} */
+    toJSON(): IStyle.JSON;
+}
+//# sourceMappingURL=SheetDirectStyle.d.ts.map