NativeScript/ui/styling/font-common.ts

import enums = require("ui/enums");
import definitios = require("ui/styling/font");
import * as converters from "./converters";

export class Font implements definitios.Font {
    public static default = undefined;

    private _fontFamily: string;
    private _fontStyle: string;
    private _fontWeight: string;
    private _fontSize: number;

    get fontFamily(): string {
        return this._fontFamily;
    }
    set fontFamily(value: string) {
        throw new Error("fontFamily is read-only");
    }

    get fontStyle(): string {
        return this._fontStyle;
    }
    set fontStyle(value: string) {
        throw new Error("fontStyle is read-only");
    }

    get fontWeight(): string {
        return this._fontWeight;
    }
    set fontWeight(value: string) {
        throw new Error("fontWeight is read-only");
    }

    get fontSize(): number {
        return this._fontSize;
    }
    set fontSize(value: number) {
        throw new Error("fontSize is read-only");
    }

    get isBold(): boolean {
        return this._fontWeight.toLowerCase() === enums.FontWeight.bold;;
    }
    set isBold(value: boolean) {
        throw new Error("isBold is read-only");
    }

    get isItalic(): boolean {
        return this._fontStyle.toLowerCase() === enums.FontStyle.italic;;
    }
    set isItalic(value: boolean) {
        throw new Error("isItalic is read-only");
    }

    constructor(family: string, size: number, style: string, weight: string) {
        this._fontFamily = family;
        this._fontSize = size;
        this._fontStyle = style;
        this._fontWeight = weight;
    }

    public getAndroidTypeface(): android.graphics.Typeface {
        return undefined;
    }

    public getUIFont(defaultFont: UIFont): UIFont {
        return undefined;
    }

    public withFontFamily(family: string): Font {
        throw new Error("This should be called on the derived class");
    }

    public withFontStyle(style: string): Font {
        throw new Error("This should be called on the derived class");
    }

    public withFontWeight(weight: string): Font {
        throw new Error("This should be called on the derived class");
    }

    public withFontSize(size: number): Font {
        throw new Error("This should be called on the derived class");
    }

    public static equals(value1: Font, value2: Font): boolean {
        // both values are falsy
        if (!value1 && !value2) {
            return true;
        }

        // only one is falsy
        if (!value1 || !value2) {
            return false;
        }

        return value1.fontFamily === value2.fontFamily &&
            value1.fontSize === value2.fontSize &&
            value1.fontStyle === value2.fontStyle &&
            value1.fontWeight === value2.fontWeight;
    }

    public static parse(cssValue: string): Font {
        var parsed = parseFont(cssValue);

        var size = converters.fontSizeConverter(parsed.fontSize);
        size = !!size ? size : undefined;

        return new Font(parsed.fontFamily, size, parsed.fontStyle, parsed.fontWeight);
    }
}

export function parseFontFamily(value: string): Array<string> {
    var result = new Array<string>();
    if (!value) {
        return result;
    }

    var split = value.split(",");
    for (var i = 0; i < split.length; i++) {
        var str = split[i].trim().replace(/['"]+/g, '');
        if (str) {
            result.push(str);
        }
    }
    return result;
}

export module genericFontFamilies {
    export var serif = "serif";
    export var sansSerif = "sans-serif";
    export var monospace = "monospace";
}

var styles = new Set();
["italic", "oblique"].forEach((val, i, a) => styles.add(val));
var weights = new Set();
["bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"].forEach((val, i, a) => weights.add(val));

interface ParsedFont {
    fontStyle?: string;
    fontVariant?: string;
    fontWeight?: string,
    lineHeight?: string,
    fontSize?: string,
    fontFamily?: string
}

function parseFont(fontValue: string): ParsedFont {
    var result: ParsedFont = {
        fontStyle: "normal",
        fontVariant: "normal",
        fontWeight: "normal",
    }

    var parts = fontValue.split(/\s+/);
    var part: string;
    while (part = parts.shift()) {
        if (part === "normal") {
            // nothing to do here
        }
        else if (part === "small-caps") {
            // The only supported font variant in shorthand font
            result.fontVariant = part;
        }
        else if (styles.has(part)) {
            result.fontStyle = part
        }
        else if (weights.has(part)) {
            result.fontWeight = part;
        }
        else if (!result.fontSize) {
            var sizes = part.split("/");
            result.fontSize = sizes[0];
            result.lineHeight = sizes.length > 1 ? sizes[1] : undefined;
        }
        else {
            result.fontFamily = part;
            if (parts.length) {
                result.fontFamily += " " + parts.join(" ");
            }
            break;
        }
    }

    return result;
}