0.2.7 Templates

OSWS Templates 0.2.7

Templates

import Templates = require('osws-templates');

._jsContentRequire

(content: string, filename: string) => exports;

Only Node.js!

console.log(Templates._jsContentRequire('module.exports = __filename;', 'test.js')) // __dirname + 'test.js'

.includeString

(content: string, filename: string) => Module;

Only Node.js!

var m = Templates.includeString('module.exports = "<%= name %>";', 'test.js');
m.render({ name: 'test' }, function(result) {
	console.log(result); // 'test'
});

.include

(filename: string, callback: TCallback) => TAsync;

Only Node.js!

module.exports = __filename;

var mAsync = Templates.include('test.js', function(m) {
	m.render({ name: 'test' }, function(result) {
		console.log(result); // 'test'
	});
});
mAsync(function(result) {
	console.log(result); // 'test'
});

.includeSync

(filename: string) => Module;

Only Node.js!

module.exports = __filename;

Templates.includeSync('test.js').render({ name: 'test' }, function(result) {
	console.log(result); // 'test'
});

.isSync

(argument: any) => boolean;

Templates.isSync(asSync(function() {})); // true;
Templates.isSync(asAsync(function(callback) {})); // false;
Templates.isSync(function(callback, other) {}); // false;
Templates.isSync(function(any, args) {}); // false;

.isAsync

(argument: any) => boolean;

Templates.isAsync(asSync(function() {})); // false;
Templates.isAsync(asAsync(function(callback) {})); // true;
Templates.isAsync(function(callback, other) {}); // false;
Templates.isAsync(function(any, args) {}); // false;

.asSync

(argument: Function) => Function;

Add to argument function, option: .__templatesSync = true;.

.asAsync

(argument: Function) => Function;

Add to argument function, option: .__templatesAsync = true;.

.dataRender

(data: TData, callback: TCallback) => void;

The method of synchronous/asynchronous conversion TData in string values. Is used when rendering.

.wrapMethod

(instance: Prototype, method: Function) => Function;

Adds a method options __templatesInstance as reference to an instance of the Prototype.

.regExpSearch

(data: string, reg: RegExp) => string[][];

._selectorRegExp

RegExp

TSelector RegExp

.parseSelector

(_attributes: IAttributes, selector: TSelector) => void;

Parse selector to IAttributes format.

All sended attributes overlap, not added. Exception - classes as .class-name-1.class-name-2, are added, do not overlap.

._stringTemplate

(string: string, context: Object, callback: TCallback) => void;

By default - wrap around method _.template.

var context = {
	type: 'name',
	data: asAsync(function(callback) { callback('Example'); }),
	person: {
		age: function() { return 100; },
		whose: asSync(function() { return 'my'; })
	}
};
Templates._stringTemplate('<%= person.whose %> <%= type %>: <%= name %>, age: <%= person.age() %>', context, console.log);
// my name: Example

You can override this method of their own

Templates._stringTemplate = function(string, context, callback) {
	callback(string);
}

.mixin

(reconstructor: (...arguments: IArguments) => any) => Templates.Mixin

Mixin have to return something, otherwise it will be considered empty.

var mixin = Templates.mixin;

var mix = mixin(function(a, b, c) {
	return div({ a: a })(b, div()(c));
});

mix instanceof Templates.Mixin // true

mix(1,2,3).render(console.log);