TypeScript is.is_String函數代碼示例

export function selector_match (node, selector, type?) {
    if (node == null) 
        return false;
    
    if (is_String(selector)) {
        if (type == null) 
            type = Dom[node.compoName ? 'CONTROLLER' : 'SET'];
        
        selector = selector_parse(selector, type);
    }

    var obj = selector.prop ? node[selector.prop] : node;
    if (obj == null) 
        return false;
    
    if (is_Function(selector.selector)) 
        return selector.selector(obj[selector.key]);
    
    // regexp
    if (typeof selector.selector !== 'string' && selector.selector.test != null) 
        return selector.selector.test(obj[selector.key]);
    
    // string | int
    /* jshint eqeqeq: false */
    return obj[selector.key] == selector.selector;
    /* jshint eqeqeq: true */
}

export function mask_config (a?, b?, c?) {
	var args = arguments,
		length = args.length
	if (length === 0) {
		return __cfg;
	}
	if (length === 1) {
		let x = args[0]
		if (is_Object(x)) {
			obj_extend(__cfg, x);
			listeners_emit('config', x);
			return;
		}
		if (is_String(x)) {
			return obj_getProperty(__cfg, x);
		}
	}
	if (length === 2) {
		var prop = args[0];
		if (obj_hasProperty(__cfg, prop) === false) {
			log_warn('Unknown configuration property', prop);
		}
		let x = {};
		obj_setProperty(x    , prop, args[1]);
		obj_setProperty(__cfg, prop, args[1]);
		listeners_emit('config', x);
		return;
	}
}

function validate(fns, val, ctr) {
    if (fns == null) {
        return null;
    }
    var imax = fns.length,
        i = -1,
        error, fn;
    while ( ++i < imax ){
        fn = fns[i];
        if (fn == null) {
            continue;
        }
        error = fn(val, ctr);
        if (error != null) {
            if (is_String(error)) {
                return {
                    message: error,
                    actual: val
                };
            }
            if (error.actual == null) {
                error.actual = val;
            }
            return error;
        }
    }
}

function getTemplateProp_(compo) {
    var template = compo.template;
    if (template == null) {
        var attr = compo.attr;
        if (attr == null) return null;

        template = attr.template;
        if (template == null) return null;

        delete compo.attr.template;
    }
    if (typeof template === 'object') return template;

    if (is_String(template)) {
        if (template.charCodeAt(0) === 35 && /^#[\w\d_-]+$/.test(template)) {
            // #
            var node = document.getElementById(template.substring(1));
            if (node == null) {
                log_warn('Template not found by id:', template);
                return null;
            }
            template = node.innerHTML;
        }
        return parser_parse(template);
    }
    log_warn('Invalid template', typeof template);
    return null;
}

 return function(val, ctr){
     var mix = fn(val, ctr);
     if (mix == null || mix === true) {
         return null;
     }
     if (mix === false) {
         return message || ('Check failed: `' + name + '`');
     }
     if (is_String(mix) && mix.length !== 0) {
         return mix;
     }
     return null;
 };

export function m_cfg(mix, val){
    if (arguments.length === 1) {
        if (is_String(mix)) {
            return obj_getProperty(_opts, mix);
        }
        if (is_Object(mix)) {
            for (var key in mix) {
                u_setOption(_opts, key, mix[key]);
            }
        }
        return this;
    }
    u_setOption(_opts, mix, val);
    return this;
};

export function reporter_getNodeStack(node) {
    var stack = [node];

    var parent = node.parent;
    while (parent != null) {
        stack.unshift(parent);
        parent = parent.parent;
    }
    var str = '';
    var root = stack[0];
    if (root !== node && is_String(root.source) && node.sourceIndex > -1) {
        str += error_formatSource(root.source, node.sourceIndex, root.filename) + '\n';
    }
    str += '  at ' + stack.map(function(x) { return x.tagName || x.compoName;}).join(' > ');
    return str;
}

export function css_ensureScopedStyles  (str: string, node, el) {
		var attr = node.attr;
		if (attr.scoped == null && attr[KEY] == null) {
			return str;
		}
		if (is_String(str) === false) {
			error_withNode('Scoped style can`t have interpolations', node);
			return str;
		}
		// Remove `scoped` attribute to exclude supported browsers.
		// Redefine custom attribute to use same template later
		attr.scoped = null;
		attr[KEY] = 1;
		var id = getScopeIdentity(node, el);
		var str_ = str;
		str_ = transformScopedStyles(str_, id);
		str_ = transformHostCss(str_, id);
		return str_;
	};

    processNode: function(node) {
        var stream = this.stream;
        if (is_Function(node.stringify)) {
            var str = node.stringify(stream);
            if (str != null) {
                stream.print('<mask>');
                stream.write(str);
                stream.print('</mask>');
            }
            return;
        }
        if (is_String(node.content)) {
            stream.print(node.content);
            return;
        }
        if (is_Function(node.content)){
            stream.print(node.content());
            return;
        }
        if (node.type === Dom.FRAGMENT) {
            this.process(node);
            return;
        }

        stream.print('<' + node.tagName);
        this.processAttr(node);

        if (isEmpty(node)) {
            if (html_isVoid(node)) {
                stream.print('>');
                return;
            }
            if (html_isSemiVoid(node)) {
                stream.print('/>');
                return;
            }
            stream.print('></' + node.tagName + '>');
            return;
        }
        stream.print('>');
        this.process(node.nodes);
        stream.print('</' + node.tagName + '>');
    },