NativeScript/ui/styling/style-property.ts

import definition = require("ui/styling/style-property");
import types = require("utils/types");
import observable = require("ui/core/dependency-observable"); 

var propertiesByName = {};
var propertiesByCssName = {};
var callbackByShorthandName = new Map<string, (value: any) => Array<definition.KeyValuePair<definition.Property, any>>>();
var inheritableProperties: Array<Property> = [];

function registerProperty(property: Property) {
    if (propertiesByCssName[property.cssName]) {
        throw new Error("Property with name " + property.cssName + " is already registered!");
    }

    propertiesByCssName[property.cssName] = property;
    propertiesByName[property.name] = property;

    if (property.metadata.inheritable) {
        inheritableProperties.push(property);
    }
}

export function getShorthandPairs(name: string, value: any): Array<definition.KeyValuePair<definition.Property, any>> {
    var callback = callbackByShorthandName.get(name);
    if (callback) {
        return callback(value)
    }

    return undefined;
}

export function registerShorthandCallback(name: string, callback: (value: any) => Array<definition.KeyValuePair<definition.Property, any>>): void {
    if (callbackByShorthandName.has(name)) {
        throw new Error("Shorthand callback already registered for property: " + name);
    }

    callbackByShorthandName.set(name, callback);
}

export function getPropertyByName(name: string): Property {
    return propertiesByName[name];
}

export function getPropertyByCssName(name: string): Property {
    return propertiesByCssName[name];
}

export function eachProperty(callback: (property: Property) => void) {
    types.verifyCallback(callback);

    var i;
    var key;
    var keys = Object.keys(propertiesByName);

    for (i = 0; i < keys.length; i++) {
        key = keys[i];
        callback(propertiesByName[key]);
    }
}

export function eachInheritableProperty(callback: (property: Property) => void) {
    types.verifyCallback(callback);

    var i;
    for (i = 0; i < inheritableProperties.length; i++) {
        callback(inheritableProperties[i]);
    }
}

export class Property extends observable.Property implements definition.Property {
    private _cssName;

    constructor(name: string, cssName: string, metadata: observable.PropertyMetadata, valueConverter?: (value: any) => any) {
        super(name, "Style", metadata, valueConverter);

        this._cssName = cssName;

        registerProperty(this);
    }

    public get cssName(): string {
        return this._cssName;
    }

    public _getEffectiveValue(entry: observable.PropertyEntry): any {
        if (types.isDefined(entry.visualStateValue)) {
            entry.valueSource = observable.ValueSource.VisualState;
            return entry.visualStateValue;
        }

        if (types.isDefined(entry.localValue)) {
            entry.valueSource = observable.ValueSource.Local;
            return entry.localValue;
        }

        if (types.isDefined(entry.cssValue)) {
            entry.valueSource = observable.ValueSource.Css;
            return entry.cssValue;
        }

        if (types.isDefined(entry.inheritedValue)) {
            entry.valueSource = observable.ValueSource.Inherited;
            return entry.inheritedValue;
        }

        entry.valueSource = observable.ValueSource.Default;
        return this.metadata.defaultValue;
    }
}