@aquera/nile-visualization 0.1.0 → 0.3.0

package/dist/src/nile-dumbbell-upper-chart/nile-dumbbell-upper-chart.js

@@ -0,0 +1,214 @@
+import { __decorate } from "tslib";
+import { customElement, property, query } from 'lit/decorators.js';
+import { html } from 'lit';
+import { getHighcharts } from '../internal/highcharts-provider.js';
+import NileElement from '../internal/nile-element.js';
+import { applySeparatedChartConfig } from '../internal/separated-chart-config.js';
+import { deepMerge } from '../internal/utils.js';
+import { styles } from './nile-dumbbell-upper-chart.css.js';
+let NileDumbbellUpperChart = class NileDumbbellUpperChart extends NileElement {
+    constructor() {
+        super(...arguments);
+        this._hc = null;
+        this.chart = null;
+        this.resizeObserver = null;
+        this.config = null;
+        this.chartTitle = '';
+        this.chartSubtitle = '';
+        this.data = [];
+        this.options = {};
+        this.loading = false;
+        this.height = '400px';
+        this.yAxisTitle = '';
+        this.seriesName = '';
+        this.lowMarkerColor = '#ef4444';
+        this.connectorColor = '#94a3b8';
+        this.showLegend = false;
+        this.horizontal = false;
+    }
+    applyConfig(cfg) {
+        applySeparatedChartConfig(this, cfg);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.config)
+            this.applyConfig(this.config);
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.destroyChart();
+        this.resizeObserver?.disconnect();
+        this.resizeObserver = null;
+    }
+    firstUpdated() {
+        this.initChart();
+        this.setupResizeObserver();
+    }
+    updated(changedProperties) {
+        if (changedProperties.has('config') && this.config) {
+            this.applyConfig(this.config);
+            return;
+        }
+        const props = [
+            'data',
+            'chartTitle',
+            'chartSubtitle',
+            'options',
+            'height',
+            'yAxisTitle',
+            'seriesName',
+            'lowMarkerColor',
+            'connectorColor',
+            'showLegend',
+            'horizontal',
+            'loading',
+        ];
+        if (!props.some(p => changedProperties.has(p)))
+            return;
+        if (this.loading) {
+            this.destroyChart();
+            return;
+        }
+        if (this.chart) {
+            this.chart.update(this.buildOptions(), true, true);
+        }
+        else {
+            this.initChart();
+        }
+    }
+    setupResizeObserver() {
+        if (!this.chartContainer)
+            return;
+        this.resizeObserver = new ResizeObserver(() => this.chart?.reflow());
+        this.resizeObserver.observe(this.chartContainer);
+    }
+    buildOptions() {
+        const self = this;
+        return deepMerge({
+            chart: {
+                type: 'dumbbell',
+                height: this.height,
+                inverted: this.horizontal,
+            },
+            title: { text: this.chartTitle || undefined },
+            subtitle: { text: this.chartSubtitle || undefined },
+            legend: { enabled: this.showLegend },
+            xAxis: { type: 'category' },
+            yAxis: { title: { text: this.yAxisTitle || undefined } },
+            tooltip: {
+                shared: true,
+                pointFormat: '<b>{point.name}</b><br/>Low: <b>{point.low}</b><br/>High: <b>{point.high}</b>',
+            },
+            plotOptions: {
+                dumbbell: {
+                    lowColor: this.lowMarkerColor,
+                    connectorColor: this.connectorColor,
+                    connectorWidth: 2,
+                    lowMarker: { radius: 4, lineWidth: 2, lineColor: '#ffffff' },
+                    marker: { radius: 10, lineWidth: 2, lineColor: '#ffffff' },
+                    cursor: 'pointer',
+                    point: {
+                        events: {
+                            click() {
+                                self.emit('nile-chart-click', {
+                                    point: this,
+                                    category: this.name,
+                                    low: this.low,
+                                    high: this.high,
+                                    seriesName: this.series.name,
+                                });
+                            },
+                        },
+                    },
+                },
+            },
+            series: [
+                {
+                    type: 'dumbbell',
+                    name: this.seriesName || 'Range',
+                    data: this.data.map(d => {
+                        const row = {
+                            name: d.name,
+                            low: d.low,
+                            high: d.high,
+                        };
+                        if (d.color)
+                            row.color = d.color;
+                        if (d.lowColor)
+                            row.lowColor = d.lowColor;
+                        return row;
+                    }),
+                },
+            ],
+            credits: { enabled: false },
+        }, this.options);
+    }
+    async initChart() {
+        if (this.loading || !this.chartContainer)
+            return;
+        if (!this._hc)
+            this._hc = await getHighcharts();
+        this.chart = this._hc.chart(this.chartContainer, this.buildOptions());
+        this.emit('nile-chart-ready', { chart: this.chart });
+    }
+    destroyChart() {
+        if (this.chart) {
+            this.chart.destroy();
+            this.chart = null;
+        }
+    }
+    render() {
+        if (this.loading) {
+            return html `<div class="chart-loading" style="height:${this.height}">Loading...</div>`;
+        }
+        return html `<div class="chart-container"></div>`;
+    }
+};
+NileDumbbellUpperChart.styles = styles;
+__decorate([
+    query('.chart-container')
+], NileDumbbellUpperChart.prototype, "chartContainer", void 0);
+__decorate([
+    property({ type: Object })
+], NileDumbbellUpperChart.prototype, "config", void 0);
+__decorate([
+    property({ type: String, attribute: 'chart-title' })
+], NileDumbbellUpperChart.prototype, "chartTitle", void 0);
+__decorate([
+    property({ type: String, attribute: 'chart-subtitle' })
+], NileDumbbellUpperChart.prototype, "chartSubtitle", void 0);
+__decorate([
+    property({ type: Array })
+], NileDumbbellUpperChart.prototype, "data", void 0);
+__decorate([
+    property({ type: Object })
+], NileDumbbellUpperChart.prototype, "options", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NileDumbbellUpperChart.prototype, "loading", void 0);
+__decorate([
+    property({ type: String })
+], NileDumbbellUpperChart.prototype, "height", void 0);
+__decorate([
+    property({ type: String, attribute: 'y-axis-title' })
+], NileDumbbellUpperChart.prototype, "yAxisTitle", void 0);
+__decorate([
+    property({ type: String, attribute: 'series-name' })
+], NileDumbbellUpperChart.prototype, "seriesName", void 0);
+__decorate([
+    property({ type: String, attribute: 'low-marker-color' })
+], NileDumbbellUpperChart.prototype, "lowMarkerColor", void 0);
+__decorate([
+    property({ type: String, attribute: 'connector-color' })
+], NileDumbbellUpperChart.prototype, "connectorColor", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'show-legend' })
+], NileDumbbellUpperChart.prototype, "showLegend", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true, attribute: 'horizontal' })
+], NileDumbbellUpperChart.prototype, "horizontal", void 0);
+NileDumbbellUpperChart = __decorate([
+    customElement('nile-dumbbell-upper-chart')
+], NileDumbbellUpperChart);
+export { NileDumbbellUpperChart };
+//# sourceMappingURL=nile-dumbbell-upper-chart.js.map

package/dist/src/nile-euler-chart/index.d.ts

@@ -0,0 +1,2 @@
+export { NileEulerChart } from './nile-euler-chart.js';
+export type { EulerVennDataPoint } from './nile-euler-chart.js';

package/dist/src/nile-euler-chart/index.js

@@ -0,0 +1,2 @@
+export { NileEulerChart } from './nile-euler-chart.js';
+//# sourceMappingURL=index.js.map

package/dist/src/nile-euler-chart/nile-euler-chart.css.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("lit").CSSResult;

package/dist/src/nile-euler-chart/nile-euler-chart.css.js

@@ -0,0 +1,28 @@
+import { css } from 'lit';
+export const styles = css `
+  :host {
+    display: block;
+    width: 100%;
+    position: relative;
+  }
+
+  :host([hidden]) {
+    display: none;
+  }
+
+  .chart-container {
+    width: 100%;
+    min-height: var(--nile-height-200px, var(--ng-height-200px));
+  }
+
+  .chart-loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: inherit;
+    color: var(--nile-colors-neutral-700, var(--ng-colors-text-secondary-700));
+    font-family: var(--nile-font-family-serif, var(--ng-font-family-body));
+    font-size: var(--nile-type-scale-3, var(--ng-font-size-text-sm));
+  }
+`;
+//# sourceMappingURL=nile-euler-chart.css.js.map

package/dist/src/nile-euler-chart/nile-euler-chart.d.ts

@@ -0,0 +1,38 @@
+import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import type Highcharts from 'highcharts';
+import NileElement from '../internal/nile-element.js';
+import type { SeparatedChartConfigInputType } from '../internal/types/separated-chart-config-input.type.js';
+export interface EulerVennDataPoint {
+    sets: string[];
+    value: number;
+    name?: string;
+}
+export declare class NileEulerChart extends NileElement {
+    static styles: CSSResultGroup;
+    private _hc;
+    private chart;
+    private resizeObserver;
+    private chartContainer;
+    config: SeparatedChartConfigInputType | null;
+    chartTitle: string;
+    chartSubtitle: string;
+    data: EulerVennDataPoint[];
+    options: Highcharts.Options;
+    loading: boolean;
+    height: string;
+    private applyConfig;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected firstUpdated(): void;
+    protected updated(changedProperties: PropertyValues): void;
+    private setupResizeObserver;
+    private buildOptions;
+    private initChart;
+    private destroyChart;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-euler-chart': NileEulerChart;
+    }
+}

package/dist/src/nile-euler-chart/nile-euler-chart.js

@@ -0,0 +1,149 @@
+import { __decorate } from "tslib";
+import { customElement, property, query } from 'lit/decorators.js';
+import { html } from 'lit';
+import NileElement from '../internal/nile-element.js';
+import { applySeparatedChartConfig } from '../internal/separated-chart-config.js';
+import { getHighcharts } from '../internal/highcharts-provider.js';
+import { deepMerge } from '../internal/utils.js';
+import { styles } from './nile-euler-chart.css.js';
+let NileEulerChart = class NileEulerChart extends NileElement {
+    constructor() {
+        super(...arguments);
+        this._hc = null;
+        this.chart = null;
+        this.resizeObserver = null;
+        this.config = null;
+        this.chartTitle = '';
+        this.chartSubtitle = '';
+        this.data = [];
+        this.options = {};
+        this.loading = false;
+        this.height = '400px';
+    }
+    applyConfig(cfg) {
+        applySeparatedChartConfig(this, cfg);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.config)
+            this.applyConfig(this.config);
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.destroyChart();
+        this.resizeObserver?.disconnect();
+        this.resizeObserver = null;
+    }
+    firstUpdated() {
+        this.initChart();
+        this.setupResizeObserver();
+    }
+    updated(changedProperties) {
+        if (changedProperties.has('config') && this.config) {
+            this.applyConfig(this.config);
+            return;
+        }
+        const props = ['data', 'chartTitle', 'chartSubtitle', 'options', 'height', 'loading'];
+        if (!props.some(p => changedProperties.has(p)))
+            return;
+        if (this.loading) {
+            this.destroyChart();
+            return;
+        }
+        if (this.chart) {
+            this.chart.update(this.buildOptions(), true, true);
+        }
+        else {
+            this.initChart();
+        }
+    }
+    setupResizeObserver() {
+        if (!this.chartContainer)
+            return;
+        this.resizeObserver = new ResizeObserver(() => this.chart?.reflow());
+        this.resizeObserver.observe(this.chartContainer);
+    }
+    buildOptions() {
+        const self = this;
+        return deepMerge({
+            chart: { height: this.height },
+            title: { text: this.chartTitle || undefined },
+            subtitle: { text: this.chartSubtitle || undefined },
+            tooltip: { headerFormat: '', pointFormat: '{point.name}: <b>{point.value}</b>' },
+            plotOptions: {
+                venn: {
+                    cursor: 'pointer',
+                    point: {
+                        events: {
+                            click() {
+                                self.emit('nile-chart-click', {
+                                    point: this,
+                                    value: this.value,
+                                    seriesName: this.series.name,
+                                });
+                            },
+                        },
+                    },
+                },
+            },
+            series: [
+                {
+                    type: 'venn',
+                    name: 'Sets',
+                    data: this.data,
+                },
+            ],
+            credits: { enabled: false },
+        }, this.options);
+    }
+    async initChart() {
+        if (this.loading || !this.chartContainer)
+            return;
+        if (!this._hc)
+            this._hc = await getHighcharts();
+        this.chart = this._hc.chart(this.chartContainer, this.buildOptions());
+        this.emit('nile-chart-ready', { chart: this.chart });
+    }
+    destroyChart() {
+        if (this.chart) {
+            this.chart.destroy();
+            this.chart = null;
+        }
+    }
+    render() {
+        if (this.loading) {
+            return html `<div class="chart-loading" style="height:${this.height}">Loading...</div>`;
+        }
+        return html `<div class="chart-container"></div>`;
+    }
+};
+NileEulerChart.styles = styles;
+__decorate([
+    query('.chart-container')
+], NileEulerChart.prototype, "chartContainer", void 0);
+__decorate([
+    property({ type: Object })
+], NileEulerChart.prototype, "config", void 0);
+__decorate([
+    property({ type: String, attribute: 'chart-title' })
+], NileEulerChart.prototype, "chartTitle", void 0);
+__decorate([
+    property({ type: String, attribute: 'chart-subtitle' })
+], NileEulerChart.prototype, "chartSubtitle", void 0);
+__decorate([
+    property({ type: Array })
+], NileEulerChart.prototype, "data", void 0);
+__decorate([
+    property({ type: Object })
+], NileEulerChart.prototype, "options", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NileEulerChart.prototype, "loading", void 0);
+__decorate([
+    property({ type: String })
+], NileEulerChart.prototype, "height", void 0);
+NileEulerChart = __decorate([
+    customElement('nile-euler-chart')
+], NileEulerChart);
+export { NileEulerChart };
+//# sourceMappingURL=nile-euler-chart.js.map

package/dist/src/nile-fan-chart/index.d.ts

@@ -0,0 +1,2 @@
+export { NileFanChart } from './nile-fan-chart.js';
+export type { FanLinePoint, FanUncertaintyBand } from './nile-fan-chart.js';

package/dist/src/nile-fan-chart/index.js

@@ -0,0 +1,2 @@
+export { NileFanChart } from './nile-fan-chart.js';
+//# sourceMappingURL=index.js.map

package/dist/src/nile-fan-chart/nile-fan-chart.css.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("lit").CSSResult;

package/dist/src/nile-fan-chart/nile-fan-chart.css.js

@@ -0,0 +1,28 @@
+import { css } from 'lit';
+export const styles = css `
+  :host {
+    display: block;
+    width: 100%;
+    position: relative;
+  }
+
+  :host([hidden]) {
+    display: none;
+  }
+
+  .chart-container {
+    width: 100%;
+    min-height: var(--nile-height-200px, var(--ng-height-200px));
+  }
+
+  .chart-loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: inherit;
+    color: var(--nile-colors-neutral-700, var(--ng-colors-text-secondary-700));
+    font-family: var(--nile-font-family-serif, var(--ng-font-family-body));
+    font-size: var(--nile-type-scale-3, var(--ng-font-size-text-sm));
+  }
+`;
+//# sourceMappingURL=nile-fan-chart.css.js.map

package/dist/src/nile-fan-chart/nile-fan-chart.d.ts

@@ -0,0 +1,65 @@
+import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import type Highcharts from 'highcharts';
+import NileElement from '../internal/nile-element.js';
+import type { SeparatedChartConfigInputType } from '../internal/types/separated-chart-config-input.type.js';
+/** Central path (history + median / point forecast). */
+export interface FanLinePoint {
+    category: string;
+    y: number;
+}
+/**
+ * One uncertainty fan layer (`arearange`). List **widest band first** (e.g. 3σ, 2σ, 1σ)
+ * so narrower bands render on top.
+ */
+export interface FanUncertaintyBand {
+    name: string;
+    data: Array<{
+        category: string;
+        low: number;
+        high: number;
+    }>;
+    color?: string;
+    fillOpacity?: number;
+}
+export declare class NileFanChart extends NileElement {
+    static styles: CSSResultGroup;
+    private _hc;
+    private chart;
+    private resizeObserver;
+    private chartContainer;
+    /** Full chart configuration. Accepts separated `{ chart, aq }` input. */
+    config: SeparatedChartConfigInputType | null;
+    chartTitle: string;
+    chartSubtitle: string;
+    lineData: FanLinePoint[];
+    bands: FanUncertaintyBand[];
+    options: Highcharts.Options;
+    loading: boolean;
+    height: string;
+    yAxisTitle: string;
+    lineSeriesName: string;
+    lineColor: string;
+    showLegend: boolean;
+    /**
+     * Index (0-based) of the first **forecast** category on the x-axis.
+     * When ≥ 0, draws a dashed separator and optional plot band.
+     */
+    forecastStartIndex: number;
+    forecastBandLabel: string;
+    /** Apply `{ chart, aq }` config to individual properties. */
+    private applyConfig;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected firstUpdated(): void;
+    protected updated(changedProperties: PropertyValues): void;
+    private setupResizeObserver;
+    private buildOptions;
+    private initChart;
+    private destroyChart;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-fan-chart': NileFanChart;
+    }
+}