704 lines
23 KiB
JavaScript
704 lines
23 KiB
JavaScript
/**
|
|
* The outline of a ignite property which is a managed property that
|
|
* can be used to invoke call back functions when the value of the property changes.
|
|
* @ignore
|
|
*/
|
|
class IgniteProperty {
|
|
/**
|
|
*
|
|
* @param {Any} val Starting value of this property.
|
|
* @param {{ onChange, onPush, onPop, onShift, onUnshift, onSplice }} options
|
|
*/
|
|
constructor(val, options = null) {
|
|
this.onChangeCallbacks = [];
|
|
this.onPushCallbacks = [];
|
|
this.onPopCallbacks = [];
|
|
this.onShiftCallbacks = [];
|
|
this.onUnshiftCallbacks = [];
|
|
this.onSpliceCallbacks = [];
|
|
this.arrayCallbacks = [];
|
|
this.reflected = [];
|
|
this._value = val;
|
|
this.ignoreValueChange = false;
|
|
this.name = null;
|
|
|
|
//If we were passed options, add any callbacks needed.
|
|
if (options) {
|
|
if (options.onChange) {
|
|
this.attachOnChange(options.onChange);
|
|
}
|
|
|
|
if (options.onPush) {
|
|
this.attachOnPush(options.onPush);
|
|
}
|
|
|
|
if (options.onPop) {
|
|
this.attachOnPop(options.onPop);
|
|
}
|
|
|
|
if (options.onShift) {
|
|
this.attachOnShift(options.onShift);
|
|
}
|
|
|
|
if (options.onUnshift) {
|
|
this.attachOnUnshift(options.onUnshift);
|
|
}
|
|
|
|
if (options.onSplice) {
|
|
this.attachOnSplice(options.onSplice);
|
|
}
|
|
}
|
|
|
|
//Attempt to patch the value if it's a list.
|
|
this.patchArray();
|
|
}
|
|
|
|
/**
|
|
* Creates a new ignite property on the target object that responds to rendering states.
|
|
* @param {Any} target
|
|
* @param {String} name
|
|
* @param {Any} value
|
|
* @returns {Any} The target passed to the function.
|
|
*/
|
|
static create(target, name, value) {
|
|
var property = new IgniteProperty(value);
|
|
|
|
Object.defineProperty(target, name, {
|
|
get: () => { return (IgniteRendering.rendering ? property : property.value); },
|
|
|
|
set: (value) => { property.value = value; }
|
|
});
|
|
|
|
return target;
|
|
}
|
|
|
|
/**
|
|
* Gets the value of this IgniteProperty.
|
|
* @returns {Any} The value of this IgniteProperty.
|
|
*/
|
|
get value() {
|
|
return this._value;
|
|
}
|
|
|
|
/**
|
|
* Sets the value of this IgniteProperty, this will reflect the value to any listeners on this property.
|
|
* @param {Any} val The value to set.
|
|
*/
|
|
set value(val) {
|
|
this.setValue(val, true);
|
|
}
|
|
|
|
/**
|
|
* Sets the value of this IngiteProperty with control of reflection.
|
|
* @param {Any} val The value to set for this IgniteProperty.
|
|
* @param {Boolean} reflect If true, this will reflect the value onto any listeners on this property.
|
|
*/
|
|
setValue(val, reflect) {
|
|
//If the ignore value change flag is set exit.
|
|
if (this.ignoreValueChange) {
|
|
return;
|
|
}
|
|
|
|
//If the current value is the same as the old value don't do anything.
|
|
if (this._value === val) {
|
|
return;
|
|
}
|
|
|
|
//Get the old value
|
|
var old = this._value;
|
|
|
|
//Set the new value
|
|
this._value = val;
|
|
|
|
//Attempt to patch the value if it's an array.
|
|
this.patchArray();
|
|
|
|
//Invoke any callbacks letting them know the value changed.
|
|
this.invokeOnChange(old, val, reflect);
|
|
}
|
|
|
|
patchArray() {
|
|
//Disconnect any existing array callbacks
|
|
if (this.arrayCallbacks.length > 0) {
|
|
this.arrayCallbacks.forEach(callback => callback.disconnect());
|
|
this.arrayCallbacks = [];
|
|
}
|
|
|
|
//If our value is an array and it hasn't been patched, then patch it.
|
|
if (Array.isArray(this._value) && this._value.onPushCallbacks == undefined) {
|
|
this._value.onPushCallbacks = [];
|
|
this._value.onPopCallbacks = [];
|
|
this._value.onShiftCallbacks = [];
|
|
this._value.onUnshiftCallbacks = [];
|
|
this._value.onSpliceCallbacks = [];
|
|
|
|
this._value.push = function () {
|
|
var len = Array.prototype.push.apply(this, arguments);
|
|
this.onPushCallbacks.forEach(callback => callback.invoke(Array.from(arguments)));
|
|
return len;
|
|
};
|
|
|
|
this._value.pop = function () {
|
|
var len = Array.prototype.pop.apply(this, arguments);
|
|
this.onPopCallbacks.forEach(callback => callback.invoke());
|
|
return len;
|
|
}
|
|
|
|
this._value.unshift = function () {
|
|
var len = Array.prototype.unshift.apply(this, arguments);
|
|
this.onUnshiftCallbacks.forEach(callback => callback.invoke(Array.from(arguments)));
|
|
return len;
|
|
}
|
|
|
|
this._value.shift = function () {
|
|
var len = Array.prototype.shift.apply(this, arguments);
|
|
this.onShiftCallbacks.forEach(callback => callback.invoke());
|
|
return len;
|
|
};
|
|
|
|
this._value.splice = function (start, deleteCount = 0, ...items) {
|
|
var removed = Array.prototype.splice.apply(this, arguments);
|
|
this.onSpliceCallbacks.forEach(callback => callback.invoke(start, deleteCount, items));
|
|
return removed;
|
|
}
|
|
|
|
this._value.attachOnPush = function (func) {
|
|
var callback = new IgniteCallback(func, detach => this.detachOnPush(detach));
|
|
this.onPushCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
this._value.attachOnPop = function (func) {
|
|
var callback = new IgniteCallback(func, detach => this.detachOnPop(detach));
|
|
this.onPopCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
this._value.attachOnUnshift = function (func) {
|
|
var callback = new IgniteCallback(func, detach => this.detachOnUnshift(detach));
|
|
this.onUnshiftCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
this._value.attachOnShift = function (func) {
|
|
var callback = new IgniteCallback(func, detach => this.detachOnShift(detach));
|
|
this.onShiftCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
this._value.attachOnSplice = function (func) {
|
|
var callback = new IgniteCallback(func, detach => this.detachOnSplice(detach));
|
|
this.onSpliceCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
this._value.detachOnPush = function (callback) {
|
|
this.onPushCallbacks = this.onPushCallbacks.filter(push => push != callback);
|
|
}
|
|
|
|
this._value.detachOnPop = function (callback) {
|
|
this.onPopCallbacks = this.onPopCallbacks.filter(pop => pop != callback);
|
|
}
|
|
|
|
this._value.detachOnUnshift = function (callback) {
|
|
this.onUnshiftCallbacks = this.onUnshiftCallbacks.filter(unshift => unshift != callback);
|
|
}
|
|
|
|
this._value.detachOnShift = function (callback) {
|
|
this.onShiftCallbacks = this.onShiftCallbacks.filter(shift => shift != callback);
|
|
}
|
|
|
|
this._value.detachOnSplice = function (callback) {
|
|
this.onSpliceCallbacks = this.onSpliceCallbacks.filter(slice => slice != callback);
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(this._value) && this._value.onPushCallbacks) {
|
|
//This array has already been patched but attach to it so we get callbacks.
|
|
this.arrayCallbacks.push(this._value.attachOnPush((items) => this.invokeOnPush(items)));
|
|
this.arrayCallbacks.push(this._value.attachOnPop(() => this.invokeOnPop()));
|
|
this.arrayCallbacks.push(this._value.attachOnShift(() => this.invokeOnShift()));
|
|
this.arrayCallbacks.push(this._value.attachOnUnshift((items) => this.invokeOnUnshift(items)));
|
|
this.arrayCallbacks.push(this._value.attachOnSplice((start, deleteCount, items) => this.invokeOnSplice(start, deleteCount, items)));
|
|
}
|
|
}
|
|
|
|
reflect() {
|
|
this.ignoreValueChange = true; //Ignore changes incase we are connected to any reflected properties.
|
|
this.reflected.forEach(reflect => reflect instanceof Function ? reflect(this._value) : (reflect.value = this._value));
|
|
this.ignoreValueChange = false;
|
|
}
|
|
|
|
invokeOnChange(oldValue, newValue, reflect = true) {
|
|
//Enter a new rendering context since this event may contain code that expects a new context.
|
|
IgniteRendering.push();
|
|
if (reflect) {
|
|
this.reflect();
|
|
}
|
|
this.onChangeCallbacks.forEach(callback => callback.invoke(oldValue, newValue));
|
|
IgniteRendering.pop();
|
|
}
|
|
|
|
invokeOnPush(items, reflect = true) {
|
|
IgniteRendering.push();
|
|
if (reflect) {
|
|
this.reflect();
|
|
}
|
|
this.onPushCallbacks.forEach(callback => callback.invoke(this._value, items));
|
|
IgniteRendering.pop();
|
|
}
|
|
|
|
invokeOnPop(reflect = true) {
|
|
IgniteRendering.push();
|
|
if (reflect) {
|
|
this.reflect();
|
|
}
|
|
this.onPopCallbacks.forEach(callback => callback.invoke(this._value));
|
|
IgniteRendering.pop();
|
|
}
|
|
|
|
invokeOnShift(reflect = true) {
|
|
IgniteRendering.push();
|
|
if (reflect) {
|
|
this.reflect();
|
|
}
|
|
this.onShiftCallbacks.forEach(callback => callback.invoke(this._value));
|
|
IgniteRendering.pop();
|
|
}
|
|
|
|
invokeOnUnshift(items, reflect = true) {
|
|
IgniteRendering.push();
|
|
if (reflect) {
|
|
this.reflect();
|
|
}
|
|
this.onUnshiftCallbacks.forEach(callback => callback.invoke(this._value, items));
|
|
IgniteRendering.pop();
|
|
}
|
|
|
|
invokeOnSplice(start, deleteCount, items, reflect = true) {
|
|
IgniteRendering.push();
|
|
if (reflect) {
|
|
this.reflect();
|
|
}
|
|
this.onSpliceCallbacks.forEach(callback => callback.invoke(this._value, start, deleteCount, items));
|
|
IgniteRendering.pop();
|
|
}
|
|
|
|
/**
|
|
* Attaches a callback function to be invoked when this property value changes.
|
|
* @param {Function(oldvalue, newValue)} onChange Callback function to be invoked.
|
|
* @returns {IgniteCallback} A new ignite callback.
|
|
*/
|
|
attachOnChange(onChange) {
|
|
var callback = new IgniteCallback(onChange, detach => this.detachOnChange(detach));
|
|
this.onChangeCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
/**
|
|
* Attaches a callback function to be invoked when a set of items are pushed to this properties value.
|
|
* @param {Function(array, items)} onPush Callback function to be invoked.
|
|
* @returns {IgniteCallback} A new ignite callback.
|
|
*/
|
|
attachOnPush(onPush) {
|
|
var callback = new IgniteCallback(onPush, detach => this.detachOnPush(detach));
|
|
this.onPushCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
/**
|
|
* Attaches a callback function to be invoked when an item is popped from this properties value.
|
|
* @param {Function} onPop Callback function to be invoked.
|
|
* @returns {IgniteCallback} A new ignite callback.
|
|
*/
|
|
attachOnPop(onPop) {
|
|
var callback = new IgniteCallback(onPop, detach => this.detachOnPop(detach));
|
|
this.onPopCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
/**
|
|
* Attaches a callback function to be invoked when items are shifted from this properties value.
|
|
* @param {Function} onShift Callback function to be invoked.
|
|
* @returns {IgniteCallback} A new ignite callback.
|
|
*/
|
|
attachOnShift(onShift) {
|
|
var callback = new IgniteCallback(onShift, detach => this.detachOnShift(detach));
|
|
this.onShiftCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
/**
|
|
* Attaches a callback function to be invoked when items are unshifted to this properties value.
|
|
* @param {Function(array, items)} onUnshift Callback function to be invoked.
|
|
* @returns {IgniteCallback} A new ignite callback.
|
|
*/
|
|
attachOnUnshift(onUnshift) {
|
|
var callback = new IgniteCallback(onUnshift, detach => this.detachOnUnshift(detach));
|
|
this.onUnshiftCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
/**
|
|
* Attaches a callback function to be invoked when items are spliced on this properties value.
|
|
* @param {Function(array, start, deleteCount, items)} onSplice Callback function to be invoked.
|
|
* @returns {IgniteCallback} A new ignite callback.
|
|
*/
|
|
attachOnSplice(onSplice) {
|
|
var callback = new IgniteCallback(onSplice, detach => this.detachOnSplice(detach));
|
|
this.onSpliceCallbacks.push(callback);
|
|
return callback;
|
|
}
|
|
|
|
/**
|
|
* Removes an ignite callback for the OnChange event.
|
|
* @param {IgniteCallback} callback
|
|
*/
|
|
detachOnChange(callback) {
|
|
this.onChangeCallbacks = this.onChangeCallbacks.filter(change => change != callback);
|
|
}
|
|
|
|
/**
|
|
* Removes an ignite callback for the OnPush event.
|
|
* @param {Ignitec} callback
|
|
*/
|
|
detachOnPush(callback) {
|
|
this.onPushCallbacks = this.onPushCallbacks.filter(push => push != callback);
|
|
}
|
|
|
|
/**
|
|
* Removes an ignite callback for the OnPop event.
|
|
* @param {IgniteCallback} callback
|
|
*/
|
|
detachOnPop(callback) {
|
|
this.onPopCallbacks = this.onPopCallbacks.filter(pop => pop != callback);
|
|
}
|
|
|
|
/**
|
|
* Removes an ignite callback for the OnShift event.
|
|
* @param {IgniteCallback} callback
|
|
*/
|
|
detachOnShift(callback) {
|
|
this.onShiftCallbacks = this.onShiftCallbacks.filter(shift => shift != callback);
|
|
}
|
|
|
|
/**
|
|
* Removes an ignite callback for the OnUnshift event.
|
|
* @param {IgniteCallback} callback
|
|
*/
|
|
detachOnUnshift(callback) {
|
|
this.onUnshiftCallbacks = this.onUnshiftCallbacks.filter(unshift => unshift != callback);
|
|
}
|
|
|
|
/**
|
|
* Removes an ignite callback for the OnSplice event.
|
|
* @param {IgniteCallback} callback
|
|
*/
|
|
detachOnSplice(callback) {
|
|
this.onSpliceCallbacks = this.onSpliceCallbacks.filter(slice => slice != callback);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the value of the property if we try to convert
|
|
* the property to a string.
|
|
* @ignore
|
|
*/
|
|
IgniteProperty.prototype.toString = function () {
|
|
if (this.value) {
|
|
return this.value.toString();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Add a prototype to help get property values from an array
|
|
* @ignore
|
|
*/
|
|
Array.prototype.getPropertyValues = function () {
|
|
var ret = [];
|
|
this.forEach(prop => {
|
|
if (prop instanceof IgniteProperty) {
|
|
ret.push(prop.value);
|
|
} else {
|
|
ret.push(prop);
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Add a prototype to help get old property values from an array
|
|
* @ignore
|
|
*/
|
|
Array.prototype.getOldPropertyValues = function (property, oldValue) {
|
|
var ret = [];
|
|
this.forEach(prop => {
|
|
if (prop === property) {
|
|
ret.push(oldValue);
|
|
} else {
|
|
if (prop instanceof IgniteProperty) {
|
|
ret.push(prop.value);
|
|
} else {
|
|
ret.push(prop);
|
|
}
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* The outline of an IgniteObject which contains IgniteProperties.
|
|
*/
|
|
class IgniteObject {
|
|
/**
|
|
* Creates a new ignite object with an optional object to create from.
|
|
* @param {Any} obj
|
|
*/
|
|
constructor(obj = null) {
|
|
//Only do this if the object is not an ignite object already.
|
|
if (obj && !(obj instanceof IgniteObject)) {
|
|
Object.keys(obj).forEach(name => {
|
|
var prop = new IgniteProperty(obj[name]);
|
|
Object.defineProperty(this, name, {
|
|
get: () => { return (IgniteRendering.rendering ? prop : prop.value); },
|
|
set: (value) => { prop.value = value; }
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks this IgniteObject for any properties not converted and automatically
|
|
* converts them.
|
|
*/
|
|
update() {
|
|
Object.keys(this).forEach(name => {
|
|
if (!(this[name] instanceof IgniteProperty)) {
|
|
var prop = new IgniteProperty(this[name]);
|
|
delete this[name];
|
|
Object.defineProperty(this, name, {
|
|
get: () => { return (IgniteRendering.rendering ? prop : prop.value); },
|
|
set: (value) => { prop.value = value; }
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Sets the values of properties on this ignite object.
|
|
* @param {Object|IgniteObject} props The properties to set onto this ignite object.
|
|
*/
|
|
setProperties(props) {
|
|
if (props == null || props == undefined) {
|
|
return;
|
|
}
|
|
|
|
if (props instanceof IgniteObject) {
|
|
props.update();
|
|
Object.getOwnPropertyNames(props).forEach(name => this[name] = props[name]);
|
|
} else {
|
|
Object.keys(props).forEach(name => this[name] = props[name]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an IgniteObject or Array of IgniteObjects and returns it.
|
|
* @param {Object|Array} obj The object to create an IgniteObject from.
|
|
* @returns {IgniteObject} The created IgniteObject.
|
|
*/
|
|
static create(obj) {
|
|
if (obj instanceof Array) {
|
|
var converted = [];
|
|
obj.forEach(item => converted.push(new IgniteObject(item)));
|
|
return converted;
|
|
} else if (!(obj instanceof IgniteObject)) {
|
|
return new IgniteObject(obj);
|
|
} else {
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The outline of a ignite callback that can be invoked and disconnected
|
|
* to help maintain and cleanup callbacks.
|
|
* @ignore
|
|
*/
|
|
class IgniteCallback {
|
|
/**
|
|
* Creates a new IgniteCallback with a callback and optional detach callback.
|
|
* @param {Function(...)} callback The callback function to invoke when the callback is invoked.
|
|
* @param {Function(IgniteCallback)} detach The detach function that is called when the callback is disconnected.
|
|
*/
|
|
constructor(callback, detach = null) {
|
|
this.callback = callback;
|
|
this.detach = detach;
|
|
}
|
|
|
|
/**
|
|
* Invokes this callback.
|
|
* @param {...any} params Any params to pass to the target function.
|
|
*/
|
|
async invoke(...params) {
|
|
if (this.callback) {
|
|
await this.callback(...params);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invokes the detach callback for this callback if there is one.
|
|
*/
|
|
disconnect() {
|
|
this.callback = null;
|
|
|
|
if (this.detach) {
|
|
this.detach(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The outline of a simple rendering context which allows us to
|
|
* know if we are currently rendering anything ignite related. This works
|
|
* because Javascript is single threaded, if events could break the current execution
|
|
* this would fail. But it's safe since events cannot do that.
|
|
* @ignore
|
|
*/
|
|
class IgniteRendering {
|
|
/**
|
|
* Increments the rendering counter. Must call leave() for each enter().
|
|
*/
|
|
static enter() {
|
|
if (!IgniteRendering.RenderCount) {
|
|
IgniteRendering.RenderCount = 0;
|
|
}
|
|
|
|
IgniteRendering.RenderCount++;
|
|
}
|
|
|
|
/**
|
|
* Decrements the rendering counter, if 0, rendering() will return false.
|
|
*/
|
|
static leave() {
|
|
if (IgniteRendering.RenderCount) {
|
|
IgniteRendering.RenderCount--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Saves the current rendering state.
|
|
*/
|
|
static push() {
|
|
if (IgniteRendering.Stack == null) {
|
|
IgniteRendering.Stack = [];
|
|
}
|
|
|
|
IgniteRendering.Stack.push(IgniteRendering.RenderCount);
|
|
IgniteRendering.RenderCount = 0;
|
|
}
|
|
|
|
/**
|
|
* Restores the last rendering state.
|
|
*/
|
|
static pop() {
|
|
if (IgniteRendering.Stack && IgniteRendering.Stack.length > 0) {
|
|
IgniteRendering.RenderCount = IgniteRendering.Stack.pop();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers a callback function that will be invoked once rendering is complete.
|
|
* @param {IgniteCallback|Function} callback The callback function to invoke once rendering is complete.
|
|
*/
|
|
static ready(callback) {
|
|
//Setup the callbacks if it's not init'd.
|
|
if (!IgniteRendering.ReadyCallbacks) {
|
|
IgniteRendering.ReadyCallbacks = [];
|
|
}
|
|
|
|
//Add this ignite callback.
|
|
IgniteRendering.ReadyCallbacks.push(callback);
|
|
|
|
//Clear the existing timer if there is one.
|
|
if (IgniteRendering.ReadyTimer && !IgniteRendering.ReadyTimerRunning) {
|
|
clearTimeout(IgniteRendering.ReadyTimer);
|
|
}
|
|
|
|
//Set a new timeout, it will only run once all elements are ready because
|
|
//of the way single threaded timers work.
|
|
if (!IgniteRendering.ReadyTimerRunning) {
|
|
IgniteRendering.ReadyTimer = setTimeout(async () => {
|
|
IgniteRendering.ReadyTimerRunning = true;
|
|
while (IgniteRendering.ReadyCallbacks.length > 0) {
|
|
var callback = IgniteRendering.ReadyCallbacks.shift();
|
|
|
|
if (callback instanceof IgniteCallback) {
|
|
callback.invoke();
|
|
} else if (callback instanceof Function) {
|
|
callback();
|
|
}
|
|
}
|
|
|
|
IgniteRendering.ReadyCallbacks = [];
|
|
IgniteRendering.ReadyTimer = null;
|
|
IgniteRendering.ReadyTimerRunning = false;
|
|
}, 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not we are currently in a rendering state.
|
|
*/
|
|
static get rendering() {
|
|
return IgniteRendering.RenderCount && IgniteRendering.RenderCount > 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Main helper class to access ignite html functions.
|
|
*/
|
|
class IgniteHtml {
|
|
/**
|
|
* Registers a new element to be rendered when render() is called.
|
|
* @param {String} name The tag name of the element to register.
|
|
* @param {Any} definition The class definition of the element.
|
|
*/
|
|
static register(name, definition) {
|
|
if (!IgniteHtml.registered) {
|
|
IgniteHtml.registered = { };
|
|
}
|
|
|
|
if (!IgniteHtml.registered[name]) {
|
|
IgniteHtml.registered[name] = definition;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Begins rendering all registered elements.
|
|
*/
|
|
static render() {
|
|
if (IgniteHtml.registered) {
|
|
var elements = Object.keys(IgniteHtml.registered);
|
|
|
|
for (var i = 0; i < elements.length; i++) {
|
|
customElements.define(elements[i], IgniteHtml.registered[elements[i]]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
window.IgniteProperty = IgniteProperty;
|
|
window.IgniteRendering = IgniteRendering;
|
|
window.IgniteObject = IgniteObject;
|
|
window.IgniteCallback = IgniteCallback;
|
|
window.IgniteHtml = IgniteHtml;
|
|
|
|
export {
|
|
IgniteProperty,
|
|
IgniteObject,
|
|
IgniteRendering,
|
|
IgniteCallback,
|
|
IgniteHtml
|
|
}; |