ngx-trend 6.1.0 → 8.0.0

package/README.md

@@ -40,12 +40,14 @@ npm install ngx-trend
 
 Latest version available for each version of Angular
 
-| ngx-trend | Angular |
-| --------- | ------- |
-| 3.4.3     | 6.x 7.x |
-| 4.0.2     | 8.x     |
-| 5.0.1     | 9.x     |
-| current   | >= 10.x |
+| ngx-trend | Angular   |
+| --------- | --------- |
+| 3.4.3     | 6.x 7.x   |
+| 4.0.2     | 8.x       |
+| 5.0.1     | 9.x       |
+| 6.1.1     | 10.x 11.x |
+| 7.0.0     | 12.x      |
+| current   | >= 13.x   |
 
 ### Quickstart
 

package/esm2020/helpers/DOM.helpers.mjs

@@ -0,0 +1,33 @@
+import { checkForCollinearPoints, getDistanceBetween, moveTo, } from './math.helpers';
+export const buildLinearPath = (data) => data.reduce((path, point, index) => {
+    // The very first instruction needs to be a "move".
+    // The rest will be a "line".
+    const isFirstInstruction = index === 0;
+    const instruction = isFirstInstruction ? 'M' : 'L';
+    return `${path}${instruction} ${point.x},${point.y}\n`;
+}, '');
+export function buildSmoothPath(data, radius) {
+    const [firstPoint, ...otherPoints] = data;
+    return otherPoints.reduce((path, point, index) => {
+        const next = otherPoints[index + 1];
+        const prev = otherPoints[index - 1] || firstPoint;
+        const isCollinear = next && checkForCollinearPoints(prev, point, next);
+        if (!next || isCollinear) {
+            // The very last line in the sequence can just be a regular line.
+            return `${path}\nL ${point.x},${point.y}`;
+        }
+        const distanceFromPrev = getDistanceBetween(prev, point);
+        const distanceFromNext = getDistanceBetween(next, point);
+        const threshold = Math.min(distanceFromPrev, distanceFromNext);
+        const isTooCloseForRadius = threshold / 2 < radius;
+        const radiusForPoint = isTooCloseForRadius ? threshold / 2 : radius;
+        const before = moveTo(prev, point, radiusForPoint);
+        const after = moveTo(next, point, radiusForPoint);
+        return [
+            path,
+            `L ${before.x},${before.y}`,
+            `S ${point.x},${point.y} ${after.x},${after.y}`,
+        ].join('\n');
+    }, `M ${firstPoint.x},${firstPoint.y}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/helpers/math.helpers.mjs

@@ -0,0 +1,68 @@
+/* eslint-disable no-restricted-properties */
+/** normalize
+ * This lets us translate a value from one scale to another.
+ *
+ * @param value - Our initial value to translate
+ * @param min - the current minimum value possible
+ * @param max - the current maximum value possible
+ * @param scaleMin - the min value of the scale we're translating to
+ * @param scaleMax - the max value of the scale we're translating to
+ * @returns the value on its new scale
+ */
+export function normalize(value, min, max, scaleMin = 0, scaleMax = 1) {
+    // If the `min` and `max` are the same value, it means our dataset is flat.
+    // For now, let's assume that flat data should be aligned to the bottom.
+    if (min === max) {
+        return scaleMin;
+    }
+    return scaleMin + (value - min) * (scaleMax - scaleMin) / (max - min);
+}
+/** moveTo
+ * the coordinate that lies at a midpoint between 2 lines, based on the radius
+ *
+ * @param to - Our initial point
+ * @param to.x - The x value of our initial point
+ * @param to.y - The y value of our initial point
+ * @param from - Our final point
+ * @param from.x - The x value of our final point
+ * @param from.y - The y value of our final point
+ * @param radius - The distance away from the final point
+ * @returns an object holding the x/y coordinates of the midpoint.
+ */
+export function moveTo(to, from, radius) {
+    const length = Math.sqrt((to.x - from.x) * (to.x - from.x) + (to.y - from.y) * (to.y - from.y));
+    const unitVector = { x: (to.x - from.x) / length, y: (to.y - from.y) / length };
+    return {
+        x: from.x + unitVector.x * radius,
+        y: from.y + unitVector.y * radius,
+    };
+}
+/** getDistanceBetween
+ * Simple formula derived from pythagoras to calculate the distance between
+ * 2 points on a plane.
+ *
+ * @param p1 - Our initial point
+ * @param p1.x - The x value of our initial point
+ * @param p1.y - The y value of our initial point
+ * @param p2 - Our final point
+ * @param p2.x - The x value of our final point
+ * @param p2.y - The y value of our final point
+ * @returns the distance between the points.
+ */
+export const getDistanceBetween = (p1, p2) => Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+/** checkForCollinearPoints
+ * Figure out if the midpoint fits perfectly on a line between the two others.
+ *
+ * @param p1 - Our initial point
+ * @param p1.x - The x value of our initial point
+ * @param p1.y - The y value of our initial point
+ * @param p2 - Our mid-point
+ * @param p2.x - The x value of our mid-point
+ * @param p2.y - The y value of our mid-point
+ * @param p3 - Our final point
+ * @param p3.x - The x value of our final point
+ * @param p3.y - The y value of our final point
+ * @returns whether or not p2 sits on the line between p1 and p3.
+ */
+export const checkForCollinearPoints = (p1, p2, p3) => (p1.y - p2.y) * (p1.x - p3.x) === (p1.y - p3.y) * (p1.x - p2.x);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/helpers/misc.helpers.mjs

@@ -0,0 +1,2 @@
+export const generateId = () => Math.round(Math.random() * Math.pow(10, 16));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlzYy5oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9oZWxwZXJzL21pc2MuaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBnZW5lcmF0ZUlkID0gKCkgPT4gTWF0aC5yb3VuZChNYXRoLnJhbmRvbSgpICogTWF0aC5wb3coMTAsIDE2KSk7XG4iXX0=

package/{esm2015/ngx-trend.js → esm2020/ngx-trend.mjs}

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './public_api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LXRyZW5kLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uL3NyYy9saWIvIiwic291cmNlcyI6WyJuZ3gtdHJlbmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LXRyZW5kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xpYi9uZ3gtdHJlbmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/{esm2015/public_api.js → esm2020/public_api.mjs}

@@ -1,3 +1,3 @@
 export * from './trend/trend.component';
 export * from './trend/trend.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLi9zcmMvbGliLyIsInNvdXJjZXMiOlsicHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyZW5kL3RyZW5kLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZW5kL3RyZW5kLm1vZHVsZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyZW5kL3RyZW5kLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZW5kL3RyZW5kLm1vZHVsZSc7XG4iXX0=

package/esm2020/trend/trend.component.mjs

@@ -0,0 +1,255 @@
+import { animate, keyframes, state, style, transition, trigger } from '@angular/animations';
+import { Component, Input, ViewChild } from '@angular/core';
+import { buildLinearPath, buildSmoothPath } from '../helpers/DOM.helpers';
+import { normalize } from '../helpers/math.helpers';
+import { generateId } from '../helpers/misc.helpers';
+import { normalizeDataset } from './trend.helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class TrendComponent {
+    constructor() {
+        this.autoDraw = false;
+        this.autoDrawDuration = 2000;
+        this.autoDrawEasing = 'ease';
+        this.padding = 8;
+        this.radius = 10;
+        this.stroke = 'black';
+        this.strokeLinecap = '';
+        this.strokeWidth = 1;
+        this.gradient = [];
+        this.svgHeight = '25%';
+        this.svgWidth = '100%';
+        this.animationState = '';
+        this.id = generateId();
+        this.gradientId = `ngx-trend-vertical-gradient-${this.id}`;
+    }
+    ngOnChanges() {
+        // We need at least 2 points to draw a graph.
+        if (!this.data || this.data.length < 2) {
+            return;
+        }
+        // `data` can either be an array of numbers:
+        // [1, 2, 3]
+        // or, an array of objects containing a value:
+        // [{ value: 1 }, { value: 2 }, { value: 3 }]
+        //
+        // For now, we're just going to convert the second form to the first.
+        // Later on, if/when we support tooltips, we may adjust.
+        const plainValues = this.data.map(point => {
+            if (typeof point === 'number') {
+                return point;
+            }
+            return point.value;
+        });
+        // Our viewbox needs to be in absolute units, so we'll default to 300x75
+        // Our SVG can be a %, though; this is what makes it scalable.
+        // By defaulting to percentages, the SVG will grow to fill its parent
+        // container, preserving a 1/4 aspect ratio.
+        const viewBoxWidth = this.width || 300;
+        const viewBoxHeight = this.height || 75;
+        this.svgWidth = this.width || '100%';
+        this.svgHeight = this.height || '25%';
+        this.viewBox = `0 0 ${viewBoxWidth} ${viewBoxHeight}`;
+        const root = location.href.split(location.hash || '#')[0];
+        this.pathStroke =
+            this.gradient && this.gradient.length ? `url('${root}#${this.gradientId}')` : undefined;
+        this.gradientTrimmed = this.gradient
+            .slice()
+            .reverse()
+            .map((val, idx) => {
+            return {
+                idx,
+                stopColor: val,
+                offset: normalize(idx, 0, this.gradient.length - 1 || 1),
+            };
+        });
+        const normalizedValues = normalizeDataset(plainValues, this.padding, viewBoxWidth - this.padding, 
+        // NOTE: Because SVGs are indexed from the top left, but most data is
+        // indexed from the bottom left, we're inverting the Y min/max.
+        viewBoxHeight - this.padding, this.padding);
+        if (this.autoDraw && this.animationState !== 'active') {
+            this.animationState = 'inactive';
+            setTimeout(() => {
+                this.lineLength = this.pathEl.nativeElement.getTotalLength();
+                this.animationState = 'active';
+            });
+        }
+        this.d = this.smooth
+            ? buildSmoothPath(normalizedValues, this.radius)
+            : buildLinearPath(normalizedValues);
+    }
+}
+TrendComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TrendComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TrendComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: TrendComponent, selector: "ngx-trend", inputs: { data: "data", smooth: "smooth", autoDraw: "autoDraw", autoDrawDuration: "autoDrawDuration", autoDrawEasing: "autoDrawEasing", width: "width", height: "height", padding: "padding", radius: "radius", stroke: "stroke", strokeLinecap: "strokeLinecap", strokeWidth: "strokeWidth", gradient: "gradient", preserveAspectRatio: "preserveAspectRatio", svgHeight: "svgHeight", svgWidth: "svgWidth" }, viewQueries: [{ propertyName: "pathEl", first: true, predicate: ["pathEl"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <svg
+      *ngIf="data && data.length >= 2"
+      [attr.width]="svgWidth"
+      [attr.height]="svgHeight"
+      [attr.stroke]="stroke"
+      [attr.stroke-width]="strokeWidth"
+      [attr.stroke-linecap]="strokeLinecap"
+      [attr.viewBox]="viewBox"
+      [attr.preserveAspectRatio]="preserveAspectRatio"
+    >
+      <defs *ngIf="gradient && gradient.length">
+        <linearGradient [attr.id]="gradientId" x1="0%" y1="0%" x2="0%" y2="100%">
+          <stop
+            *ngFor="let g of gradientTrimmed"
+            [attr.key]="g.idx"
+            [attr.offset]="g.offset"
+            [attr.stop-color]="g.stopColor"
+          />
+        </linearGradient>
+      </defs>
+      <path
+        fill="none"
+        #pathEl
+        [attr.stroke]="pathStroke"
+        [attr.d]="d"
+        [@pathAnimaiton]="{
+          value: animationState,
+          params: {
+            autoDrawDuration: autoDrawDuration,
+            autoDrawEasing: autoDrawEasing,
+            lineLength: lineLength
+          }
+        }"
+      />
+    </svg>
+  `, isInline: true, directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], animations: [
+        trigger('pathAnimaiton', [
+            state('inactive', style({ display: 'none' })),
+            transition('* => active', [
+                style({ display: 'initial' }),
+                // We do the animation using the dash array/offset trick
+                // https://css-tricks.com/svg-line-animation-works/
+                animate('{{ autoDrawDuration }}ms {{ autoDrawEasing }}', keyframes([
+                    style({
+                        'stroke-dasharray': '{{ lineLength }}px',
+                        'stroke-dashoffset': '{{ lineLength }}px',
+                    }),
+                    style({
+                        'stroke-dasharray': '{{ lineLength }}px',
+                        'stroke-dashoffset': 0,
+                    }),
+                ])),
+                // One unfortunate side-effect of the auto-draw is that the line is
+                // actually 1 big dash, the same length as the line itself. If the
+                // line length changes (eg. radius change, new data), that dash won't
+                // be the same length anymore. We can fix that by removing those
+                // properties once the auto-draw is completed.
+                style({
+                    'stroke-dashoffset': '',
+                    'stroke-dasharray': '',
+                }),
+            ]),
+        ]),
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TrendComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngx-trend',
+                    template: `
+    <svg
+      *ngIf="data && data.length >= 2"
+      [attr.width]="svgWidth"
+      [attr.height]="svgHeight"
+      [attr.stroke]="stroke"
+      [attr.stroke-width]="strokeWidth"
+      [attr.stroke-linecap]="strokeLinecap"
+      [attr.viewBox]="viewBox"
+      [attr.preserveAspectRatio]="preserveAspectRatio"
+    >
+      <defs *ngIf="gradient && gradient.length">
+        <linearGradient [attr.id]="gradientId" x1="0%" y1="0%" x2="0%" y2="100%">
+          <stop
+            *ngFor="let g of gradientTrimmed"
+            [attr.key]="g.idx"
+            [attr.offset]="g.offset"
+            [attr.stop-color]="g.stopColor"
+          />
+        </linearGradient>
+      </defs>
+      <path
+        fill="none"
+        #pathEl
+        [attr.stroke]="pathStroke"
+        [attr.d]="d"
+        [@pathAnimaiton]="{
+          value: animationState,
+          params: {
+            autoDrawDuration: autoDrawDuration,
+            autoDrawEasing: autoDrawEasing,
+            lineLength: lineLength
+          }
+        }"
+      />
+    </svg>
+  `,
+                    animations: [
+                        trigger('pathAnimaiton', [
+                            state('inactive', style({ display: 'none' })),
+                            transition('* => active', [
+                                style({ display: 'initial' }),
+                                // We do the animation using the dash array/offset trick
+                                // https://css-tricks.com/svg-line-animation-works/
+                                animate('{{ autoDrawDuration }}ms {{ autoDrawEasing }}', keyframes([
+                                    style({
+                                        'stroke-dasharray': '{{ lineLength }}px',
+                                        'stroke-dashoffset': '{{ lineLength }}px',
+                                    }),
+                                    style({
+                                        'stroke-dasharray': '{{ lineLength }}px',
+                                        'stroke-dashoffset': 0,
+                                    }),
+                                ])),
+                                // One unfortunate side-effect of the auto-draw is that the line is
+                                // actually 1 big dash, the same length as the line itself. If the
+                                // line length changes (eg. radius change, new data), that dash won't
+                                // be the same length anymore. We can fix that by removing those
+                                // properties once the auto-draw is completed.
+                                style({
+                                    'stroke-dashoffset': '',
+                                    'stroke-dasharray': '',
+                                }),
+                            ]),
+                        ]),
+                    ],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { data: [{
+                type: Input
+            }], smooth: [{
+                type: Input
+            }], autoDraw: [{
+                type: Input
+            }], autoDrawDuration: [{
+                type: Input
+            }], autoDrawEasing: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], padding: [{
+                type: Input
+            }], radius: [{
+                type: Input
+            }], stroke: [{
+                type: Input
+            }], strokeLinecap: [{
+                type: Input
+            }], strokeWidth: [{
+                type: Input
+            }], gradient: [{
+                type: Input
+            }], preserveAspectRatio: [{
+                type: Input
+            }], svgHeight: [{
+                type: Input
+            }], svgWidth: [{
+                type: Input
+            }], pathEl: [{
+                type: ViewChild,
+                args: ['pathEl']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trend.component.js","sourceRoot":"","sources":["../../../src/lib/trend/trend.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { animate, keyframes, state, style, transition, trigger } from '@angular/animations';\nimport { Component, ElementRef, Input, OnChanges, ViewChild } from '@angular/core';\n\nimport { buildLinearPath, buildSmoothPath } from '../helpers/DOM.helpers';\nimport { normalize } from '../helpers/math.helpers';\nimport { generateId } from '../helpers/misc.helpers';\nimport { normalizeDataset } from './trend.helpers';\n\n@Component({\n  selector: 'ngx-trend',\n  template: `\n    <svg\n      *ngIf=\"data && data.length >= 2\"\n      [attr.width]=\"svgWidth\"\n      [attr.height]=\"svgHeight\"\n      [attr.stroke]=\"stroke\"\n      [attr.stroke-width]=\"strokeWidth\"\n      [attr.stroke-linecap]=\"strokeLinecap\"\n      [attr.viewBox]=\"viewBox\"\n      [attr.preserveAspectRatio]=\"preserveAspectRatio\"\n    >\n      <defs *ngIf=\"gradient && gradient.length\">\n        <linearGradient [attr.id]=\"gradientId\" x1=\"0%\" y1=\"0%\" x2=\"0%\" y2=\"100%\">\n          <stop\n            *ngFor=\"let g of gradientTrimmed\"\n            [attr.key]=\"g.idx\"\n            [attr.offset]=\"g.offset\"\n            [attr.stop-color]=\"g.stopColor\"\n          />\n        </linearGradient>\n      </defs>\n      <path\n        fill=\"none\"\n        #pathEl\n        [attr.stroke]=\"pathStroke\"\n        [attr.d]=\"d\"\n        [@pathAnimaiton]=\"{\n          value: animationState,\n          params: {\n            autoDrawDuration: autoDrawDuration,\n            autoDrawEasing: autoDrawEasing,\n            lineLength: lineLength\n          }\n        }\"\n      />\n    </svg>\n  `,\n  animations: [\n    trigger('pathAnimaiton', [\n      state('inactive', style({ display: 'none' })),\n      transition('* => active', [\n        style({ display: 'initial' }),\n        // We do the animation using the dash array/offset trick\n        // https://css-tricks.com/svg-line-animation-works/\n        animate(\n          '{{ autoDrawDuration }}ms {{ autoDrawEasing }}',\n          keyframes([\n            style({\n              'stroke-dasharray': '{{ lineLength }}px',\n              'stroke-dashoffset': '{{ lineLength }}px',\n            }),\n            style({\n              'stroke-dasharray': '{{ lineLength }}px',\n              'stroke-dashoffset': 0,\n            }),\n          ]),\n        ),\n        // One unfortunate side-effect of the auto-draw is that the line is\n        // actually 1 big dash, the same length as the line itself. If the\n        // line length changes (eg. radius change, new data), that dash won't\n        // be the same length anymore. We can fix that by removing those\n        // properties once the auto-draw is completed.\n        style({\n          'stroke-dashoffset': '',\n          'stroke-dasharray': '',\n        }),\n      ]),\n    ]),\n  ],\n})\nexport class TrendComponent implements OnChanges {\n  id: number;\n  @Input() data?: Array<(number | { value: number })>;\n  @Input() smooth?: boolean;\n  @Input() autoDraw = false;\n  @Input() autoDrawDuration = 2000;\n  @Input() autoDrawEasing = 'ease';\n  @Input() width?: number;\n  @Input() height?: number;\n  @Input() padding = 8;\n  @Input() radius = 10;\n  @Input() stroke = 'black';\n  @Input() strokeLinecap = '';\n  @Input() strokeWidth = 1;\n  @Input() gradient: string[] = [];\n  @Input() preserveAspectRatio?: string;\n  @Input() svgHeight: string | number = '25%';\n  @Input() svgWidth: string | number = '100%';\n  @ViewChild('pathEl') pathEl!: ElementRef;\n  gradientTrimmed!: Array<{ idx: number; stopColor: string; offset: number }>;\n  d: any;\n  viewBox!: string;\n  pathStroke: any;\n  gradientId: string;\n  lineLength!: number;\n  animationState = '';\n\n  constructor() {\n    this.id = generateId();\n    this.gradientId = `ngx-trend-vertical-gradient-${this.id}`;\n  }\n  ngOnChanges(): void {\n    // We need at least 2 points to draw a graph.\n    if (!this.data || this.data.length < 2) {\n      return;\n    }\n\n    // `data` can either be an array of numbers:\n    // [1, 2, 3]\n    // or, an array of objects containing a value:\n    // [{ value: 1 }, { value: 2 }, { value: 3 }]\n    //\n    // For now, we're just going to convert the second form to the first.\n    // Later on, if/when we support tooltips, we may adjust.\n    const plainValues = this.data.map(point => {\n      if (typeof point === 'number') {\n        return point;\n      }\n      return point.value;\n    });\n\n    // Our viewbox needs to be in absolute units, so we'll default to 300x75\n    // Our SVG can be a %, though; this is what makes it scalable.\n    // By defaulting to percentages, the SVG will grow to fill its parent\n    // container, preserving a 1/4 aspect ratio.\n    const viewBoxWidth = this.width || 300;\n    const viewBoxHeight = this.height || 75;\n    this.svgWidth = this.width || '100%';\n    this.svgHeight = this.height || '25%';\n    this.viewBox = `0 0 ${viewBoxWidth} ${viewBoxHeight}`;\n    const root = location.href.split(location.hash || '#')[0];\n    this.pathStroke =\n      this.gradient && this.gradient.length ? `url('${root}#${this.gradientId}')` : undefined;\n\n    this.gradientTrimmed = this.gradient\n      .slice()\n      .reverse()\n      .map((val, idx) => {\n        return {\n          idx,\n          stopColor: val,\n          offset: normalize(idx, 0, this.gradient.length - 1 || 1),\n        };\n      });\n\n    const normalizedValues = normalizeDataset(\n      plainValues,\n      this.padding,\n      viewBoxWidth - this.padding,\n      // NOTE: Because SVGs are indexed from the top left, but most data is\n      // indexed from the bottom left, we're inverting the Y min/max.\n      viewBoxHeight - this.padding,\n      this.padding,\n    );\n\n    if (this.autoDraw && this.animationState !== 'active') {\n      this.animationState = 'inactive';\n      setTimeout(() => {\n        this.lineLength = this.pathEl.nativeElement.getTotalLength();\n        this.animationState = 'active';\n      });\n    }\n\n    this.d = this.smooth\n      ? buildSmoothPath(normalizedValues, this.radius)\n      : buildLinearPath(normalizedValues);\n  }\n}\n"]}

package/esm2020/trend/trend.helpers.mjs

@@ -0,0 +1,28 @@
+import { normalize } from '../helpers/math.helpers';
+export function normalizeDataset(data, minX, maxX, minY, maxY) {
+    // For the X axis, we want to normalize it based on its index in the array.
+    // For the Y axis, we want to normalize it based on the element's value.
+    //
+    // X axis is easy: just evenly-space each item in the array.
+    // For the Y axis, we first need to find the min and max of our array,
+    // and then normalize those values between 0 and 1.
+    const boundariesX = { min: 0, max: data.length - 1 };
+    const boundariesY = { min: Math.min(...data), max: Math.max(...data) };
+    const normalizedData = data.map((point, index) => ({
+        x: normalize(index, boundariesX.min, boundariesX.max, minX, maxX),
+        y: normalize(point, boundariesY.min, boundariesY.max, minY, maxY),
+    }));
+    // According to the SVG spec, paths with a height/width of `0` can't have
+    // linear gradients applied. This means that our lines are invisible when
+    // the dataset is flat (eg. [0, 0, 0, 0]).
+    //
+    // The hacky solution is to apply a very slight offset to the first point of
+    // the dataset. As ugly as it is, it's the best solution we can find (there
+    // are ways within the SVG spec of changing it, but not without causing
+    // breaking changes).
+    if (boundariesY.min === boundariesY.max) {
+        normalizedData[0].y += 0.0001;
+    }
+    return normalizedData;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/trend/trend.module.mjs

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TrendComponent } from './trend.component';
+import * as i0 from "@angular/core";
+export class TrendModule {
+}
+TrendModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TrendModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TrendModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TrendModule, declarations: [TrendComponent], imports: [CommonModule], exports: [TrendComponent] });
+TrendModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TrendModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TrendModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    exports: [TrendComponent],
+                    declarations: [TrendComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlbmQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmVuZC90cmVuZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQU9uRCxNQUFNLE9BQU8sV0FBVzs7d0dBQVgsV0FBVzt5R0FBWCxXQUFXLGlCQUZQLGNBQWMsYUFGbkIsWUFBWSxhQUNaLGNBQWM7eUdBR2IsV0FBVyxZQUpiLENBQUMsWUFBWSxDQUFDOzJGQUlaLFdBQVc7a0JBTHZCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxjQUFjLENBQUM7b0JBQ3pCLFlBQVksRUFBRSxDQUFDLGNBQWMsQ0FBQztpQkFDL0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgVHJlbmRDb21wb25lbnQgfSBmcm9tICcuL3RyZW5kLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBleHBvcnRzOiBbVHJlbmRDb21wb25lbnRdLFxuICBkZWNsYXJhdGlvbnM6IFtUcmVuZENvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIFRyZW5kTW9kdWxlIHtcbn1cbiJdfQ==