nehan/dist/used-region-resolver.js

Html layout engine for paged-media written in Typescript

import { Config, Display, BorderCollapse, CssCascade, ReplacedElement, } from './public-api';
export class UsedRegionResolver {
    static select(element) {
        const display = Display.load(element);
        const float = CssCascade.getValue(element, "float");
        const position = CssCascade.getValue(element, "position");
        const isRe = ReplacedElement.isReplacedElement(element);
        if (float !== "none") {
            return isRe ? ReFloatBlockRegionResolver.instance : FloatBlockRegionResolver.instance;
        }
        if (position === "absolute") {
            return isRe ? ReAbsoluteRegionResolver.instance : AbsoluteRegionResolver.instance;
        }
        if (display.isInlineBlockFlow()) {
            return isRe ? ReInlineBlockRegionResolver.instance : InlineBlockRegionResolver.instance;
        }
        if (display.isInlineLevel()) {
            return isRe ? ReInlineRegionResolver.instance : InlineRegionResolver.instance;
        }
        if (display.isBlockLevel()) {
            return isRe ? ReBlockRegionResolver.instance : BlockRegionResolver.instance;
        }
        console.error("select resolver failed.");
        return InlineRegionResolver.instance;
    }
}
class BlockRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        if (display.isTableRow() || display.isTableRowGroup()) {
            const parent = element.parent;
            const borderCollapse = BorderCollapse.load(element);
            if (parent && borderCollapse.isCollapse()) {
                return parseInt(parent.computedStyle.getPropertyValue("measure") || "0");
            }
        }
        if (region.logicalSize.measure.length === "auto") {
            region.edges.margin.clearAutoInline();
            region.logicalSize.measure.length = region.containingMeasure - region.edges.measure;
            return;
        }
        const borderBoxMeasure = region.borderBoxMeasure;
        if (region.boxSizing.isBorderBox()) {
            region.logicalSize.measure.length -= region.edges.borderBoxMeasure;
        }
        else if (region.boxSizing.isPaddingBox()) {
            region.logicalSize.measure.length -= region.edges.padding.measure;
        }
        if (borderBoxMeasure > region.containingMeasure) {
            region.edges.margin.clearInline();
        }
        if (region.edges.margin.isAutoMeasure()) {
            const autoMargin = Math.floor((region.containingMeasure - region.logicalSize.measure.length) / 2);
            region.edges.margin.start.length = region.edges.margin.end.length = autoMargin;
        }
    }
}
BlockRegionResolver.instance = new BlockRegionResolver();
class ReBlockRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        if (region.logicalSize.measure.length === "auto") {
            region.edges.margin.clearAutoInline();
            return;
        }
        if (region.edges.margin.start.length === "auto" && region.edges.margin.end.length === "auto") {
            const autoMarginBoth = Math.floor((region.containingMeasure - region.logicalSize.measure.length) / 2);
            region.edges.margin.start.length = region.edges.margin.end.length = autoMarginBoth;
        }
        else if (region.edges.margin.start.length === "auto" && region.edges.margin.end.length !== "auto") {
            const autoMarginStart = region.containingMeasure - region.logicalSize.measure.length - region.edges.margin.end.length;
            region.edges.margin.start.length = autoMarginStart;
        }
        else if (region.edges.margin.start.length !== "auto" && region.edges.margin.end.length === "auto") {
            const autoMarginEnd = region.containingMeasure - region.logicalSize.measure.length - region.edges.margin.start.length;
            region.edges.margin.end.length = autoMarginEnd;
        }
    }
}
ReBlockRegionResolver.instance = new ReBlockRegionResolver();
class FloatBlockRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
        if (region.logicalSize.measure.isAuto()) {
            if (Config.debugLayout) {
                console.info("auto measure for float element is not allowed in nehan, so use %dpx by default:", Config.defaultFloatMeasure, element);
            }
            region.logicalSize.measure.length = Config.defaultFloatMeasure;
        }
    }
}
FloatBlockRegionResolver.instance = new FloatBlockRegionResolver();
class ReFloatBlockRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
        if (region.logicalSize.measure.isAuto()) {
            if (Config.debugLayout) {
                console.info("auto measure for float element is not allowed in nehan, so use %dpx by default:", Config.defaultFloatMeasure, element);
            }
            region.logicalSize.measure.length = Config.defaultFloatMeasure;
        }
    }
}
ReFloatBlockRegionResolver.instance = new ReFloatBlockRegionResolver();
class InlineRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
    }
}
InlineRegionResolver.instance = new InlineRegionResolver();
class ReInlineRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
    }
}
ReInlineRegionResolver.instance = new ReInlineRegionResolver();
class InlineBlockRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
        if (region.logicalSize.measure.isAuto()) {
            if (element.computedStyle.getPropertyValue("display") !== "table-cell") {
                if (Config.debugLayout) {
                    console.info("auto measure for inline-block element is not allowed in nehan, so use %dpx by default:", Config.defaultInlineBlockMeasure, element);
                }
                region.logicalSize.measure.length = Config.defaultInlineBlockMeasure;
            }
        }
    }
}
InlineBlockRegionResolver.instance = new InlineBlockRegionResolver();
class ReInlineBlockRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
        if (region.logicalSize.measure.isAuto()) {
            if (Config.debugLayout) {
                console.info("auto measure for inline-block element is not allowed in nehan, so use %dpx by default:", Config.defaultInlineBlockMeasure, element);
            }
            region.logicalSize.measure.length = Config.defaultInlineBlockMeasure;
        }
    }
}
ReInlineBlockRegionResolver.instance = new ReInlineBlockRegionResolver();
class AbsoluteRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
    }
}
AbsoluteRegionResolver.instance = new AbsoluteRegionResolver();
class ReAbsoluteRegionResolver {
    constructor() { }
    resolve(element, region, display) {
        region.edges.margin.clearAutoInline();
    }
}
ReAbsoluteRegionResolver.instance = new ReAbsoluteRegionResolver();
//# sourceMappingURL=used-region-resolver.js.map