@vivliostyle/core

/** * Copyright 2013 Google, Inc. * Copyright 2015 Trim-marks Inc. * Copyright 2019 Vivliostyle Foundation * * Vivliostyle.js is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Vivliostyle.js is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with Vivliostyle.js. If not, see <http://www.gnu.org/licenses/>. * * @fileoverview Layout - Fills a column with styled content. * This file does not communicate with the styling system directly. * Instead it goes through the layout interface that gives it one view tree * node at a time. */ import * as LayoutRetryers from "./layout-retryers"; import * as BreakPosition from "./break-position"; import * as Css from "./css"; import * as GeometryUtil from "./geometry-util"; import * as PageFloats from "./page-floats"; import * as Matchers from "./matchers"; import * as PseudoElement from "./pseudo-element"; import * as Task from "./task"; import * as VtreeImpl from "./vtree"; import { FragmentLayoutConstraintType, Layout, RepetitiveElement, Selectors, Vtree } from "./types"; export declare const isInstanceOfAfterIfContinuesLayoutConstraint: typeof Selectors.isInstanceOfAfterIfContinuesLayoutConstraint; export declare const registerFragmentIndex: typeof Matchers.NthFragmentMatcher.registerFragmentIndex; export declare const clearFragmentIndices: typeof Matchers.NthFragmentMatcher.clearFragmentIndices; export declare class AfterIfContinues implements Selectors.AfterIfContinues { readonly sourceNode: Element; readonly styler: PseudoElement.PseudoelementStyler; constructor(sourceNode: Element, styler: PseudoElement.PseudoelementStyler); createElement(column: Layout.Column, parentNodeContext: Vtree.NodeContext): Task.Result<Element>; private createNodePositionForPseudoElement; private createShadowContext; } export declare class AfterIfContinuesLayoutConstraint implements Selectors.AfterIfContinuesLayoutConstraint { nodeContext: Vtree.NodeContext; afterIfContinues: Selectors.AfterIfContinues; pseudoElementHeight: number; flagmentLayoutConstraintType: FragmentLayoutConstraintType; constructor(nodeContext: Vtree.NodeContext, afterIfContinues: Selectors.AfterIfContinues, pseudoElementHeight: number); /** @override */ allowLayout(nodeContext: Vtree.NodeContext, overflownNodeContext: Vtree.NodeContext, column: Layout.Column): boolean; /** @override */ nextCandidate(nodeContext: Vtree.NodeContext): boolean; /** @override */ postLayout(allowed: boolean, positionAfter: Vtree.NodeContext, initialPosition: Vtree.NodeContext, column: Layout.Column): void; /** @override */ finishBreak(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<boolean>; getRepetitiveElements(): AfterIfContinuesElementsOffset; /** @override */ equalsTo(constraint: Layout.FragmentLayoutConstraint): boolean; /** @override */ getPriorityOfFinishBreak(): number; } export declare class AfterIfContinuesElementsOffset implements Selectors.AfterIfContinuesElementsOffset { nodeContext: any; pseudoElementHeight: any; constructor(nodeContext: any, pseudoElementHeight: any); /** @override */ calculateOffset(nodeContext: Vtree.NodeContext): number; /** @override */ calculateMinimumOffset(nodeContext: Vtree.NodeContext): number; affectTo(nodeContext: Vtree.NodeContext): boolean; } export declare function processAfterIfContinues(result: Task.Result<Vtree.NodeContext>, column: Layout.Column): Task.Result<Vtree.NodeContext>; export declare function processAfterIfContinuesOfAncestors(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<boolean>; export declare function calculatePseudoElementHeight(nodeContext: Vtree.NodeContext, column: Layout.Column, pseudoElement: Element): number; export declare const mediaTags: { img: boolean; svg: boolean; audio: boolean; video: boolean; }; /** * Represents a constraint on layout */ export declare type LayoutConstraint = Layout.LayoutConstraint; /** * Represents a constraint that allows layout if all the constraints it contains * allow layout. */ export declare class AllLayoutConstraint implements LayoutConstraint { readonly constraints: LayoutConstraint[]; constructor(constraints: LayoutConstraint[]); /** * @override */ allowLayout(nodeContext: Vtree.NodeContext): boolean; } /** * Represents constraints on laying out fragments */ export declare type FragmentLayoutConstraint = Layout.FragmentLayoutConstraint; export declare type BreakPositionAndNodeContext = Layout.BreakPositionAndNodeContext; /** * Potential breaking position inside CSS box (between lines). * @param checkPoints array of breaking points for breakable block */ export declare class BoxBreakPosition extends BreakPosition.AbstractBreakPosition implements Layout.BoxBreakPosition { readonly checkPoints: Vtree.NodeContext[]; readonly penalty: number; private alreadyEvaluated; breakNodeContext: Vtree.NodeContext; constructor(checkPoints: Vtree.NodeContext[], penalty: number); /** * @override */ findAcceptableBreak(column: Column, penalty: number): Vtree.NodeContext; /** * @override */ getMinBreakPenalty(): number; /** @override */ getNodeContext(): Vtree.NodeContext; } export declare function validateCheckPoints(checkPoints: Vtree.NodeContext[]): void; export declare function isSpecialInlineDisplay(display: string): boolean; export declare class Column extends VtreeImpl.Container implements Layout.Column { layoutContext: Vtree.LayoutContext; clientLayout: Vtree.ClientLayout; readonly layoutConstraint: LayoutConstraint; readonly pageFloatLayoutContext: PageFloats.PageFloatLayoutContext; last: Node; viewDocument: Document; flowRootFormattingContext: Vtree.FormattingContext; isFloat: boolean; isFootnote: boolean; startEdge: number; endEdge: number; beforeEdge: number; afterEdge: number; footnoteEdge: number; box: GeometryUtil.Rect; chunkPositions: Vtree.ChunkPosition[]; bands: GeometryUtil.Band[]; overflown: boolean; breakPositions: BreakPosition.BreakPosition[]; pageBreakType: string | null; forceNonfitting: boolean; leftFloatEdge: number; rightFloatEdge: number; bottommostFloatTop: number; stopAtOverflow: boolean; lastAfterPosition: Vtree.NodePosition | null; fragmentLayoutConstraints: FragmentLayoutConstraint[]; pseudoParent: Column; nodeContextOverflowingDueToRepetitiveElements: Vtree.NodeContext | null; blockDistanceToBlockEndFloats: number; computedBlockSize: number; constructor(element: Element, layoutContext: Vtree.LayoutContext, clientLayout: Vtree.ClientLayout, layoutConstraint: LayoutConstraint, pageFloatLayoutContext: PageFloats.PageFloatLayoutContext); getTopEdge(): number; getBottomEdge(): number; getLeftEdge(): number; getRightEdge(): number; isFloatNodeContext(nodeContext: Vtree.NodeContext): boolean; stopByOverflow(nodeContext: Vtree.NodeContext): boolean; isOverflown(edge: number): boolean; getExclusions(): GeometryUtil.Shape[]; openAllViews(position: Vtree.NodePosition): Task.Result<Vtree.NodeContext>; calculateOffsetInNodeForNodeContext(position: Vtree.NodePosition): number; /** * @param count first-XXX nesting identifier */ maybePeelOff(position: Vtree.NodeContext, count: number): Task.Result<Vtree.NodeContext>; /** * Builds the view until a CSS box edge is reached. * @param position start source position. * @param checkPoints array to append possible breaking points. * @return holding box edge position reached or null if the source is exhausted. */ buildViewToNextBlockEdge(position: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): Task.Result<Vtree.NodeContext>; nextInTree(position: Vtree.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree.NodeContext>; /** * Builds the view for a single unbreakable element. * @param position start source position. * @return holding box edge position reached or null if the source is exhausted. */ buildDeepElementView(position: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; /** * Create a single floating element (for exclusion areas). * @param ref container's child to insert float before (can be null). * @param side float side ("left" or "right"). * @param width float inline dimension. * @param height float box progression dimension. * @return newly created float element. */ createFloat(ref: Node, side: string, width: number, height: number): Element; /** * Remove all the exclusion floats. */ killFloats(): void; /** * Create exclusion floats for a column. */ createFloats(): void; /** * @param nodeContext position after the block * @param checkPoints array of possible breaking points. * @param index index of the breaking point * @param boxOffset box offset * @return edge position */ calculateEdge(nodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[], index: number, boxOffset: number): number; /** * Parse CSS computed length (in pixels) * @param val CSS length in "px" units or a number. * @return value in pixels or 0 if not parsable */ parseComputedLength(val: string | number): number; /** * Reads element's computed CSS margin. */ getComputedMargin(element: Element): GeometryUtil.Insets; /** * Reads element's computed padding + borders. */ getComputedPaddingBorder(element: Element): GeometryUtil.Insets; /** * Reads element's computed CSS insets(margins + border + padding or margins : * depends on box-sizing) */ getComputedInsets(element: Element): GeometryUtil.Insets; /** * Set element's computed CSS insets to Column Container */ setComputedInsets(element: Element, container: Column): void; /** * Set element's computed width and height to Column Container */ setComputedWidthAndHeight(element: Element, container: Column): void; /** * Layout a single unbreakable element. */ layoutUnbreakable(nodeContextIn: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; /** * Layout a single float element. */ layoutFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; setupFloatArea(area: PageFloatArea, floatReference: PageFloats.FloatReference, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): boolean; createPageFloatArea(float: PageFloats.PageFloat | null, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): PageFloatArea | null; layoutSinglePageFloatFragment(continuations: PageFloats.PageFloatContinuation[], floatSide: string, clearSide: string | null, allowFragmented: boolean, strategy: PageFloats.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats.PageFloatFragment | null): Task.Result<SinglePageFloatLayoutResult>; layoutPageFloatInner(continuation: PageFloats.PageFloatContinuation, strategy: PageFloats.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats.PageFloatFragment): Task.Result<boolean>; /** * @returns Represents if the layout was succeeded or not */ private layoutStashedPageFloats; setFloatAnchorViewNode(nodeContext: Vtree.NodeContext): Vtree.NodeContext; resolveFloatReferenceFromColumnSpan(floatReference: PageFloats.FloatReference, columnSpan: Css.Val, nodeContext: Vtree.NodeContext): Task.Result<PageFloats.FloatReference>; layoutPageFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; createJustificationAdjustmentElement(insertionPoint: Node, doc: Document, parentNode: Node, vertical: boolean): HTMLElement; addAndAdjustJustificationElement(nodeContext: Vtree.NodeContext, insertAfter: boolean, node: Node, insertionPoint: Node, doc: Document, parentNode: Node): HTMLElement; compensateJustificationLineHeight(span: Element, br: Element, nodeContext: Vtree.NodeContext): void; /** * Fix justification of the last line of text broken across pages (if * needed). */ fixJustificationIfNeeded(nodeContext: Vtree.NodeContext, endOfColumn: boolean): void; processLineStyling(nodeContext: Vtree.NodeContext, resNodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): Task.Result<Vtree.NodeContext>; isLoneImage(checkPoints: Vtree.NodeContext[]): boolean; getTrailingMarginEdgeAdjustment(trailingEdgeContexts: Vtree.NodeContext[]): number; /** * Layout a single CSS box. */ layoutBreakableBlock(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; postLayoutBlock(nodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): void; findEndOfLine(linePosition: number, checkPoints: Vtree.NodeContext[], isUpdateMaxReachedAfterEdge: boolean): { nodeContext: Vtree.NodeContext; index: number; checkPointIndex: number; }; findAcceptableBreakInside(checkPoints: Vtree.NodeContext[], edgePosition: number, force: boolean): Vtree.NodeContext; resolveTextNodeBreaker(nodeContext: Vtree.NodeContext): TextNodeBreaker; /** * Read ranges skipping special elments */ getRangeBoxes(start: Node, end: Node): Vtree.ClientRect[]; /** * Give block's initial and final nodes, find positions of the line bottoms. * This is, of course, somewhat hacky implementation. * @return position of line breaks */ findLinePositions(checkPoints: Vtree.NodeContext[]): number[]; calculateClonedPaddingBorder(nodeContext: Vtree.NodeContext): number; private getOffsetByRepetitiveElements; findBoxBreakPosition(bp: BoxBreakPosition, force: boolean): Vtree.NodeContext; getAfterEdgeOfBlockContainer(nodeContext: Vtree.NodeContext): number; findFirstOverflowingEdgeAndCheckPoint(checkPoints: Vtree.NodeContext[]): { edge: number; checkPoint: Vtree.NodeContext | null; }; findEdgeBreakPosition(bp: BreakPosition.EdgeBreakPosition): Vtree.NodeContext; /** * Finalize a line break. * @return holing true */ finishBreak(nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>; findAcceptableBreakPosition(): BreakPositionAndNodeContext; doFinishBreak(nodeContext: Vtree.NodeContext, overflownNodeContext: Vtree.NodeContext, initialNodeContext: Vtree.NodeContext, initialComputedBlockSize: number): Task.Result<Vtree.NodeContext>; /** * Determines if a page break is acceptable at this position */ isBreakable(flowPosition: Vtree.NodeContext): boolean; /** * Determines if an indent value is zero */ zeroIndent(val: string | number): boolean; /** * @return true if overflows */ checkOverflowAndSaveEdge(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[]): boolean; /** * Save a possible page break position on a CSS block edge. Check if it * overflows. * @return true if overflows */ checkOverflowAndSaveEdgeAndBreakPosition(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[], saveEvenOverflown: boolean, breakAtTheEdge: string | null): boolean; applyClearance(nodeContext: Vtree.NodeContext): boolean; isBFC(formattingContext: Vtree.FormattingContext): boolean; /** * Skips positions until either the start of unbreakable block or inline * content. Also sets breakBefore on the result combining break-before and * break-after properties from all elements that meet at the edge. */ skipEdges(nodeContext: Vtree.NodeContext, leadingEdge: boolean, forcedBreakValue: string | null): Task.Result<Vtree.NodeContext>; /** * Skips non-renderable positions until it hits the end of the flow or some * renderable content. Returns the nodeContext that was passed in if some * content remains and null if all content could be skipped. */ skipTailEdges(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; layoutFloatOrFootnote(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>; /** * Layout next portion of the source. */ layoutNext(nodeContext: Vtree.NodeContext, leadingEdge: boolean, forcedBreakValue?: string | null): Task.Result<Vtree.NodeContext>; clearOverflownViewNodes(nodeContext: Vtree.NodeContext, removeSelf: boolean): void; initGeom(): void; init(): void; /** * Save the potential breaking position at the edge. Should, in general, save * "after" position but only after skipping all of the "before" ones and * getting to the non-empty content (to get breakAtEdge right). */ saveEdgeBreakPosition(position: Vtree.NodeContext, breakAtEdge: string | null, overflows: boolean): void; /** * @param checkPoints array of breaking points for breakable block */ saveBoxBreakPosition(checkPoints: Vtree.NodeContext[]): void; updateMaxReachedAfterEdge(afterEdge: number): void; /** * @param chunkPosition starting position. * @return holding end position. */ layout(chunkPosition: Vtree.ChunkPosition, leadingEdge: boolean, breakAfter?: string | null): Task.Result<Vtree.ChunkPosition>; isFullWithPageFloats(): boolean; getMaxBlockSizeOfPageFloats(): number; doFinishBreakOfFragmentLayoutConstraints(nodeContext: Vtree.NodeContext): Task.Result<boolean>; /** * @param nodeContext starting position. * @return holding end position. */ doLayout(nodeContext: Vtree.NodeContext, leadingEdge: boolean, breakAfter?: string | null): Task.Result<{ nodeContext: Vtree.NodeContext; overflownNodeContext: Vtree.NodeContext; }>; /** * Re-layout already laid-out chunks. Return the position of the last flow if * there is an overflow. * TODO: deal with chunks that did not fit at all. * @return holding end position. */ redoLayout(): Task.Result<Vtree.ChunkPosition>; saveDistanceToBlockEndFloats(): void; collectElementsOffset(): RepetitiveElement.ElementsOffset[]; } /** * Represents a "pseudo"-column nested inside a real column. * This class is created to handle parallel fragmented flows (e.g. table columns * in a single table row). A pseudo-column behaves in the same way as the * original column, sharing its properties. Property changes on the * pseudo-column are not propagated to the original column. The LayoutContext of * the original column is also cloned and used by the pseudo-column, not to * propagate state changes of the LayoutContext caused by the pseudo-column. * @param column The original (parent) column * @param viewRoot Root element for the pseudo-column, i.e., the root of the * fragmented flow. * @param parentNodeContext A NodeContext generating this PseudoColumn */ export declare class PseudoColumn { startNodeContexts: Vtree.NodeContext[]; private column; constructor(column: Layout.Column, viewRoot: Element, parentNodeContext: Vtree.NodeContext); /** * @param chunkPosition starting position. * @return holding end position. */ layout(chunkPosition: Vtree.ChunkPosition, leadingEdge: boolean): Task.Result<Vtree.ChunkPosition>; findAcceptableBreakPosition(allowBreakAtStartPosition: boolean): Layout.BreakPositionAndNodeContext; /** * @return holing true */ finishBreak(nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>; doFinishBreakOfFragmentLayoutConstraints(positionAfter: Vtree.NodeContext): void; isStartNodeContext(nodeContext: Vtree.NodeContext): boolean; isLastAfterNodeContext(nodeContext: Vtree.NodeContext): boolean; getColumnElement(): Element; getColumn(): Layout.Column; } export declare const firstCharPattern: RegExp; export declare type SinglePageFloatLayoutResult = Layout.SinglePageFloatLayoutResult; export declare function fixJustificationOnHyphen(nodeContext: Vtree.NodeContext, insertAfter: boolean, node: Node, insertionPoint: Node): void; /** * breaking point resolver for Text Node. */ export declare class TextNodeBreaker implements Layout.TextNodeBreaker { breakTextNode(textNode: Text, nodeContext: Vtree.NodeContext, low: number, checkPoints: Vtree.NodeContext[], checkpointIndex: number, force: boolean): Vtree.NodeContext; breakAfterSoftHyphen(textNode: Text, text: string, viewIndex: number, nodeContext: Vtree.NodeContext): number; breakAfterOtherCharacter(textNode: Text, text: string, viewIndex: number, nodeContext: Vtree.NodeContext): number; updateNodeContext(nodeContext: Vtree.NodeContext, viewIndex: number, textNode: Text): Vtree.NodeContext; static instance: TextNodeBreaker; } export declare function resolveHyphenateCharacter(nodeContext: Vtree.NodeContext): string; export declare class ColumnLayoutRetryer extends LayoutRetryers.AbstractLayoutRetryer { readonly leadingEdge: boolean; breakAfter: string | null; private initialPageBreakType; initialComputedBlockSize: number; private initialOverflown; context: { overflownNodeContext: Vtree.NodeContext; }; constructor(leadingEdge: boolean, breakAfter?: string | null); /** * @override */ resolveLayoutMode(nodeContext: Vtree.NodeContext): Layout.LayoutMode; /** * @override */ prepareLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): void; /** * @override */ clearNodes(initialPosition: Vtree.NodeContext): void; /** * @override */ saveState(nodeContext: Vtree.NodeContext, column: Layout.Column): void; /** * @override */ restoreState(nodeContext: Vtree.NodeContext, column: Layout.Column): void; } export declare class DefaultLayoutMode implements Layout.LayoutMode { readonly leadingEdge: boolean; readonly breakAfter: string | null; readonly context: { overflownNodeContext: Vtree.NodeContext; }; constructor(leadingEdge: boolean, breakAfter: string | null, context: { overflownNodeContext: Vtree.NodeContext; }); /** * @override */ doLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<Vtree.NodeContext>; /** * @override */ accept(nodeContext: Vtree.NodeContext, column: Layout.Column): boolean; /** * @override */ postLayout(positionAfter: Vtree.NodeContext, initialPosition: Vtree.NodeContext, column: Layout.Column, accepted: boolean): boolean; } export declare class PageFloatArea extends Column implements Layout.PageFloatArea { readonly floatSide: string; readonly parentContainer: Vtree.Container; private rootViewNodes; private floatMargins; adjustContentRelativeSize: boolean; constructor(floatSide: string, element: Element, layoutContext: Vtree.LayoutContext, clientLayout: Vtree.ClientLayout, layoutConstraint: LayoutConstraint, pageFloatLayoutContext: PageFloats.PageFloatLayoutContext, parentContainer: Vtree.Container); /** * @override */ openAllViews(position: Vtree.NodePosition): Task.Result<Vtree.NodeContext>; convertPercentageSizesToPx(target: Element): void; fixFloatSizeAndPosition(nodeContext: Vtree.NodeContext): void; getContentInlineSize(): number; }