@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

package/types/src/text/ITextFrame.d.ts

@@ -0,0 +1,313 @@
+import { TextAlign as CSSTextAlign } from 'csstype';
+import { Size, Bounds, Rectangle } from '@sheetxl/utils';
+import { TextVisitor } from './TextVisitor';
+import { ITextLine } from './TextLine';
+import { ITextParagraph } from './TextParagraph';
+import { ITextBoxAlignment as _IAlignment } from './TextBoxAlignment';
+/**
+ * Represents a rectangular container for text and its formatting within a document.
+ *
+ * A TextFrame allows precise control over the positioning, size (width and height),
+ * layout, and appearance of text content.
+ */
+export interface ITextFrame {
+    readonly wrapped: boolean;
+    readonly insets: Rectangle;
+    readonly orientation: ITextFrame.Orientation;
+    readonly autoFit: ITextFrame.Autofit;
+    readonly fontScale: number;
+    readonly vertical: boolean;
+    readonly columnCount: number;
+    readonly columnSpacing: number;
+    readonly verticalAlignment: ITextFrame.VerticalAlignment;
+    /**
+     * This is different then center aligned text.
+     */
+    readonly horizontalCentered: boolean;
+    readonly lineReduction: number;
+    readonly isSpaceFirstLastPara: boolean;
+    /**
+     * Returns the presetTextWarp.
+     * TODO - implement this.
+    */
+    readonly presetTextWarp: string | null;
+    readonly paragraphs: ITextParagraph[];
+    visitParas(visitor: TextVisitor): void;
+    visitLines(visitor: TextVisitor): void;
+    /**
+     * Before using the bounds of a textFrame the layout must be called.
+     * This will then return a a clone of this ITextFrame that can be
+     * placed and rendered.
+     *
+     * @param dimensions will cause the text to wrap. If bounds are not specified or only a dimension then it will not wrap.
+     */
+    layout(dimensions?: Partial<Size>): ITextFrame;
+    /**
+     * This is the bound of a textfield include any whitespace
+     */
+    readonly bounds: Readonly<Bounds>;
+    /**
+     * This is the bound of a text not include whitespace
+     */
+    readonly textBounds: Readonly<Bounds>;
+    readonly lines: ITextLine[];
+    /**
+     * Creates a simple text frame that can be used for rendering and/or measuring.
+     * @param text The text to use
+     * @param allowWrap If `true` then will try to wrap on natural breaks. Defaults the the current settings.
+     */
+    createTextFrame(text: string, allowWrap?: boolean): ITextFrame;
+}
+/**
+ * {@inheritDoc ITextFrame}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ITextFrame}
+ */
+export declare namespace ITextFrame {
+    namespace IAlignment {
+        type Properties = _IAlignment.Properties;
+        type JSON = _IAlignment.JSON;
+        /**
+         * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
+         */
+        type Modifiers = _IAlignment.Modifiers;
+        /**
+         * Options for updating an IAlignment.
+         */
+        type Update = _IAlignment.Update;
+    }
+    type IAlignment = _IAlignment;
+    /**
+     * Represents a tab stop within a text frame or paragraph.
+     */
+    class TabStop {
+        /**
+         * The position (offset) of the tab stop relative to the left margin of the container, measured in points.
+         */
+        offset: number;
+        /**
+         * The alignment of text at the tab stop.
+         */
+        align: ITextFrame.TabStopAlignment;
+    }
+    /**
+     * Horizontal alignment of text within a cell.
+     */
+    const HorizontalAlignment: {
+        /**
+         * Aligned based on the data value.
+         * Text data is left-aligned. Numbers, dates, and times are right-aligned. Boolean types are centered.
+         */
+        readonly General: "general";
+        /**
+         * Aligned to the left.
+         */
+        readonly Left: "left";
+        /**
+         * Aligned in the center.
+         */
+        readonly Center: "center";
+        /**
+         * Aligned to the right.
+         */
+        readonly Right: "right";
+        /**
+         * Aligned to the left and right margins.
+         * Spacing will be inserted between 'words
+      .   */
+        readonly Justify: "justify";
+        /**
+         * Each 'word' in each line of text inside the cell is evenly distributed
+         * across the width of the cell, with flush right and left margins.
+         *
+         * When there is also an indent value to apply, both the left and right side
+         * of the cell are padded by the indent value.
+         * A 'word' is a set of characters with no space character in them.
+         * Two lines inside a cell are separated by a carriage return.
+         */
+        readonly Distributed: "distributed";
+        /**
+         * The horizontal alignment is centered across multiple cells.
+         * The number of cells is determined by the number of consecutive blank cells
+         * that also have an alignment of CenterContinuous.
+         */
+        readonly CenterContinuous: "centerContinuous";
+        /**
+         * The value of the cell should be repeated across the entire width of the cell.
+         * If blank cells to the right also have the fill alignment, they are also filled
+         * with the value, using a convention similar to centerContinuous.
+         */
+        readonly Fill: "fill";
+    };
+    type HorizontalAlignment = typeof HorizontalAlignment[keyof typeof HorizontalAlignment];
+    /**
+     * Specifies the vertical alignment of text within a text frame.
+     */
+    const VerticalAlignment: {
+        /**
+         * Aligned to the top.
+         */
+        readonly Top: "top";
+        /**
+         * Aligned to the center.
+         */
+        readonly Center: "center";
+        /**
+         * Aligned to the bottom.
+         */
+        readonly Bottom: "bottom";
+        /**
+         * The vertical alignment of lines of text is distributed vertically,
+         * where each line of text inside the cell is evenly distributed across the height of the cell,
+         * with flush top and bottom margins.
+         */
+        readonly Justify: "justify";
+        /**
+         * Just like Justify, expect that all lines with a single word are centered and the last line is also distributed.
+         */
+        readonly Distributed: "distributed";
+    };
+    type VerticalAlignment = typeof VerticalAlignment[keyof typeof VerticalAlignment];
+    /**
+     * Specifies the orientation in which text is displayed.
+     */
+    const Orientation: {
+        /**
+         * Horizontal text. This is the default.
+         */
+        readonly Horizontal: "horizontal";
+        /**
+         * Vertical orientation.
+         *
+         * @remarks
+         * Each line is 90 degrees rotated clockwise, so it goes from top to bottom; each next line is to the left from
+         * the previous one.
+         */
+        readonly Vertical: "90";
+        /**
+         * Vertical orientation.
+         *
+         * @remarks
+         * Each line is 270 degrees rotated clockwise, so it goes from bottom to top; each next line is to the right from
+         * the previous one.
+         */
+        readonly Vertical270: "270";
+        /**
+          * Determines if all of the text is vertical; ('one letter on top of another').
+          *
+          * **Not Supported**
+          */
+        readonly Stacked: "stacked";
+    };
+    type Orientation = typeof Orientation[keyof typeof Orientation];
+    /**
+     * Specifies the reading order of text within a text frame.
+     */
+    const ReadingDirection: {
+        /**
+         * The reading direction is automatically determined based on the text content.
+         */
+        readonly Auto: "auto";
+        /**
+         * The reading direction is from left to right.
+         */
+        readonly LeftToRight: "ltr";
+        /**
+         * The reading direction is from right to left.
+         */
+        readonly RightToLeft: "rtl";
+    };
+    type ReadingDirection = typeof ReadingDirection[keyof typeof ReadingDirection];
+    /**
+     * The behavior of the text when it exceeds the size of the bounding box.
+     */
+    const Overflow: {
+        /**
+         * Visible means that the text will attempt to be visible on overflow.
+         * It can still be obscured (either z-index, or another blocking element) or fall out of the viewport.
+         */
+        readonly Visible: "visible";
+        /**
+         * Wrap text to keep within the left right margins but may overflow vertically.
+         */
+        readonly Wrap: "wrap";
+        /**
+         *  Note - This is not part of the OOXML spec
+         */
+        readonly Clip: "clip";
+        /**
+         * Shrinks text to fit within the bounding area
+         */
+        readonly Shrink: "shrink";
+        /** Not OOXML spec - Not support */
+        readonly Ellipsis: "ellipsis";
+    };
+    type Overflow = typeof Overflow[keyof typeof Overflow];
+    /**
+     * How the text should fit within the bounding area.
+     */
+    const Autofit: {
+        /**
+         * Specifies that text within the text body should not be auto-fit to the bounding box.
+         * Auto-fitting is when text within a text box is scaled in order to remain inside
+         * the text box.
+         */
+        readonly None: "none";
+        /**
+         * Specifies that text within the text body should be normally auto-fit to the bounding box.
+         * AutoFitting is when text within a text box is scaled in order to remain inside the text box.
+         *
+         * <p>
+         * <em>Example:</em> Consider the situation where a user is building a diagram and needs
+         * to have the text for each shape that they are using stay within the bounds of the shape.
+         * An easy way this might be done is by using NORMAL autofit
+         * </p>
+         */
+        readonly Normal: "normal";
+        /**
+         * Specifies that a shape should be auto-fit to fully contain the text described within it.
+         * Auto-fitting is when text within a shape is scaled in order to contain all the text inside.
+         *
+         * <p>
+         * <em>Example:</em> Consider the situation where a user is building a diagram and needs to have
+         * the text for each shape that they are using stay within the bounds of the shape.
+         * An easy way this might be done is by using SHAPE autofit
+         * </p>
+         */
+        readonly Shape: "shape";
+    };
+    type Autofit = typeof Autofit[keyof typeof Autofit];
+    /**
+     * Specifies the alignment of a tab stop within a text frame or paragraph.
+     */
+    const TabStopAlignment: {
+        /**
+         * The default tab stop alignment, typically left-aligned for left-to-right text and right-aligned for right-to-left text.
+         */
+        readonly Default: "default";
+        /**
+         * Aligns text at the tab stop to the left.
+         */
+        readonly Left: "left";
+        /**
+         * Aligns text at the tab stop to the right.
+         */
+        readonly Right: "right";
+        /**
+         * Centers text at the tab stop.
+         */
+        readonly Center: "center";
+    };
+    type TabStopAlignment = typeof TabStopAlignment[keyof typeof TabStopAlignment];
+    interface CloneableTextFrame extends ITextFrame {
+        clone(visitor?: TextVisitor): ITextFrame;
+        equals(other: ITextFrame): boolean;
+    }
+    /**
+     * Returns a css equivalent of the horizontal text alignment.
+     */
+    const toCSSHorizontalTextAlign: (align: ITextFrame.HorizontalAlignment) => CSSTextAlign;
+}
+//# sourceMappingURL=ITextFrame.d.ts.map

package/types/src/text/TextBoxAlignment.d.ts

@@ -0,0 +1,141 @@
+import { ITextFrame } from './ITextFrame';
+import { IStyle } from '../style';
+/**
+ * Provided options for aligned text within a bounding box.
+ */
+export interface ITextBoxAlignment {
+    /**
+     * Types of horizontal alignment.
+     */
+    getHorizontal(): ITextFrame.HorizontalAlignment;
+    /**
+     * Sets the horizontal alignment
+     *
+     * @param horizontal The horizontal alignment
+     */
+    setHorizontal(horizontal: ITextFrame.HorizontalAlignment | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * Types of horizontal alignment.
+     */
+    getVertical(): ITextFrame.VerticalAlignment;
+    /**
+     * Sets the vertical alignment
+     *
+     * @param vertical The vertical alignment
+     */
+    setVertical(vertical: ITextFrame.VerticalAlignment | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * An integer value, where an increment of 1 represents 3 spaces.
+     * Indicates the number of spaces (of the normal style font) of indentation for text in a cell.
+     *
+     * @remarks
+     * This is only applied for alignments: left, right, and distributed.
+     */
+    getIndent(): number;
+    /**
+     * Sets the indentation
+     *
+     * @param indent The indentation
+     */
+    setIndent(indent: number | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * Indicates additional number of spaces of indentation to adjust for text in a cell.
+     */
+    getRelativeIndent(): number;
+    /**
+     * Sets the relative indentation
+     *
+     * @param relativeIndent The relative indentation
+     */
+    setRelativeIndent(relativeIndent: number | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * The behavior for text that does not fit with the cell bounds.
+     * @see
+     * {@link ITextFrame.Overflow}
+     */
+    getOverflow(): ITextFrame.Overflow;
+    /**
+     * Sets the overflow behavior
+     *
+     * @param overflow The overflow behavior
+     */
+    setOverflow(overflow: ITextFrame.Overflow | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * Rotation of the text.
+     * @defaultValue 0
+     */
+    getRotation(): number;
+    /**
+     * Sets the rotation
+     *
+     * @param rotation The rotation
+     */
+    setRotation(rotation: number | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * If the text should stack vertically instead of horizontally.
+     */
+    getStacked(): boolean;
+    /**
+     * Sets the stacked
+     *
+     * @param stacked The stacked
+     */
+    setStacked(stacked: boolean | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * If the cells justified or distributed alignment should be used on the last line of text.
+     * (This is typical for East Asian alignments but not typical in other contexts.)
+     */
+    getJustifyLastLine(): boolean;
+    /**
+     * Sets the justified last line
+     *
+     * @param justifyLastLine The justified last line
+     */
+    setJustifyLastLine(justifyLastLine: boolean | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    /**
+     * The direction the cell is being read.
+     */
+    getReadingDirection(): ITextFrame.ReadingDirection;
+    /**
+     * Sets the reading direction
+     *
+     * @param readingDirection The reading direction
+     */
+    setReadingDirection(readingDirection: ITextFrame.ReadingDirection | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
+    toJSON(): ITextBoxAlignment.JSON;
+    /**
+     * For runtime type checking.
+     */
+    readonly isITextBoxAlignment: true;
+}
+/**
+ * Provided options for aligned text within a bounding box.
+ */
+export declare namespace ITextBoxAlignment {
+    /**
+     * Text alignment rules for when text is placed in a bounding box.
+     * (for example a TableCell or a Shape).
+     */
+    interface Properties {
+        horizontal?: ITextFrame.HorizontalAlignment;
+        vertical?: ITextFrame.VerticalAlignment;
+        indent?: number;
+        relativeIndent?: number;
+        overflow?: ITextFrame.Overflow;
+        rotation?: number;
+        stacked?: boolean;
+        justifyLastLine?: boolean;
+        readingDirection?: ITextFrame.ReadingDirection;
+    }
+    interface JSON extends Properties {
+    }
+    /**
+     * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
+     */
+    type Modifiers = Partial<ITextBoxAlignment.Properties>;
+    /**
+     * Options for updating an ITextBoxAlignment.
+     */
+    type Update = ITextBoxAlignment | Modifiers | string | null;
+}
+//# sourceMappingURL=TextBoxAlignment.d.ts.map

package/types/src/text/TextFrame.d.ts

@@ -0,0 +1,43 @@
+import { Size, Bounds, Rectangle } from '@sheetxl/utils';
+import { TextVisitor } from './TextVisitor';
+import { ITextLine } from './TextLine';
+import { ITextParagraph } from './TextParagraph';
+import { ITextFrame } from './ITextFrame';
+import { ITextBoxAlignment } from './TextBoxAlignment';
+import { IStyledFont } from './richtext';
+export declare class TextFrame {
+    private _private;
+    private _bounds;
+    private _textBounds;
+    private _lines;
+    private _lastLayoutSize;
+    private _lastLayout;
+    private _defaultFont;
+    private _alignment;
+    constructor(overrides: Partial<ITextFrame>, defaultFont: IStyledFont, alignment: ITextBoxAlignment, lines?: ITextLine[] | null, bounds?: Bounds | null, textBounds?: Bounds | null);
+    visitParas(visitor: TextVisitor): void;
+    visitLines(visitor: TextVisitor): void;
+    layout(size?: Partial<Size> | null): ITextFrame;
+    clone(visitor?: TextVisitor): ITextFrame;
+    equals(other: ITextParagraph): boolean;
+    /** {@inheritDoc ITextFrame.createTextFrame} */
+    createTextFrame(text: string, allowWrap?: boolean): ITextFrame;
+    get bounds(): Bounds;
+    get textBounds(): Bounds;
+    get lines(): ITextLine[];
+    get wrapped(): boolean;
+    get insets(): Rectangle;
+    get orientation(): ITextFrame.Orientation;
+    get autoFit(): ITextFrame.Autofit;
+    get fontScale(): number;
+    get vertical(): boolean;
+    get columnCount(): number;
+    get columnSpacing(): number;
+    get verticalAlignment(): ITextFrame.VerticalAlignment;
+    get horizontalCentered(): boolean;
+    get lineReduction(): number;
+    get isSpaceFirstLastPara(): boolean;
+    get presetTextWarp(): string | null;
+    get paragraphs(): ITextParagraph[];
+}
+//# sourceMappingURL=TextFrame.d.ts.map

package/types/src/text/TextLine.d.ts

@@ -0,0 +1,24 @@
+import { Bounds } from '@sheetxl/utils';
+import { IBullet } from './Bullet';
+import { ITextRun } from './TextRun';
+/**
+ * Represents a single line with an ITextFrame
+ */
+export interface ITextLine {
+    readonly bullet: IBullet | null;
+    readonly runs: ITextRun[];
+    readonly bounds: Bounds;
+    readonly baseline: number;
+}
+/**
+ * A default text line.
+ */
+export declare class DefaultTextLine implements ITextLine {
+    _private: any;
+    constructor(bounds: Bounds | null, baseline: number, runs: ITextRun[]);
+    get bounds(): any;
+    get baseline(): any;
+    get runs(): any;
+    get bullet(): null;
+}
+//# sourceMappingURL=TextLine.d.ts.map

package/types/src/text/TextParagraph.d.ts

@@ -0,0 +1,61 @@
+import { Bounds } from '@sheetxl/utils';
+import { ITextFrame } from './ITextFrame';
+import { TextVisitor } from './TextVisitor';
+import { IBullet } from './Bullet';
+import { PlacedTextRun, ITextRun } from './TextRun';
+/**
+ * Represents a collection of runs with specific information about white spacing before/after.
+ */
+export interface ITextParagraph {
+    /**
+     * This is used if the run doesn't have a font or in the case where there is no run (Empty line)
+     */
+    readonly defaultFontSize: number;
+    readonly defaultTabSize: number;
+    readonly tabOverrides: ITextFrame.TabStop[];
+    readonly spacingBefore: number;
+    readonly spacingAfter: number;
+    readonly lineSpacing: number;
+    readonly align: ITextFrame.HorizontalAlignment;
+    readonly endParagraphSize: number;
+    readonly indentLevel: number;
+    readonly leadingIndent: number;
+    readonly hangingIndent: number;
+    readonly rightMargin: number;
+    readonly bullet: IBullet | null;
+    readonly runs: ITextRun[];
+}
+export interface PlacedTextParagraph extends ITextParagraph {
+    /**
+     * Bounds is not copied during clone.
+     */
+    readonly bounds?: Bounds;
+    readonly runs: PlacedTextRun[];
+}
+export interface CloneableTextParagraph extends ITextParagraph {
+    clone(visitor?: TextVisitor): ITextParagraph;
+    equals(other: ITextParagraph): boolean;
+}
+export declare class DefaultTextParagraph implements ITextParagraph, PlacedTextParagraph, CloneableTextParagraph {
+    private _private;
+    private _bounds?;
+    constructor(overrides: Partial<ITextParagraph>);
+    clone(visitor?: TextVisitor): ITextParagraph;
+    equals(other: ITextParagraph): boolean;
+    get bounds(): Bounds | undefined;
+    get defaultFontSize(): number;
+    get defaultTabSize(): number;
+    get tabOverrides(): ITextFrame.TabStop[];
+    get spacingBefore(): number;
+    get spacingAfter(): number;
+    get lineSpacing(): number;
+    get align(): ITextFrame.HorizontalAlignment;
+    get endParagraphSize(): number;
+    get indentLevel(): number;
+    get leadingIndent(): number;
+    get hangingIndent(): number;
+    get rightMargin(): number;
+    get bullet(): IBullet | null;
+    get runs(): ITextRun[];
+}
+//# sourceMappingURL=TextParagraph.d.ts.map

package/types/src/text/TextRotation.d.ts

@@ -0,0 +1,106 @@
+import { Size, Bounds, Point } from '@sheetxl/utils';
+import { ITextFrame } from './ITextFrame';
+/**
+ * Rotated cell-text layout (the Excel model).
+ *
+ * Rotated text is NOT a rotated block. Each laid-out line is an independent strip drawn at the
+ * rotation angle:
+ *
+ * 1. The cell height is a hard constraint. A line breaks when its rotated extent reaches the
+ *    content-box top/bottom — the available text length per line is
+ *    `(height - lineHeight·|cos θ|) / |sin θ|` (see {@link getLineLength}).
+ * 2. Consecutive strips tile exactly: each is advanced horizontally by `-lineHeight / sin θ`
+ *    (see {@link getAdvance}) — up-slanted text (CSS 270..360) marches right, down-slanted
+ *    (CSS 0..90) marches left, in reading order.
+ * 3. The horizontal direction is free: the footprint grows/overflows sideways like ordinary
+ *    overflow text; alignment positions the whole set within the content box.
+ *
+ * All output is pure geometry (origins + one shared angle), renderer-agnostic: a DOM renderer maps
+ * each line to `transform: rotate(θ); transform-origin: 0 0` at `origin`; a canvas renderer uses
+ * `translate(origin) + rotate(θ)`. Angles are CSS degrees (clockwise, y-down) as returned by
+ * `ITextBoxAlignment.getRotation`.
+ */
+/**
+ * A single rotated line strip.
+ */
+export interface Line {
+    /**
+     * Where the strip's un-rotated top-left sits (content-box coordinate space). The strip is the
+     * line's box (`size`) rotated by the layout {@link Layout.angle angle} **about this point**.
+     */
+    origin: Point;
+    /** The un-rotated strip box: the line's text width × line height. */
+    size: Size;
+    /** The axis-aligned bounds of the rotated strip. */
+    bounds: Bounds;
+}
+/**
+ * The placed geometry for all lines — see {@link layoutLines}.
+ */
+export interface Layout {
+    /** The rotation, CSS degrees clockwise, normalized to [0, 360). Never 0 or 180 (callers skip). */
+    angle: number;
+    /**
+     * The available text length along a rotated line before it exhausts the content height. Wrapped
+     * text breaks at this length; fit tests (`####`, repeat fills) measure against it.
+     */
+    lineLength: number;
+    /**
+     * The signed horizontal advance between consecutive line origins (`-lineHeight / sin θ`).
+     * Positive marches right (up-slanted text), negative marches left (down-slanted).
+     */
+    advance: number;
+    /** One entry per laid-out text line, in reading order. */
+    lines: readonly Line[];
+    /** The axis-aligned union of all strips — the painted footprint (may exceed the content box). */
+    bounds: Bounds;
+}
+/**
+ * Normalizes CSS degrees to [0, 360).
+ */
+export declare function normalizeAngle(deg: number): number;
+/**
+ * Returns `true` if the angle participates in rotated layout (non-degenerate sine). Multiples of
+ * 180° render as ordinary horizontal text (a 180° flip is a renderer transform, not a layout).
+ */
+export declare function isRotatedLayout(deg: number): boolean;
+/**
+ * The available text length along one rotated line within `contentHeight`.
+ *
+ * A strip of thickness `lineHeight` at angle θ spans `w·|sin θ| + lineHeight·|cos θ|` vertically;
+ * solving for the length that exactly fills the height gives
+ * `(contentHeight - lineHeight·|cos θ|) / |sin θ|`. At ±90° this degenerates to `contentHeight`.
+ * Clamped to ≥ 1 so a too-short row still lays out (and wraps per-character like a too-narrow
+ * column does).
+ */
+export declare function getLineLength(contentHeight: number, lineHeight: number, deg: number): number;
+/**
+ * The signed horizontal advance between consecutive strips: `-lineHeight / sin θ`.
+ *
+ * Derived by translating a strip perpendicular by exactly `lineHeight` (adjacent, no overlap) and
+ * sliding it back along its own direction onto the shared anchor edge — the net move is purely
+ * horizontal. Positive = next line to the right (up-slanted text), negative = left (down-slanted).
+ */
+export declare function getAdvance(lineHeight: number, deg: number): number;
+/**
+ * Lays out rotated line strips within a content box.
+ *
+ * @param lineSizes The un-rotated line boxes (width = text width, height = line height), in
+ *  reading order. Only sizes are used; positions are derived here.
+ * @param deg The rotation in CSS degrees (must satisfy {@link isRotatedLayout}).
+ * @param content The content box (cell box minus insets), in the caller's coordinate space.
+ * @param horizontal The resolved horizontal alignment (`General` already resolved to left/right).
+ *  At diagonal angles it applies twice, matching Excel: along each line's chord (a short last line
+ *  slides toward the reading end) and to the whole footprint against the content box. At ±90° it
+ *  places the footprint only — the chord is vertical there, and sliding along it belongs to
+ *  `vertical`.
+ * @param vertical The vertical alignment. Diagonal angles: applied to the whole footprint against
+ *  the content box. ±90°: applied per line ALONG its chord with screen semantics (Top hugs every
+ *  line to the top edge, Center centers each line, Bottom hugs the bottom).
+ *
+ * @remarks
+ * The footprint may exceed the content box in either axis — rotated text overflows; clipping is a
+ * consumer decision.
+ */
+export declare function layoutLines(lineSizes: readonly Size[], deg: number, content: Bounds, horizontal: ITextFrame.HorizontalAlignment, vertical: ITextFrame.VerticalAlignment): Layout;
+//# sourceMappingURL=TextRotation.d.ts.map