ng-canvas-gauges
Version:
Angular 6+ component wrapper for the canvas-gauges lib written by @Mikhus
437 lines • 34.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import * as tslib_1 from "tslib";
/*!
* The MIT License (MIT)
*
* Copyright (c) 2017 Vlad Martynenko <vladimir.martynenko.work@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import { ViewChild, Input, ElementRef } from '@angular/core';
import * as CanvasGauges from 'canvas-gauges';
import * as Rx from 'rx-dom-html';
// String utils
/** @type {?} */
var toCamelCase = (/**
* @param {?} str
* @return {?}
*/
function (str) { return str.replace(/(\-\w)/g, (/**
* @param {?} matches
* @return {?}
*/
function (matches) { return matches[1].toUpperCase(); })); });
var ɵ0 = toCamelCase;
/** @type {?} */
var toKebabCase = (/**
* @param {?} str
* @return {?}
*/
function (str) { return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase(); });
var ɵ1 = toKebabCase;
/** @type {?} */
var attributeName2PropertyName = (/**
* @param {?} attrName
* @return {?}
*/
function (attrName) { return toCamelCase(attrName); });
var ɵ2 = attributeName2PropertyName;
/**
* Base gauge component for the Gauges rendering
* T - Type of the Gauge to be rendered (Currently RadialGauge, LinearGauge from the original library)
* T2 - Type of config options used by the particular gauge (RadialGaugeOptions, LinearGaugeOptions)
* @abstract
* @template T, T2
*/
var BaseGauge = /** @class */ (function () {
/**
*
* @param el - reference to the element of the whole component, used to scrape options declared on the component itself
* @param zone - required to redraw gauge outside of Angular, due to animation lags caused by the ovewritten function of the ngZone
*/
function BaseGauge(el, zone) {
this.el = el;
this.zone = zone;
/**
* Flag indicating that OnViewInit life-cycle has completed
*/
this.isInited = false;
}
Object.defineProperty(BaseGauge.prototype, "options", {
/**
* Returns gauges properties as an options object.
* Option properties consist of the attribute-based properties and those
* explicitly set.
* @returns <T2>
*/
get: /**
* Returns gauges properties as an options object.
* Option properties consist of the attribute-based properties and those
* explicitly set.
* @return {?} <T2>
*/
function () {
var e_1, _a;
/** @type {?} */
var options = (/** @type {?} */ ({}));
options.renderTo = this.canvas.nativeElement;
try {
// Map attribute-based options onto options.
// Requries converting kebab style attribute names to camelCase property names
for (var _b = tslib_1.__values(this.el.nativeElement.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
var attr = _c.value;
/** @type {?} */
var prop = attributeName2PropertyName(attr.name);
options[prop] = CanvasGauges.DomObserver.parse(attr.value);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
// merge preOptons with attribute-based properties
// tslint:disable-next-line:forin
for (var prop in this.preInitOptions) {
options[prop] = this.preInitOptions[prop];
}
// clear the preInitOptions as they have already been merged
// with the attribute-based properties
if (this.isInited) {
this.preInitOptions = null;
}
return options;
},
/**
* Assign gauge options at anytime in the lifecycle.
* @param newOptions - assign the style and size properties
*/
set: /**
* Assign gauge options at anytime in the lifecycle.
* @param {?} newOptions - assign the style and size properties
* @return {?}
*/
function (newOptions) {
// cache newOptions as preInitOptions until gauge is ready
if (!this.isInited) {
this.preInitOptions = newOptions;
return;
}
this.update(newOptions);
},
enumerable: true,
configurable: true
});
Object.defineProperty(BaseGauge.prototype, "value", {
/**
* Assign the value of the gauge visual indicator such as a needle or pointer
* @param newValue the guage new value
*/
set: /**
* Assign the value of the gauge visual indicator such as a needle or pointer
* @param {?} newValue the guage new value
* @return {?}
*/
function (newValue) {
var _this = this;
// case new gauge value as preInitValue until the gauge is ready
if (!this.isInited) {
this.preInitValue = newValue;
return;
}
this.zone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.gauge.value = newValue;
}));
},
enumerable: true,
configurable: true
});
/**
* Update the gauge options. Do not use until after OnViewInit() before using.
*
* Special implementation note - options.properties are maintained as
* attribute name->value on this component's elementRef. Thus this method
* maps each newOptions property onto the property's corresponding attribute.
* The attribute update triggers a DOM mutation event which "this" listens for.
* See #listenForDOMEvents()
*
* @param newOptions - the options to update the gauge
*/
/**
* Update the gauge options. Do not use until after OnViewInit() before using.
*
* Special implementation note - options.properties are maintained as
* attribute name->value on this component's elementRef. Thus this method
* maps each newOptions property onto the property's corresponding attribute.
* The attribute update triggers a DOM mutation event which "this" listens for.
* See #listenForDOMEvents()
*
* @param {?} newOptions - the options to update the gauge
* @return {?}
*/
BaseGauge.prototype.update = /**
* Update the gauge options. Do not use until after OnViewInit() before using.
*
* Special implementation note - options.properties are maintained as
* attribute name->value on this component's elementRef. Thus this method
* maps each newOptions property onto the property's corresponding attribute.
* The attribute update triggers a DOM mutation event which "this" listens for.
* See #listenForDOMEvents()
*
* @param {?} newOptions - the options to update the gauge
* @return {?}
*/
function (newOptions) {
// map all options onto this element's attributes
// Then attribute changes will be detected and pushed to the gauge.update()
if (!newOptions) {
return;
}
// tslint:disable-next-line:forin
for (var prop in newOptions) {
/** @type {?} */
var val = newOptions[prop].toString();
if (prop === 'value') {
// short circuit the value property update by calling
// the gauge.value api directly for efficient animated update
this.value = CanvasGauges.DomObserver.parse(val);
}
else {
/** @type {?} */
var attrName = toKebabCase(prop);
this.el.nativeElement.setAttribute(attrName, val);
}
}
};
/**
* Perform gauge initialization.
* Subclasses that override this method must this super version
* for proper operation.
*/
/**
* Perform gauge initialization.
* Subclasses that override this method must this super version
* for proper operation.
* @return {?}
*/
BaseGauge.prototype.ngAfterViewInit = /**
* Perform gauge initialization.
* Subclasses that override this method must this super version
* for proper operation.
* @return {?}
*/
function () {
// initial update of gauge properties
this.initGauge();
this.listenForDOMEvents();
this.isInited = true;
};
/**
* Listen for attribute-change events that are created when updating
* the options of this gauge.
*/
/**
* Listen for attribute-change events that are created when updating
* the options of this gauge.
* @protected
* @return {?}
*/
BaseGauge.prototype.listenForDOMEvents = /**
* Listen for attribute-change events that are created when updating
* the options of this gauge.
* @protected
* @return {?}
*/
function () {
var _this = this;
// Listen to gauge element for attribute changes
// Convert all changed attribtues into a GenericOptions or subclass
// Update the gauge with the new options.
this.domListener =
Rx.DOM.fromMutationObserver(this.el.nativeElement, { attributes: true }).
subscribe((/**
* @param {?} changes
* @return {?}
*/
function (changes) {
/** @type {?} */
var newOptions = (/** @type {?} */ ({}));
changes.forEach((/**
* @param {?} change
* @return {?}
*/
function (change) {
if ('attributes' === change.type) {
// console.log('DOM, change', change.attributeName);
newOptions[attributeName2PropertyName(change.attributeName)] =
CanvasGauges.DomObserver.parse(_this.el.nativeElement.getAttribute(change.attributeName));
}
}));
_this.basicUpdate(newOptions);
}));
};
/**
* Discontinue listening for attribute change events.
*/
/**
* Discontinue listening for attribute change events.
* @protected
* @return {?}
*/
BaseGauge.prototype.stopListeningForDOMEvents = /**
* Discontinue listening for attribute change events.
* @protected
* @return {?}
*/
function () {
if (this.domListener) {
this.domListener.disconnect();
this.domListener = null;
}
};
/**
* Initalize the gauge with all options defined by attributes and
* parent component options.
*/
/**
* Initalize the gauge with all options defined by attributes and
* parent component options.
* @protected
* @return {?}
*/
BaseGauge.prototype.initGauge = /**
* Initalize the gauge with all options defined by attributes and
* parent component options.
* @protected
* @return {?}
*/
function () {
/** @type {?} */
var options = this.options;
if (this.preInitValue) {
options.value = this.preInitValue;
}
// init options.renderTo if needed
if (!options.hasOwnProperty('renderTo') || !options.renderTo) {
options.renderTo = this.canvas.nativeElement;
}
this.basicUpdate(options);
};
/**
* Performs the gauge update using the current options
* @param options The options for the guage
*/
/**
* Performs the gauge update using the current options
* @protected
* @param {?} options The options for the guage
* @return {?}
*/
BaseGauge.prototype.basicUpdate = /**
* Performs the gauge update using the current options
* @protected
* @param {?} options The options for the guage
* @return {?}
*/
function (options) {
// treat the value property special and update it through the
// value getter.
if (typeof options.value === 'number') {
// use gauge api directly for most efficient update method
this.value = options.value;
// filter value property from options to avoid redundant
// processing by gauge
delete options.value;
}
// do nothing if no option properties to update
if (Object.keys(options).length) {
this.gauge.update(options);
}
};
BaseGauge.propDecorators = {
canvas: [{ type: ViewChild, args: ['gauge',] }],
options: [{ type: Input }],
value: [{ type: Input }]
};
return BaseGauge;
}());
export { BaseGauge };
if (false) {
/**
* Canvas element on the template used by the library to draw gauge element
* @type {?}
* @protected
*/
BaseGauge.prototype.canvas;
/**
* A gauge instance responsible for rendering and updates on the canvas.
* Subclasses should initialize in their ngOnInit implementation.
* @type {?}
* @protected
*/
BaseGauge.prototype.gauge;
/**
* Flag indicating that OnViewInit life-cycle has completed
* @type {?}
* @private
*/
BaseGauge.prototype.isInited;
/**
* value property of gauge prior to component view initialization
* @type {?}
* @private
*/
BaseGauge.prototype.preInitValue;
/**
* options property of gauge prior to component view initialization
* @type {?}
* @private
*/
BaseGauge.prototype.preInitOptions;
/**
* Listen for attribute changes, i.e., options properties that are stored
* as attributes on this ElementRef
* @type {?}
* @private
*/
BaseGauge.prototype.domListener;
/**
* @type {?}
* @private
*/
BaseGauge.prototype.el;
/** @type {?} */
BaseGauge.prototype.zone;
/**
* Subclasses should instantiate the CanvasGauge object in the child component
* @abstract
* @return {?}
*/
BaseGauge.prototype.ngOnInit = function () { };
}
export { ɵ0, ɵ1, ɵ2 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-gauge.js","sourceRoot":"ng://ng-canvas-gauges/","sources":["lib/base-gauge.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * The MIT License (MIT)\n *\n * Copyright (c) 2017 Vlad Martynenko <vladimir.martynenko.work@gmail.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { ViewChild, Input, NgZone, ElementRef, OnInit, AfterViewInit } from '@angular/core';\nimport * as CanvasGauges from 'canvas-gauges';\nimport * as Rx from 'rx-dom-html';\n\n\n\n// String utils\nconst toCamelCase = (str: string) => str.replace(/(\\-\\w)/g, (matches) => matches[1].toUpperCase());\n\nconst toKebabCase = (str: string) => str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();\n\nconst attributeName2PropertyName = (attrName: string) => toCamelCase(attrName);\n\n\n\n\n/**\n * Base gauge component for the Gauges rendering\n * T - Type of the Gauge to be rendered (Currently RadialGauge, LinearGauge from the original library)\n * T2 - Type of config options used by the particular gauge (RadialGaugeOptions, LinearGaugeOptions)\n */\nexport abstract class BaseGauge<T extends CanvasGauges.BaseGauge, T2 extends CanvasGauges.GenericOptions>\n    implements OnInit, AfterViewInit {\n\n    /**\n     * Canvas element on the template used by the library to draw gauge element\n     */\n    @ViewChild('gauge')\n    protected canvas: ElementRef;\n\n    /**\n     * A gauge instance responsible for rendering and updates on the canvas.\n     * Subclasses should initialize in their ngOnInit implementation.\n     */\n    protected gauge: T;\n\n\n    /**\n     * Flag indicating that OnViewInit life-cycle has completed\n     */\n    private isInited = false;\n\n    /**\n     * value property of gauge prior to component view initialization\n     */\n    private preInitValue: number;\n\n    /**\n     * options property of gauge prior to component view initialization\n     */\n    private preInitOptions: T2;\n\n\n    /**\n     * Listen for attribute changes, i.e., options properties that are stored\n     * as attributes on this ElementRef\n     */\n    private domListener: MutationObserver;\n\n\n    /**\n     *\n     * @param el - reference to the element of the whole component, used to scrape options declared on the component itself\n     * @param zone - required to redraw gauge outside of Angular, due to animation lags caused by the ovewritten function of the ngZone\n     */\n    constructor(private el: ElementRef, public zone: NgZone) {\n    }\n\n\n    /**\n     * Subclasses should instantiate the CanvasGauge object in the child component\n     */\n    abstract ngOnInit(): void;\n\n\n    /**\n     * Returns gauges properties as an options object.\n     * Option properties consist of the attribute-based properties and those\n     * explicitly set.\n     * @returns <T2>\n     */\n    public get options(): T2 {\n\n        const options = {} as T2;\n        options.renderTo = this.canvas.nativeElement;\n\n        // Map attribute-based options onto options.\n        // Requries converting kebab style attribute names to camelCase property names\n        for (const attr of this.el.nativeElement.attributes) {\n            const prop = attributeName2PropertyName(attr.name);\n            options[prop] = CanvasGauges.DomObserver.parse(attr.value);\n        }\n\n        // merge preOptons with attribute-based properties\n        // tslint:disable-next-line:forin\n        for (const prop in this.preInitOptions) {\n            options[prop] = this.preInitOptions[prop];\n        }\n\n        // clear the preInitOptions as they have already been merged\n        // with the attribute-based properties\n        if (this.isInited) {\n            this.preInitOptions = null;\n        }\n\n        return options;\n    }\n\n\n    /**\n     * Assign gauge options at anytime in the lifecycle.\n     * @param newOptions - assign the style and size properties\n     */\n    @Input()\n    public set options(newOptions: T2) {\n\n        // cache newOptions as preInitOptions until gauge is ready\n        if (!this.isInited) {\n            this.preInitOptions = newOptions;\n            return;\n        }\n\n        this.update(newOptions);\n    }\n\n\n    /**\n     * Assign the value of the gauge visual indicator such as a needle or pointer\n     * @param newValue  the guage new value\n     */\n    @Input()\n    public set value(newValue: number) {\n\n        // case new gauge value as preInitValue until the gauge is ready\n        if (!this.isInited) {\n            this.preInitValue = newValue;\n            return;\n        }\n\n        this.zone.runOutsideAngular(() => {\n            this.gauge.value = newValue;\n        });\n    }\n\n\n    /**\n     * Update the gauge options. Do not use until after OnViewInit() before using.\n     *\n     * Special implementation note - options.properties are maintained as\n     * attribute name->value on this component's elementRef.  Thus this method\n     * maps each newOptions property onto the property's corresponding attribute.\n     * The attribute update triggers a DOM mutation event which  \"this\" listens for.\n     * See #listenForDOMEvents()\n     *\n     * @param newOptions  - the options to update the gauge\n     */\n    public update(newOptions: T2 | {}) {\n\n        // map all options onto this element's attributes\n        // Then attribute changes will be detected and pushed to the gauge.update()\n        if (!newOptions) { return; }\n\n        // tslint:disable-next-line:forin\n        for (const prop in newOptions) {\n            const val = newOptions[prop].toString();\n\n            if (prop === 'value') {\n                // short circuit the value property update by calling\n                // the gauge.value api directly for efficient animated update\n                this.value = CanvasGauges.DomObserver.parse(val);\n            } else {\n                const attrName = toKebabCase(prop);\n                this.el.nativeElement.setAttribute(attrName, val);\n            }\n        }\n    }\n\n\n    /**\n     * Perform gauge initialization.\n     * Subclasses that override this method must this super version\n     * for proper operation.\n     */\n    public ngAfterViewInit() {\n\n        // initial update of gauge properties\n        this.initGauge();\n\n        this.listenForDOMEvents();\n\n        this.isInited = true;\n    }\n\n\n    /**\n     * Listen for attribute-change events that are created when updating\n     * the options of this gauge.\n     */\n    protected listenForDOMEvents() {\n        // Listen to gauge element for attribute changes\n        // Convert all changed attribtues into a GenericOptions or subclass\n        // Update the gauge with the new options.\n        this.domListener =\n            Rx.DOM.fromMutationObserver(this.el.nativeElement, { attributes: true }).\n                subscribe(changes => {\n                    const newOptions = {} as T2;\n                    changes.forEach(change => {\n                        if ('attributes' === change.type) {\n                            // console.log('DOM, change', change.attributeName);\n                            newOptions[attributeName2PropertyName(change.attributeName)] =\n                                CanvasGauges.DomObserver.parse(\n                                    this.el.nativeElement.getAttribute(change.attributeName));\n                        }\n                    });\n\n                    this.basicUpdate(newOptions);\n                });\n    }\n\n\n    /**\n     * Discontinue listening for attribute change events.\n     */\n    protected stopListeningForDOMEvents() {\n        if (this.domListener) {\n            this.domListener.disconnect();\n            this.domListener = null;\n        }\n    }\n\n\n    /**\n     * Initalize the gauge with all options defined by attributes and\n     * parent component options.\n     */\n    protected initGauge() {\n        const options = this.options;\n        if (this.preInitValue) {\n            options.value = this.preInitValue;\n        }\n\n        // init options.renderTo if needed\n        if (!options.hasOwnProperty('renderTo') || !options.renderTo) {\n            options.renderTo = this.canvas.nativeElement;\n        }\n\n        this.basicUpdate(options);\n    }\n\n\n    /**\n     * Performs the gauge update using the current options\n     * @param options  The options for the guage\n     */\n    protected basicUpdate(options: T2) {\n\n        // treat the value property special and update it through the\n        // value getter.\n        if (typeof options.value === 'number') {\n\n            // use gauge api directly for most efficient update method\n            this.value = options.value;\n\n            // filter value property from options to avoid redundant\n            // processing by gauge\n            delete options.value;\n        }\n\n        // do nothing if no option properties to update\n        if (Object.keys(options).length) {\n            this.gauge.update(options);\n        }\n    }\n\n}\n\n\n\n"]}