NativeScript/tns-core-modules/ui/styling/font-common.ts

import { Font as FontDefinition, ParsedFont } from "ui/styling/font";
import { makeValidator, makeParser} from "ui/core/properties";

export abstract class FontBase implements FontDefinition {
    public static default = undefined;

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

    get fontFamily(): string {
        return this._fontFamily;
    }

    get fontStyle(): FontStyle {
        return this._fontStyle;
    }

    get fontWeight(): FontWeight {
        return this._fontWeight;
    }

    get fontSize(): number {
        return this._fontSize;
    }

    get isItalic(): boolean {
        return this._fontStyle === FontStyle.ITALIC;
    }

    get isBold(): boolean {
        return this._fontWeight === FontWeight.BOLD
            || this._fontWeight === "700";
    }

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

    public abstract getAndroidTypeface(): android.graphics.Typeface;
    public abstract getUIFont(defaultFont: UIFont): UIFont;
    public abstract withFontFamily(family: string): FontBase;
    public abstract withFontStyle(style: string): FontBase;
    public abstract withFontWeight(weight: string):FontBase;
    public abstract withFontSize(size: number): FontBase;

    public static equals(value1: FontBase, value2: FontBase): 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;
    }
}

export type FontStyle = "normal" | "italic";
export namespace FontStyle {
    export const NORMAL: "normal" = "normal";
    export const ITALIC: "italic" = "italic";
    export const isValid = makeValidator<FontStyle>(NORMAL, ITALIC);
    export const parse = makeParser(isValid, NORMAL);
}

export type FontWeight = "100" | "200" | "300" | "normal" | "400" | "500" | "600" | "bold" | "700" | "800" | "900";
export namespace FontWeight {
    export const THIN: "100" = "100";
    export const EXTRA_LIGHT: "200" = "200";
    export const LIGHT: "300" = "300";
    export const NORMAL: "normal" = "normal"; 
    export const MEDIUM: "500" = "500";
    export const SEMI_BOLD: "600" = "600";
    export const BOLD: "bold" = "bold"; 
    export const EXTRA_BOLD: "800" = "800";
    export const BLACK: "900" = "900";
    export const isValid = makeValidator<FontWeight>(THIN, EXTRA_LIGHT, LIGHT, NORMAL, "400", MEDIUM, SEMI_BOLD, BOLD, "700", EXTRA_BOLD, BLACK);
    export const parse = makeParser(isValid, NORMAL);
}

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

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

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

const styles = new Set();
[
    FontStyle.NORMAL, 
    FontStyle.ITALIC
].forEach((val, i, a) => styles.add(val));

// http://www.w3schools.com/cssref/pr_font_weight.asp
//- normal(same as 400)
//- bold(same as 700)
//- 100(Thin) (API16 -thin)
//- 200(Extra Light / Ultra Light) (API16 -light)
//- 300(Light) (API16 -light)
//- 400(Normal) 
//- 500(Medium) (API21 -medium)
//- 600(Semi Bold / Demi Bold) (API21 -medium)
//- 700(Bold) (API16 -bold)
//- 800(Extra Bold / Ultra Bold) (API16 -bold)
//- 900(Black / Heavy) (API21 -black)
const weights = new Set();
[
    FontWeight.THIN, 
    FontWeight.EXTRA_LIGHT, 
    FontWeight.LIGHT, 
    FontWeight.NORMAL, 
    "400", 
    FontWeight.MEDIUM, 
    FontWeight.SEMI_BOLD, 
    FontWeight.BOLD, 
    "700", 
    FontWeight.EXTRA_BOLD, 
    FontWeight.BLACK
].forEach((val, i, a) => weights.add(val));

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

    const parts = fontValue.split(/\s+/);
    let 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 = <any>part;
        }
        else if (weights.has(part)) {
            result.fontWeight = <any>part;
        }
        else if (!result.fontSize) {
            let 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;
}