nehan/dist/logical-size.js

Html layout engine for paged-media written in Typescript

import { Utils, PhysicalSize, } from "./public-api";
export class LogicalSize {
    constructor(args) {
        this.measure = args.measure;
        this.extent = args.extent;
    }
    static load(element) {
        const measure = this.loadMeasure(element);
        if (measure === null) {
            return null;
        }
        const extent = this.loadExtent(element);
        if (extent === null) {
            return null;
        }
        return new LogicalSize({ measure: measure, extent: extent });
    }
    static loadMeasure(element) {
        const value = element.computedStyle.getPropertyValue("measure") || "auto";
        return (value === "auto") ? null : Utils.atoi(value);
    }
    static loadExtent(element) {
        const value = element.computedStyle.getPropertyValue("extent") || "auto";
        return (value === "auto") ? null : Utils.atoi(value);
    }
    static get zero() {
        return new LogicalSize({ measure: 0, extent: 0 });
    }
    toString() {
        return `m:${this.measure}, e:${this.extent}`;
    }
    clone() {
        return new LogicalSize({ measure: this.measure, extent: this.extent });
    }
    canContain(size) {
        return (this.measure >= size.measure && this.extent >= size.extent);
    }
    isZero() {
        return this.measure === 0 && this.extent === 0;
    }
    hasZero() {
        return this.measure === 0 || this.extent === 0;
    }
    getPhysicalSize(writingMode) {
        return new PhysicalSize({
            width: this.getWidth(writingMode),
            height: this.getHeight(writingMode)
        });
    }
    getWidth(writingMode) {
        return writingMode.isTextVertical() ? this.extent : this.measure;
    }
    getHeight(writingMode) {
        return writingMode.isTextVertical() ? this.measure : this.extent;
    }
    resize(maxSize) {
        if (this.measure <= maxSize.measure && this.extent <= maxSize.extent) {
            return this.clone();
        }
        const size = { measure: this.measure, extent: this.extent };
        const ePerM = this.extent / this.measure;
        const mPerE = this.measure / this.extent;
        while (size.measure > maxSize.measure || size.extent > maxSize.extent) {
            const dMeasure = size.measure - maxSize.measure;
            const dExtent = size.extent - maxSize.extent;
            if (dMeasure > dExtent) {
                size.measure = maxSize.measure;
                size.extent = size.extent - dMeasure * ePerM;
            }
            else {
                size.extent = maxSize.extent;
                size.measure = size.measure - dExtent * mPerE;
            }
        }
        return new LogicalSize({
            measure: Math.floor(size.measure),
            extent: Math.floor(size.extent)
        });
    }
    acceptCssEvaluator(visitor) {
        return visitor.visitSize(this);
    }
}
//# sourceMappingURL=logical-size.js.map