nehan/dist/logical-css-evaluator.js

Html layout engine for paged-media written in Typescript

import { Config, LogicalEdgeMap, LogicalCornerMap, NativeStyleMap, } from './public-api';
export class LogicalCssEvaluator {
    constructor(writingMode) {
        this.writingMode = writingMode;
    }
    visitUnmanagedCssProps(style) {
        const css = new NativeStyleMap();
        Config.unmanagedCssProps.forEach(prop => {
            const unmanagedValue = style.getPropertyValue(prop);
            if (unmanagedValue !== null) {
                css.set(prop, unmanagedValue);
            }
        });
        return css;
    }
    visitFont(font) {
        const css = new NativeStyleMap();
        css.set("font-style", font.style);
        css.set("font-variant", font.variant);
        css.set("font-weight", font.weight);
        css.set("font-stretch", font.stretch);
        css.set("font-size", font.size + "px");
        css.set("font-family", font.family);
        return css;
    }
    visitColor(color) {
        const css = new NativeStyleMap();
        css.set("color", color.value);
        return css;
    }
    visitSizeHori(size) {
        const css = new NativeStyleMap();
        css.set("width", size.measure + "px");
        css.set("height", size.extent + "px");
        return css;
    }
    visitSizeVert(size) {
        const css = new NativeStyleMap();
        css.set("width", size.extent + "px");
        css.set("height", size.measure + "px");
        return css;
    }
    visitSize(size) {
        if (this.writingMode.isTextHorizontal()) {
            return this.visitSizeHori(size);
        }
        return this.visitSizeVert(size);
    }
    visitPosHori(pos) {
        const css = new NativeStyleMap();
        css.set("top", pos.before + "px");
        css.set("left", pos.start + "px");
        return css;
    }
    visitPosVertLtr(pos) {
        const css = new NativeStyleMap();
        css.set("top", pos.start + "px");
        css.set("left", pos.before + "px");
        return css;
    }
    visitPosVertRtl(pos) {
        const css = new NativeStyleMap();
        css.set("top", pos.start + "px");
        css.set("right", pos.before + "px");
        return css;
    }
    visitPos(pos) {
        if (this.writingMode.isTextHorizontal()) {
            return this.visitPosHori(pos);
        }
        if (this.writingMode.isVerticalRl()) {
            return this.visitPosVertRtl(pos);
        }
        return this.visitPosVertLtr(pos);
    }
    visitBackgroundPos(backgroundPos) {
        const css = new NativeStyleMap();
        let value = backgroundPos.value;
        LogicalEdgeMap.select(this.writingMode).forEach((logical, physical) => {
            value = value.replace(logical, physical);
        });
        css.set("background-position", value);
        return css;
    }
    visitLogicalMargin(margin) {
        return margin.getPhysicalEdge(this.writingMode).items.reduce((css, item) => {
            return css.set(margin.getPropByLogicalDirection(item.prop), item.value + "px");
        }, new NativeStyleMap());
    }
    visitLogicalPadding(padding) {
        return padding.getPhysicalEdge(this.writingMode).items.reduce((css, item) => {
            return css.set(padding.getPropByLogicalDirection(item.prop), item.value + "px");
        }, new NativeStyleMap());
    }
    visitLogicalBorderColor(borderColor) {
        return borderColor.getPhysicalEdge(this.writingMode).items.reduce((css, item) => {
            return css.set(borderColor.getPropByLogicalDirection(item.prop), String(item.value));
        }, new NativeStyleMap());
    }
    visitLogicalBorderWidth(borderWidth) {
        return borderWidth.getPhysicalEdge(this.writingMode).items.reduce((css, item) => {
            return css.set(borderWidth.getPropByLogicalDirection(item.prop), item.value + "px");
        }, new NativeStyleMap());
    }
    visitLogicalBorderStyle(borderStyle) {
        return borderStyle.getPhysicalEdge(this.writingMode).items.reduce((css, item) => {
            return css.set(borderStyle.getPropByLogicalDirection(item.prop), String(item.value));
        }, new NativeStyleMap());
    }
    visitLogicalBorderRadius(borderRadius, borderWidth) {
        const cornerMap = LogicalCornerMap.select(this.writingMode);
        return borderRadius.items.reduce((css, item) => {
            if (item.prop.indexOf("before") >= 0 && borderWidth.before <= 0 ||
                item.prop.indexOf("after") >= 0 && borderWidth.after <= 0) {
                return css;
            }
            return css.set(`border-${cornerMap.get(item.prop)}-radius`, String(item.value));
        }, new NativeStyleMap());
    }
    visitLogicalPos(pos) {
        const css = new NativeStyleMap();
        const map = LogicalEdgeMap.select(this.writingMode);
        if (pos.before !== undefined) {
            css.set(map.get("before"), pos.before + "px");
        }
        if (pos.end !== undefined) {
            css.set(map.get("end"), pos.end + "px");
        }
        if (pos.after !== undefined) {
            css.set(map.get("after"), pos.after + "px");
        }
        if (pos.start !== undefined) {
            css.set(map.get("start"), pos.start + "px");
        }
        return css;
    }
}
//# sourceMappingURL=logical-css-evaluator.js.map