@grptx/ng-canvas-gauges
Version:
Angular 14+ component wrapper for the canvas-gauges lib written by @Mikhus
230 lines • 28.4 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)
*/
export class BaseGauge {
/**
*
* @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;
/**
* Flag indicating that OnViewInit life-cycle has completed
*/
this.isInited = false;
}
/**
* 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);
}
}
}
BaseGauge.ɵfac = function BaseGauge_Factory(t) { return new (t || BaseGauge)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
BaseGauge.ɵ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" } });
(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":["/*!\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, Directive } 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 */\n@Directive()\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', { static: true })\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"]}