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