return __cfg.getScript || file_getScript;
});
export const _file_getStyle = createTransport(function(){
    return __cfg.getStyle || file_getStyle;
});
export const _file_getJson = createTransport(function(){
    return __cfg.getJson || (__cfg as any).getData || file_getJson;
});


listeners_on('config', function (config) {
    var modules = config.modules;
    if (modules == null) {
        return;
    }
    var fn = Loaders[modules];
    if (is_Function(fn) === false) {
        log_warn('Module system is not supported: ' + modules);
        return;
    }
    fn();
});

function createTransport(loaderFactoryFn) {
    return function(path_){
        var fn = loaderFactoryFn(),
            path = path_,
            v = _opts.version;
        if (v != null) {
            path = path_appendQuery(path, 'v', v);
        }
        return fn(path);

        Module.cfg('moduleResolution', 'classic');
        listeners_off('error');
	},

	async 'should load default file in node_modules' () {
		let dom = await renderer_renderAsync(`
            import Foo from '/test/tmpl/npm/foo.mask';

            Foo;
        `);
        
        return UTest.domtest(dom, `
            find ('h4') > text ('EmptyPackage');
        `);
	},
	async 'should fail loading' () {
        var errors = [];
        
		listeners_on('error', assert.await((error) => errors.push(error)));
		await renderer_renderAsync(`
            import Any from '/test/tmpl/npm/foo-none.mask';
            Any;
        `);
           
        notEq_(errors.length, 0);
        var error = errors[0];
        has_(error.message, 'Module was not resolved');
	}
});

			eq_(result, 'foo');
		},
		async 'should run getter on ASYNC statement' () {

			var someFn = assert.await(async function(){
				return { foo: 'Foo'};
			})

			var ast = expression_parse('(await someFn()).foo');
			var result =  await expression_eval(ast, { someFn });
			eq_(result, 'Foo');
		},		
	},
	'function calls': {
		'should log error for undefined function call' () {
			listeners_on('error', assert.await(error => has_(error.message, 'is not a function')));
			var result =  expression_eval('someFn()');
			eq_(result, null);
			listeners_off('error')
		},
		async 'should evaluate async in fn arguments' () {

			var model = { 
				async someFn () {
					return { foo: 'FoO'}
				},
				toLowerCase (str) {
					return str.toLowerCase()
				}
			};
			var result =  await expression_eval('toLowerCase((await someFn()).foo)', model);

				'foo .bar . gaz',
				'foo?.bar?.gaz',
				'foo ?.bar ?. gaz'				
			]
			.forEach(x => {
				var result = run(x, { foo: { bar: { gaz: 'abc' }} });
				eq_(result, 'abc');
			})
		}
	},
	'elvis opearotr': {
		$teardown () {            
			listeners_off('warn');
		},
		'should silently return null' () {
			listeners_on('warn', assert.avoid());
			var x = run('foo?.bar.gaz', { });
			eq_(x, null);
		},
		'should drop warning' () {
			listeners_on('warn', assert.await(msg => {
                has_(msg.message, 'foo.bar.gaz');
			}));
			var x = run('foo.bar.gaz', { });
			eq_(x, null);
		}
	},
	'Or Statements': {
		'Should return last empty string, though it is falsy' () {
			eq_(run('null || ""'), '');		
		},

import { listeners_off, listeners_on } from '@core/util/listeners';
import { parser_parse, mask_stringify } from '@core/parser/exports';
import { Dom } from '@core/dom/exports';

UTest({
    'should parse properties' () {
        listeners_off('warn');
        listeners_on('warn', assert.avoid());
        listeners_off('error');
        listeners_on('error', assert.avoid());

        [
            `div [ style.baz ] = green;`,
            `div [style.baz ] = green`,
            `div [style.baz]='green'`,
            `div [      style.baz
            ]
                =
            'green'`
        ]
        .forEach(str => {
            var node = parser_parse(str);        
            eq_(node.tagName, 'div');        
            deepEq_(node.props, { 'style.baz': 'green' });
            eq_(node.type, Dom.NODE);

            var back = mask_stringify(node);
            eq_(back, `div [style.baz] = green;`);
        })        
    },
    'should parse properties and other attributes': {

				find('h4') > text FooFromTmpl;	
			`);
		},
		'let' () {
			'> create owner component'
			var Foo = Compo({});
			customTag_define('Foo', Foo);
			
			'> register from template in the owners scope'
			customTag_registerFromTemplate(`
				let LetBaz {
					h4 > 'LetBaz'
				}
			`, Foo);
			
			listeners_on('error', assert.await(error => has_(error.message, 'LetBaz')));
			var dom = renderer_render(`
				Foo {
					LetBaz;
				}
				LetBaz;
			`);
			listeners_off('error');
			return UTest.domtest(dom, `
				find('h4') {
					length 1;
					text LetBaz;
				}
			`);
		}
	},

		},

		'should notify unacceptable node' () {
			var template = `
				define Bar {
					var test = true;
					[UpperCase]
					if (this.test) {
						h1 > 'OK'
                    }                    
				}
				Bar;
			`;

			Decorator.define ('UpperCase', {
				afterRender (el) { }
			});

			
			listeners_on('error', assert.await(error => {
				var msg = error.message;
				has_(msg, 'UpperCase');
                has_(msg, 'support');
			}))
			var dom = renderer_render(template);
			return UTest.domtest(dom, `
				find (h1) > text ('OK');
			`)
		}
	}
})

var errors = [];
var warns  = [];
function getLinesOfLast(arr) {
	var error = (errors.pop() || warns.pop());
	return error.message.split('\n')
}
function getLast(arr?) {
	var error = arr && arr.pop() || (errors.pop() || warns.pop());
	return error.message;
}

UTest({

	$before () {
		listeners_on('error', error => errors.push(error));
		listeners_on('warn', warn => warns.push(warn));
	},
	$after () {
		listeners_off('error');
		listeners_off('warn');
	},
	$teardown () {
		errors = [];
		warns  = [];
	},
	'unexpect tag closing': {
		'starting' () {
			parser_parse('} what');
			var lines = getLinesOfLast(warns);
			has_(lines, [

				find('h1') > text MyHeader;
			`);
		}
	},
	'scoped (let)': {
		'should create nested scoped component' () {
			var tmpl = `
				define FooGlobal {
					let BarLocal {
						span > 'Bar'
					}
				}
				FooGlobal {
					BarLocal;
				}
				
				BarLocal;
            `;
            
			listeners_on('error', assert.await(err => has_(String(err), 'BarLocal')));
			$(renderer_render(tmpl))
				.eq_('length', 1)
				.eq_('prop', 'tagName', 'SPAN')
				.eq_('text', 'Bar')
				;
            listeners_off('error');
		}
	}
})

// vim: set ft=js: