TypeScript reporters.log_warn函数代码示例

    emit(signal, a?, b?, c?){
        var controllers = _collection[this.name],
            name = this.name,
            args = _Array_slice.call(arguments, 1);
        
        if (controllers == null) {
            //if DEBUG
            log_warn('Pipe.emit: No signals were bound to:', name);
            //endif
            return;
        }
        
        var i = controllers.length,
            called = false;

        while (--i !== -1) {
            var ctr = controllers[i];
            var slots = ctr.pipes[name];

            if (slots == null) 
                continue;
            
            var slot = slots[signal];
            if (slot != null) {
                slot.apply(ctr, args);
                called = true;
            }
        }

        // if DEBUG
        if (called === false)
            log_warn('Pipe `%s` has not slots for `%s`', name, signal);
        // endif
    }

			domLib.fn[method] = function(template, model, ctr, ctx){
				if (this.length === 0) {
					//#if (DEBUG)
					log_warn('<jcompo> $.', method, '- no element was selected(found)');
					//#endif
					return this;
				}
				if (this.length > 1) {
					//#if (DEBUG)
					log_warn('<jcompo> $.', method, ' can insert only to one element. Fix is comming ...');
					//#endif
				}
				if (ctr == null) {
					ctr = index < 2
						? this.compo()
						: this.parent().compo()
						;
				}
				
				var isUnsafe = false;
				if (ctr == null) {
					ctr = {};
					isUnsafe = true;
				}
				
				
				if (ctr.components == null) {
					ctr.components = [];
				}
				
				var compos = ctr.components,
					i = compos.length,
					fragment = renderer_render(template, model, ctx, null, ctr);
				
				var self = this[jQ_Methods[index]](fragment),
					imax = compos.length;
				
				for (; i < imax; i++) {
					CompoSignals.signal.emitIn(compos[i], 'domInsert');
				}
				
				if (isUnsafe && imax !== 0) {
					// if DEBUG
					log_warn(
						'$.'
						, method
						, '- parent controller was not found in Elements DOM.'
						, 'This can lead to memory leaks.'
					);
					log_warn(
						'Specify the controller directly, via $.'
						, method
						, '(template[, model, controller, ctx])'
					);
					// endif
				}
				
				return self;
			};

function _merge(node, placeholders, tmplNode, clonedParent?) {
    if (node == null)
        return null;

    var fn;
    if (is_Array(node)) {
        fn = _mergeArray;
    } else {
        switch (node.type) {
            case dom_TEXTNODE:
                fn = _cloneTextNode;
                break;
            case dom_DECORATOR:
                fn = _cloneDecorator;
                break;
            case dom_NODE:
            case dom_STATEMENT:
                fn = _mergeNode;
                break;
            case dom_FRAGMENT:
                fn = _mergeFragment;
                break;
            case dom_COMPONENT:
                fn = _mergeComponent;
                break;
        }
    }
    if (fn !== void 0) {
        return fn(node, placeholders, tmplNode, clonedParent);
    }
    log_warn('Unknown type', node.type);
    return null;
}

function interpolate_(path, placeholders, node) {
    var index = path.indexOf('.');
    if (index === -1) {
        log_warn('Merge templates. Accessing node', path);
        return null;
    }
    var tagName = path.substring(0, index),
        id = tagName.substring(1),
        property = path.substring(index + 1),
        obj = null;

    if (node != null) {
        if (tagName === '@attr') {
            return interpolate_getAttr_(node, placeholders, property);
        }
        else if (tagName === '@counter') {
            return interpolate_getCounter_(property);
        }
        else if (tagName === node.tagName)
            obj = node;
    }

    if (obj == null)
        obj = placeholders.$getNode(id);

    if (obj == null) {
        //- log_error('Merge templates. Node not found', tagName);
        return null;
    }
    return obj_getProperty(obj, property);
}

 register: function(id, nodes){
     if (id == null) {
         log_warn('`:template` must define the `id` attr');
         return;
     }
     cache_[id] = nodes;
 }

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;
	}
}

		resolveCompo: function(el, silent?){
			if (el == null)
				return null;
			
			var ownerId, id, compo;
			do {
				id = el.getAttribute('x-compo-id');
				if (id != null) {
					if (ownerId == null) {
						ownerId = id;
					}
					compo = _cache[id];
					if (compo != null) {
						compo = compo_find(compo, {
							key: 'ID',
							selector: ownerId,
							nextKey: 'components'
						});
						if (compo != null) 
							return compo;
					}
				}
				el = el.parentNode;
			}while(el != null && el.nodeType === 1);

			// if DEBUG
			ownerId && silent !== true && log_warn('No controller for ID', ownerId);
			// endif
			return null;
		},

function _handleDefinition (el, ctr, definition, asEvent, isSlot) {
    var match = rgx.exec(definition);
    if (match == null) {
        log_error('Signal definition is not resolved', definition, 'The pattern is: (source((sourceArg))?:)?signal((expression))?');
        return null;
    }
    var source = match[2], 
        sourceArg = match[4], 
        signal = match[5], 
        signalExpr = match[7];
    
    if (asEvent != null) {
        sourceArg = source;
        source = asEvent;
    }
    var fn = _createListener(ctr, signal, signalExpr);

    if (!source) {
        log_error('Signal: Eventname is not set', definition);
        return null;
    }
    if (!fn) {
        log_warn('Slot not found:', signal);
        return null;
    }
    if (isSlot) {
        compo_attach(ctr, 'slots.' + source, fn);
        return;
    }

    dom_addEventListener(el, source, fn, sourceArg, ctr);
    return signal;
}

 '$': function(compo, selector) {
     var r = domLib_find(compo.$, selector)
     //#if (DEBUG)
     if (r.length === 0)
         log_warn('<compo-selector> - element not found -', selector, compo);
     //#endif
     return r;
 },