@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

package/types/src/fill/IStroke.d.ts

@@ -1,17 +1,110 @@
 import { Properties as CSSProperties } from 'csstype';
 import { Bounds } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
 import { IColor } from '../color';
 import { IFill } from '../fill';
 /**
- * *** **PLACEHOLDER** - Not yet implemented.
+ * The line drawn along a shape's path: what it is drawn with, how wide, how dashed, and what is
+ * drawn at the ends of an open path.
  *
- * Defines how a stroke is drawn around a shape.
+ * @remarks
+ * A stroke is read resolved: what the shape states over what its theme style gives. Every setter
+ * writes to the shape and answers with the stroke as it reads afterwards.
  */
 export interface IStroke {
     /**
-     * Fill properties for the stroke.
+     * What the line is drawn with. A line's color is its fill's; its transparency is that color's
+     * alpha. A {@link IFill.Type.None | none} fill is no line at all.
      */
     getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
+    /**
+     * Sets what the line is drawn with: a color, or a fill.
+     *
+     * @example
+     * ```ts
+     * stroke.setFill('red');
+     * stroke.setFill({ type: IFill.Type.None }); // no line
+     * ```
+     */
+    setFill(fill: IFill.Update, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The width of the line in points, as Excel measures it. A line that states none is drawn at
+     * Excel's implied width.
+     */
+    getWidth(): number;
+    /**
+     * Sets the width in points; `null` leaves the width to the theme style.
+     */
+    setWidth(width: number | null, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The dash: a preset, or a custom pattern of dash and space lengths relative to the width.
+     */
+    getDash(): IStroke.DashStyle | number[];
+    /**
+     * Sets the dash; `null` leaves it to the theme style.
+     */
+    setDash(dash: IStroke.DashStyle | number[] | null, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The shape drawn at the end of an open subpath.
+     */
+    getLineCap(): IStroke.LineCap;
+    /**
+     * Sets the line cap; `null` leaves it to the theme style.
+     */
+    setLineCap(lineCap: IStroke.LineCap | null, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The shape drawn at the corners of the path.
+     */
+    getLineJoin(): IStroke.LineJoin;
+    /**
+     * Sets the line join; `null` leaves it to the theme style.
+     */
+    setLineJoin(lineJoin: IStroke.LineJoin | null, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The ratio of miter length to width past which a miter join becomes a bevel.
+     */
+    getMiterLimit(): number;
+    /**
+     * The line end drawn at the start of an open path.
+     */
+    getHead(): IStroke.LineEnd;
+    /**
+     * Sets the line end at the start of an open path; `null` leaves it to the theme style.
+     */
+    setHead(head: IStroke.LineEnd | IStroke.LineEndType | null, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The line end drawn at the end of an open path.
+     */
+    getTail(): IStroke.LineEnd;
+    /**
+     * Sets the line end at the end of an open path; `null` leaves it to the theme style.
+     */
+    setTail(tail: IStroke.LineEnd | IStroke.LineEndType | null, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * The compound line type. Only single is drawn.
+     */
+    getCompound(): IStroke.Compound;
+    /**
+     * Where the line sits on the path. Only centered is drawn.
+     */
+    getAlign(): IStroke.Align;
+    /**
+     * Sets several properties at once.
+     *
+     * @example
+     * ```ts
+     * stroke.update({ width: 2, dash: IStroke.DashStyle.Dash, tail: { type: 'triangle' } });
+     * ```
+     */
+    update(update: IStroke.Update, options?: ITransaction.OperationOptions): IStroke;
+    /**
+     * Whether a line is drawn: a fill that is not none, and a width above zero.
+     */
+    isVisible(): boolean;
+    /**
+     * Returns `true` if the stroke is equal to the other stroke.
+     */
+    isEqual(other: IStroke | null): boolean;
     /**
      * Returns the stroke as a set of css string that are suitable for css.
      *
@@ -25,6 +118,10 @@ export interface IStroke {
      * Returns the stroke as a json object.
      */
     toJSON(): IStroke.JSON;
+    /**
+     * For type checking.
+     */
+    readonly isIStroke: true;
 }
 /**
  * {@inheritDoc IStroke}
@@ -37,25 +134,25 @@ export declare namespace IStroke {
     interface Properties {
         /**
          * Fill properties for the stroke.
-         */
-        fill: IFill.Properties;
-        /**
-         * The width of the stroke.
          *
          * @remarks
-         * Indicates the thickness of the stroke in pixels.
+         * A stroke's transparency is its fill color's alpha; a gradient line can vary it stop by stop.
+         */
+        fill?: IFill.Properties;
+        /**
+         * The width of the stroke, in points.
          */
-        width: number;
+        width?: number;
         /**
          * Defines the shape to be used at the corners of paths when they are stroked.
          */
-        lineJoin: IStroke.LineJoin;
+        lineJoin?: IStroke.LineJoin;
         /**
          * Defining the shape to be used at the end of open subpaths when they are stroked.
          *
          * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap}
          */
-        lineCap: IStroke.LineCap;
+        lineCap?: IStroke.LineCap;
         /**
          * Defining a limit on the ratio of the miter length to the stroke-width
          * used to draw a miter join. When the limit is exceeded, the join is converted
@@ -65,38 +162,35 @@ export declare namespace IStroke {
          *
          * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit}
          */
-        miterLimit: number;
+        miterLimit?: number;
         /**
-         * Defines the arrowhead or shape that will be drawn at the first vertex of the given shape.
-         *
-         * @defaultValue `null`.
-         *
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-start}
+         * The line end drawn at the start of an open path (DrawingML `headEnd`).
          *
+         * @defaultValue `'none'`
          */
-        markerStart: IStroke.IMarker;
+        headType?: IStroke.LineEndType;
+        /** The head's width, relative to the line width. @defaultValue `'med'` */
+        headWidth?: IStroke.LineEndSize;
+        /** The head's length, relative to the line width. @defaultValue `'med'` */
+        headLength?: IStroke.LineEndSize;
         /**
-         * Defines the arrowhead or shape that will be drawn at all interior vertices of the given shape.
-         *
-         * @defaultValue `null`.
-         *
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-mid}
+         * The line end drawn at the end of an open path (DrawingML `tailEnd`).
          *
+         * @defaultValue `'none'`
          */
-        markerMid: IStroke.IMarker;
+        tailType?: IStroke.LineEndType;
+        /** The tail's width, relative to the line width. @defaultValue `'med'` */
+        tailWidth?: IStroke.LineEndSize;
+        /** The tail's length, relative to the line width. @defaultValue `'med'` */
+        tailLength?: IStroke.LineEndSize;
         /**
-         * Defines the arrowhead or shape that will be drawn at final vertex for the given shape.
-         *
-         * @defaultValue `null`.
-         *
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-end}
+         * The dash: a preset ({@link IStroke.DashStyle}), or a custom pattern of dash and space
+         * lengths as percentages of the line width (DrawingML `custDash`: `[400, 300]` is a dash of
+         * four widths and a space of three). {@link IStroke.toDashLengths} gives either in widths.
          *
+         * @defaultValue IStroke.DashStyle.Solid
          */
-        markerEnd: IStroke.IMarker;
-        /**
-         * Custom or preset for the stroke.
-         */
-        dash: number[] | string;
+        dash?: IStroke.DashStyle | number[];
         /**
          * Indicates the type of compound stroke.
          *
@@ -106,7 +200,7 @@ export declare namespace IStroke {
          * Only single is supported for rendering.
          *
          */
-        compound: IStroke.Compound;
+        compound?: IStroke.Compound;
         /**
          * Indicates the alignment of the stroke.
          *
@@ -115,22 +209,51 @@ export declare namespace IStroke {
          * @remarks
          * Only center is supported for rendering.
          */
-        align: IStroke.Align;
+        align?: IStroke.Align;
     }
     /**
-     * A Marker is a custom placeholder for shapes along a stroke.
-     *
-     * @remarks
-     * The Marker contains the positioning and shape of the marker.
-     *
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Element/marker}
+     * Modifiers describe a partial list of properties that can be set with values or shorthand
+     * strings: the fill may be a color, and each end a line end type alone.
      */
-    interface IMarker {
-        width: number;
-        height: number;
-        axis: number;
-        shape: IStroke.PresetMarkerShape;
+    interface Modifiers extends Omit<{
+        [K in keyof Properties]?: Properties[K] | null;
+    }, 'fill'> {
+        /** {@inheritDoc IStroke.Properties.fill} */
+        fill?: IFill.Update;
+        /** The line end at the start of an open path: the three `head` keys at once. */
+        head?: LineEnd | LineEndType | null;
+        /** The line end at the end of an open path: the three `tail` keys at once. */
+        tail?: LineEnd | LineEndType | null;
     }
+    /**
+     * Options for updating a stroke: a stroke, modifiers, a color for the fill, or `null` for the
+     * theme style's line.
+     */
+    type Update = IStroke | Modifiers | string | null;
+    /** A line end: what is drawn, and its size relative to the line width. */
+    interface LineEnd {
+        type: LineEndType;
+        width?: LineEndSize;
+        length?: LineEndSize;
+    }
+    /** The shape drawn at an open path's end (DrawingML `ST_LineEndType`). */
+    const LineEndType: {
+        readonly None: "none";
+        readonly Triangle: "triangle";
+        readonly Stealth: "stealth";
+        readonly Diamond: "diamond";
+        readonly Oval: "oval";
+        /** An open arrowhead: two strokes of the line's width. */
+        readonly Arrow: "arrow";
+    };
+    type LineEndType = typeof LineEndType[keyof typeof LineEndType];
+    /** A line end's width or length, relative to the line width (DrawingML `ST_LineEndWidth` / `ST_LineEndLength`). */
+    const LineEndSize: {
+        readonly Small: "sm";
+        readonly Medium: "med";
+        readonly Large: "lg";
+    };
+    type LineEndSize = typeof LineEndSize[keyof typeof LineEndSize];
     /**
      * Support stroke with multiple strokes.
      * ** PLACEHOLDER **
@@ -234,32 +357,49 @@ export declare namespace IStroke {
         readonly Round: "round";
     };
     type LineJoin = typeof LineJoin[keyof typeof LineJoin];
-    const PresetMarkerShape: {
-        readonly Single: "none";
-        readonly Double: "double";
-        readonly ThickThin: "thickThin";
-        readonly ThinThick: "thickThin";
-    };
-    type PresetMarkerShape = typeof PresetMarkerShape[keyof typeof PresetMarkerShape];
-    const StrokeStyle: {
-        readonly None: "none";
-        readonly Dashed: "dashed";
-        readonly Dotted: "dotted";
-        readonly LargeDash: "lgDash";
-        readonly LargeDashDot: "lgDashDot";
-        readonly LargeDashDotDot: "lgDashDotDot";
+    /**
+     * The preset dashes (DrawingML `ST_PresetLineDashVal`), as Excel's Dash type list offers them.
+     *
+     * @remarks
+     * The `sys` presets are measured in line widths of a hairline; the others in the line's own
+     * width. {@link IBorders.StrokeStyle} is a cell border's, a different list.
+     */
+    const DashStyle: {
         readonly Solid: "solid";
+        /** Round dot. */
+        readonly SysDot: "sysDot";
+        /** Square dot. */
         readonly SysDash: "sysDash";
+        readonly Dash: "dash";
+        readonly DashDot: "dashDot";
+        readonly LongDash: "lgDash";
+        readonly LongDashDot: "lgDashDot";
+        readonly LongDashDotDot: "lgDashDotDot";
+        readonly Dot: "dot";
         readonly SysDashDot: "sysDashDot";
         readonly SysDashDotDot: "sysDashDotDot";
-        readonly SysDot: "sysDot";
     };
-    type StrokeStyle = typeof StrokeStyle[keyof typeof StrokeStyle];
+    type DashStyle = typeof DashStyle[keyof typeof DashStyle];
+    /**
+     * A dash as alternating dash and space lengths in line widths, or `null` for a solid line.
+     *
+     * @param dash A preset, or a custom pattern as {@link Properties.dash} holds it (percentages of
+     * the width).
+     *
+     * @example
+     * ```ts
+     * IStroke.toDashLengths(IStroke.DashStyle.SysDot); // [1, 1]
+     * IStroke.toDashLengths([400, 300]); // [4, 3]
+     * ```
+     */
+    function toDashLengths(dash: DashStyle | readonly number[] | null | undefined): number[] | null;
     /**
      * A JSON representation useful for persistence.
      */
     interface JSON extends Properties {
-        fill: IFill.JSON;
+        fill?: IFill.JSON;
+        /** The line's `extLst` as a file states it (DrawingML `ln/extLst`): an opaque fragment, written back as it was. */
+        extLst?: string;
     }
 }
 //# sourceMappingURL=IStroke.d.ts.map

package/types/src/fill/PaintUtils.d.ts

@@ -0,0 +1,22 @@
+import { IColor } from '../color/IColor';
+import { IFill } from './IFill';
+/**
+ * Turns a serialized color (`accent1`, `tx1 lumMod 65 lumOff 35`, `#156082`) into the CSS a painter
+ * draws, or `null` where it cannot be read.
+ */
+export type ColorToCSS = (color: string) => string | null;
+/**
+ * A color as concrete CSS: `#RRGGBB`, or `rgba(r,g,b,a)` when it is not opaque. Never a theme
+ * reference, a CSS variable or `light-dark()`.
+ */
+export declare function toConcreteCSS(color: IColor): string;
+/**
+ * A fill with each of its colors drawn through `css`: a solid fill's color, a gradient's stops, a
+ * pattern's foreground and background. What it does not color (an image, the gradient's geometry,
+ * the pattern's tile) is kept as it is.
+ *
+ * @returns `undefined` for no fill stated, `null` for a fill that draws nothing (none, a group's
+ * fill, which the caller resolves, or one whose colors cannot be read).
+ */
+export declare function toConcreteFill(fill: IFill.JSON | null | undefined, css: ColorToCSS): IFill.JSON | null | undefined;
+//# sourceMappingURL=PaintUtils.d.ts.map

package/types/src/fill/RectAlignment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Where one rectangle sits within another: a corner, an edge's midpoint, or the center.
+ *
+ * @remarks
+ * Used to anchor an image fill's tiles, a shadow or a reflection to a shape (DrawingML
+ * `ST_RectAlignment`).
+ */
+export declare const RectAlignment: {
+    readonly TopLeft: "tl";
+    readonly Top: "t";
+    readonly TopRight: "tr";
+    readonly Left: "l";
+    readonly Center: "ctr";
+    readonly Right: "r";
+    readonly BottomLeft: "bl";
+    readonly Bottom: "b";
+    readonly BottomRight: "br";
+};
+export type RectAlignment = typeof RectAlignment[keyof typeof RectAlignment];
+//# sourceMappingURL=RectAlignment.d.ts.map

package/types/src/fill/_Fills.d.ts

@@ -0,0 +1,187 @@
+import { Properties as CSSProperties } from 'csstype';
+import { Size, Rectangle } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { IResource } from '../resource';
+import { IColor } from '../color';
+import { IFill } from './IFill';
+/**
+ * What a fill needs from whatever holds it — a cell style, a shape style — to read colors and to
+ * write itself back.
+ *
+ * @remarks
+ * A fill is a view over layered properties: it reads the last layer that states a value, and
+ * every setter goes through {@link updateFill}, which writes to the host and answers with the
+ * fill as it reads afterwards. The fill never holds the host's state.
+ */
+export interface FillHost {
+    /** Parses a serialized color through the host's theme. */
+    parseColor(color: IColor.Serializable): IColor;
+    /**
+     * The fill the host draws when nothing states one: a cell's Normal fill, a shape's theme fill.
+     * `null` when the host has no such baseline, which makes every fill count as visible styling.
+     */
+    getBaseFill(): IFill | null;
+    /** The image an image fill names, when the host holds it. */
+    getResource?(resourceId: number): IResource | null;
+    /** Writes a fill update to the host and returns the fill as it now reads. */
+    updateFill(update: IFill.Modifiers, options?: ITransaction.OperationOptions): IFill;
+}
+/** One of the fills a host can hold. */
+export type AnyFill = IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.IImage | IFill.INone;
+declare abstract class AbstractFill<P extends object> {
+    protected readonly _h: FillHost;
+    protected readonly _p: readonly Readonly<P>[];
+    constructor(host: FillHost, layers: readonly Readonly<P>[]);
+    /** The value the last layer that states `key` gives it. */
+    protected _value<K extends keyof P>(key: K): P[K] | undefined;
+    protected _update(update: IFill.Modifiers, key: string, options?: ITransaction.OperationOptions): IFill;
+    /** {@inheritDoc IFill.isIFill} */
+    get isIFill(): true;
+}
+export declare class NoneFill extends AbstractFill<IFill.NoneProperties> 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?: ITransaction.OperationOptions): 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;
+}
+export declare class SolidFill extends AbstractFill<IFill.SolidProperties> 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?: ITransaction.OperationOptions): 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;
+}
+export declare class GradientStop extends AbstractFill<IFill.GradientStopProperties & IFill.Properties> implements IFill.IGradientStop {
+    protected _i: number;
+    protected _l: number;
+    constructor(index: number, length: number, host: FillHost, properties: readonly IFill.GradientStopProperties[]);
+    /** {@inheritDoc IFill.IGradientStop.getOffset} */
+    getOffset(): number;
+    /** {@inheritDoc IFill.IGradientStop.getColor} */
+    getColor(): IColor;
+}
+export declare class GradientFill extends AbstractFill<IFill.GradientProperties> implements IFill.IGradient {
+    /** {@inheritDoc IFill.IGradient.getType} */
+    getType(): typeof IFill.Type.Gradient;
+    private _stops;
+    /** {@inheritDoc IFill.IGradient.getColor} */
+    getColor(): IColor | null;
+    /** {@inheritDoc IFill.IGradient.setColor} */
+    setColor(color: IColor.Serializable | null, options?: ITransaction.OperationOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getStops} */
+    getStops(): IFill.IGradientStop[];
+    /** {@inheritDoc IFill.IGradient.setStops} */
+    setStops(stops: (IFill.IGradientStop | IColor.Serializable | null)[], options?: ITransaction.OperationOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getGradientType} */
+    getGradientType(): IFill.GradientType;
+    /** {@inheritDoc IFill.IGradient.setGradientType} */
+    setGradientType(gradientType: IFill.GradientType, options?: ITransaction.OperationOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getAngle} */
+    getAngle(): number;
+    /** {@inheritDoc IFill.IGradient.setAngle} */
+    setAngle(angle: number, options?: ITransaction.OperationOptions): IFill.IGradient;
+    /** {@inheritDoc IFill.IGradient.getFocus} */
+    getFocus(): Rectangle;
+    /** {@inheritDoc IFill.IGradient.setFocus} */
+    setFocus(focus: Rectangle, options?: ITransaction.OperationOptions): 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;
+}
+export declare class PatternFill extends AbstractFill<IFill.PatternProperties> 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?: ITransaction.OperationOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.getBackground} */
+    getBackground(): IColor;
+    /** {@inheritDoc IFill.IPattern.setBackground} */
+    setBackground(color: IColor.Serializable | null, options?: ITransaction.OperationOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.getForeground} */
+    getForeground(): IColor;
+    /** {@inheritDoc IFill.IPattern.setForeground} */
+    setForeground(color: IColor.Serializable | null, options?: ITransaction.OperationOptions): IFill.IPattern;
+    /** {@inheritDoc IFill.IPattern.getPatternType} */
+    getPatternType(): IFill.BuiltInSheetPattern;
+    /** {@inheritDoc IFill.IPattern.setPatternType} */
+    setPatternType(patternType: IFill.BuiltInSheetPattern | null, options?: ITransaction.OperationOptions): 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;
+}
+export declare class ImageFill extends AbstractFill<IFill.ImageProperties> implements IFill.IImage {
+    /** {@inheritDoc IFill.IImage.getType} */
+    getType(): typeof IFill.Type.Image;
+    /** {@inheritDoc IFill.IImage.getColor} */
+    getColor(): IColor | null;
+    /** {@inheritDoc IFill.IImage.setColor} */
+    setColor(color: IColor.Serializable | null, options?: ITransaction.OperationOptions): IFill;
+    /** {@inheritDoc IFill.IImage.getResource} */
+    getResource(): IResource | null;
+    /** {@inheritDoc IFill.IImage.isTiled} */
+    isTiled(): boolean;
+    /** {@inheritDoc IFill.IImage.toCSS} */
+    toCSS(_mode?: IColor.CSSMode): CSSProperties;
+    /** {@inheritDoc IFill.hasVisibleStyling} */
+    hasVisibleStyling(): boolean;
+    /** {@inheritDoc IFill.isEqual} */
+    isEqual(other: IFill | null): boolean;
+    /** {@inheritDoc IFill.IImage.toJSON} */
+    toJSON(): IFill.ImageJSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+/**
+ * The fill the layers describe: typed by the last layer that states a type, and solid when none
+ * does but a color is stated. Anything else, and nothing at all, is no fill.
+ *
+ * @param host What the fill reads colors through and writes itself to.
+ * @param layers Properties in precedence order, the last winning; a layer may be `null`.
+ */
+export declare function createFill(host: FillHost, layers: readonly (Readonly<IFill.Properties> | null | undefined)[]): AnyFill;
+export {};
+//# sourceMappingURL=_Fills.d.ts.map

package/types/src/fill/_Stroke.d.ts

@@ -0,0 +1,89 @@
+import { Properties as CSSProperties } from 'csstype';
+import { Bounds } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { IResource } from '../resource';
+import { IColor } from '../color';
+import { IFill } from './IFill';
+import { IStroke } from './IStroke';
+/** Excel's implied line width, in points, for a line that states none. */
+export declare const IMPLIED_WIDTH = 0.75;
+/**
+ * What a stroke needs from whatever holds it: colors, the baseline it is compared against, and
+ * a way to write itself back. The same shape as a fill's host, for the same reason.
+ */
+export interface StrokeHost {
+    /** Parses a serialized color through the host's theme. */
+    parseColor(color: IColor.Serializable): IColor;
+    /** The line the host draws when nothing states one; `null` with no such baseline. */
+    getBaseStroke(): IStroke | null;
+    /** The image an image fill names, when the host holds it. */
+    getResource?(resourceId: number): IResource | null;
+    /** Writes a stroke update to the host and returns the stroke as it now reads. */
+    updateStroke(update: IStroke.Modifiers | null, options?: ITransaction.OperationOptions): IStroke;
+}
+/**
+ * {@link IStroke} over layered properties: the last layer that states a value answers for it.
+ */
+export declare class Stroke implements IStroke {
+    private readonly _h;
+    private readonly _p;
+    private _fill;
+    constructor(host: StrokeHost, layers: readonly (Readonly<IStroke.Properties> | null | undefined)[]);
+    private _value;
+    private _update;
+    /** {@inheritDoc IStroke.getFill} */
+    getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
+    /** {@inheritDoc IStroke.setFill} */
+    setFill(fill: IFill.Update, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getWidth} */
+    getWidth(): number;
+    /** {@inheritDoc IStroke.setWidth} */
+    setWidth(width: number | null, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getDash} */
+    getDash(): IStroke.DashStyle | number[];
+    /** {@inheritDoc IStroke.setDash} */
+    setDash(dash: IStroke.DashStyle | number[] | null, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getLineCap} */
+    getLineCap(): IStroke.LineCap;
+    /** {@inheritDoc IStroke.setLineCap} */
+    setLineCap(lineCap: IStroke.LineCap | null, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getLineJoin} */
+    getLineJoin(): IStroke.LineJoin;
+    /** {@inheritDoc IStroke.setLineJoin} */
+    setLineJoin(lineJoin: IStroke.LineJoin | null, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getMiterLimit} */
+    getMiterLimit(): number;
+    private _end;
+    /** {@inheritDoc IStroke.getHead} */
+    getHead(): IStroke.LineEnd;
+    /** {@inheritDoc IStroke.setHead} */
+    setHead(head: IStroke.LineEnd | IStroke.LineEndType | null, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getTail} */
+    getTail(): IStroke.LineEnd;
+    /** {@inheritDoc IStroke.setTail} */
+    setTail(tail: IStroke.LineEnd | IStroke.LineEndType | null, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.getCompound} */
+    getCompound(): IStroke.Compound;
+    /** {@inheritDoc IStroke.getAlign} */
+    getAlign(): IStroke.Align;
+    /** {@inheritDoc IStroke.update} */
+    update(update: IStroke.Update, options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IStroke.isVisible} */
+    isVisible(): boolean;
+    /** {@inheritDoc IStroke.isEqual} */
+    isEqual(other: IStroke | null): boolean;
+    /** {@inheritDoc IStroke.toCSS} */
+    toCSS(mode?: IColor.CSSMode, _bounds?: Bounds): CSSProperties;
+    /** {@inheritDoc IStroke.toJSON} */
+    toJSON(): IStroke.JSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IStroke.isIStroke} */
+    get isIStroke(): true;
+    /**
+     * An update as modifiers: a stroke by its JSON, a string as the fill's color, modifiers with
+     * `head`/`tail` spread to their three keys each, and `null` as itself.
+     */
+    static toModifiers(update: IStroke.Update): IStroke.Modifiers | null;
+}
+//# sourceMappingURL=_Stroke.d.ts.map