@tolle_/tolle-ui 18.3.0 → 18.3.1

package/esm2022/lib/bar-list.component.mjs

@@ -0,0 +1,95 @@
+import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * A ranked list of horizontal bars — label left, value right, bar width
+ * scaled to each row's share of the list's largest value. Unlike a chart
+ * series or a category bar's segments, every bar is the same accent: rank is
+ * carried by length, not by a categorical palette.
+ * @new
+ */
+export class BarListComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex = (index) => index;
+    /** Rows to rank, in the order they should be drawn. @default [] */
+    data = [];
+    /** Row key holding each row's label. @default 'label' */
+    labelKey = 'label';
+    /** Row key holding each row's numeric value. @default 'value' */
+    valueKey = 'value';
+    /** Extra Tailwind classes merged onto the list via `cn()` (last-wins). */
+    class = '';
+    cdr = inject(ChangeDetectorRef);
+    get rows() {
+        const rows = this.data ?? [];
+        const values = rows.map((row) => {
+            const num = Number(row?.[this.valueKey]);
+            return Number.isFinite(num) ? num : 0;
+        });
+        const max = values.reduce((m, v) => Math.max(m, v), 0);
+        return rows.map((row, i) => {
+            const raw = row?.[this.labelKey];
+            const value = values[i];
+            return {
+                label: raw == null ? '' : String(raw),
+                value,
+                percent: max > 0 ? Math.max(0, Math.min(100, (value / max) * 100)) : 0,
+                formattedValue: value.toLocaleString('en-US'),
+            };
+        });
+    }
+    get computedClass() {
+        return cn('flex w-full flex-col gap-1', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BarListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BarListComponent, isStandalone: true, selector: "tolle-bar-list", inputs: { data: "data", labelKey: "labelKey", valueKey: "valueKey", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div
+        *ngFor="let row of rows; trackBy: trackByIndex"
+        class="relative flex items-center overflow-hidden rounded-sm"
+      >
+        <div class="absolute inset-y-0 left-0 rounded-sm bg-primary/15" [style.width.%]="row.percent"></div>
+        <span class="relative z-10 truncate px-2 py-1.5 text-sm text-foreground">{{ row.label }}</span>
+        <span class="relative z-10 ml-auto shrink-0 px-2 py-1.5 text-sm font-medium tabular-nums text-foreground">
+          {{ row.formattedValue }}
+        </span>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BarListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-bar-list', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div
+        *ngFor="let row of rows; trackBy: trackByIndex"
+        class="relative flex items-center overflow-hidden rounded-sm"
+      >
+        <div class="absolute inset-y-0 left-0 rounded-sm bg-primary/15" [style.width.%]="row.percent"></div>
+        <span class="relative z-10 truncate px-2 py-1.5 text-sm text-foreground">{{ row.label }}</span>
+        <span class="relative z-10 ml-auto shrink-0 px-2 py-1.5 text-sm font-medium tabular-nums text-foreground">
+          {{ row.formattedValue }}
+        </span>
+      </div>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], labelKey: [{
+                type: Input
+            }], valueKey: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/category-bar.component.mjs

@@ -0,0 +1,130 @@
+import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * A single bar split into proportional, labelled ranges — for showing where
+ * one value falls against a scale made of categories (a credit score inside
+ * "Poor / Fair / Good / Excellent", latency inside "Fast / OK / Slow").
+ *
+ * Segments take the chart palette by position, since a category bar has no
+ * stable per-render identity to key colour off the way a chart series does —
+ * pass `colors` to override.
+ * @new
+ */
+export class CategoryBarComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */
+    trackByIndex = (index) => index;
+    /** Width of each segment. Values that are not finite and greater than zero are dropped. @default [] */
+    values = [];
+    /** Name for each segment, used in the accessible summary and as a title tooltip. @default [] */
+    labels = [];
+    /** Paint for each segment, by index. Falls back to the chart palette --chart-1 through --chart-5. @default [] */
+    colors = [];
+    /** Position of the pointer, 0-100 on the same scale the segments sum to. Omit to draw no pointer. @default null */
+    markerValue = null;
+    /** Accessible name, prefixed onto the sr-only summary of segments and marker. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the bar via `cn()` (last-wins). */
+    class = '';
+    cdr = inject(ChangeDetectorRef);
+    get total() {
+        return this.values.reduce((sum, v) => (Number.isFinite(v) && v > 0 ? sum + v : sum), 0);
+    }
+    get segments() {
+        const total = this.total;
+        if (total <= 0)
+            return [];
+        return this.values
+            .map((value, i) => ({ value, i }))
+            .filter(({ value }) => Number.isFinite(value) && value > 0)
+            .map(({ value, i }) => ({
+            label: this.labels[i] ?? '',
+            value,
+            percent: (value / total) * 100,
+            color: this.colors[i] || 'rgb(var(--chart-' + ((i % 5) + 1) + '))',
+        }));
+    }
+    get clampedMarker() {
+        if (this.markerValue == null || !Number.isFinite(this.markerValue))
+            return null;
+        return Math.min(100, Math.max(0, this.markerValue));
+    }
+    get summary() {
+        const parts = this.segments.map((s) => (s.label ? s.label + ': ' : '') + s.percent.toFixed(0) + '%');
+        const marker = this.clampedMarker !== null ? ', current position ' + this.clampedMarker.toFixed(0) + '%' : '';
+        const prefix = this.ariaLabel ? this.ariaLabel + '. ' : '';
+        return prefix + parts.join(', ') + marker;
+    }
+    get computedClass() {
+        return cn('w-full', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CategoryBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CategoryBarComponent, isStandalone: true, selector: "tolle-category-bar", inputs: { values: "values", labels: "labels", colors: "colors", markerValue: "markerValue", ariaLabel: "ariaLabel", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div class="relative flex w-full gap-0.5">
+        <div
+          *ngFor="let segment of segments; let i = index; trackBy: trackByIndex"
+          class="h-2 first:rounded-l-full last:rounded-r-full"
+          [style.width.%]="segment.percent"
+          [style.background]="segment.color"
+          [attr.title]="segment.label || null"
+        ></div>
+
+        <span
+          *ngIf="clampedMarker !== null"
+          class="absolute top-1/2 h-3 w-3 -translate-x-1/2 -translate-y-1/2 rounded-full border-2 border-background bg-foreground shadow"
+          [style.left.%]="clampedMarker"
+        ></span>
+      </div>
+
+      <p class="sr-only">{{ summary }}</p>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CategoryBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-category-bar', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div class="relative flex w-full gap-0.5">
+        <div
+          *ngFor="let segment of segments; let i = index; trackBy: trackByIndex"
+          class="h-2 first:rounded-l-full last:rounded-r-full"
+          [style.width.%]="segment.percent"
+          [style.background]="segment.color"
+          [attr.title]="segment.label || null"
+        ></div>
+
+        <span
+          *ngIf="clampedMarker !== null"
+          class="absolute top-1/2 h-3 w-3 -translate-x-1/2 -translate-y-1/2 rounded-full border-2 border-background bg-foreground shadow"
+          [style.left.%]="clampedMarker"
+        ></span>
+      </div>
+
+      <p class="sr-only">{{ summary }}</p>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { values: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], colors: [{
+                type: Input
+            }], markerValue: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-bar.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/category-bar.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, OnChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cn } from './utils/cn';\n\n/** One resolved segment: its share of the bar's width, its paint, and the numbers behind it. */\nexport interface CategoryBarSegment {\n  label: string;\n  value: number;\n  percent: number;\n  color: string;\n}\n\n/**\n * A single bar split into proportional, labelled ranges — for showing where\n * one value falls against a scale made of categories (a credit score inside\n * \"Poor / Fair / Good / Excellent\", latency inside \"Fast / OK / Slow\").\n *\n * Segments take the chart palette by position, since a category bar has no\n * stable per-render identity to key colour off the way a chart series does —\n * pass `colors` to override.\n * @new\n */\n@Component({\n  selector: 'tolle-category-bar',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <div class=\"relative flex w-full gap-0.5\">\n        <div\n          *ngFor=\"let segment of segments; let i = index; trackBy: trackByIndex\"\n          class=\"h-2 first:rounded-l-full last:rounded-r-full\"\n          [style.width.%]=\"segment.percent\"\n          [style.background]=\"segment.color\"\n          [attr.title]=\"segment.label || null\"\n        ></div>\n\n        <span\n          *ngIf=\"clampedMarker !== null\"\n          class=\"absolute top-1/2 h-3 w-3 -translate-x-1/2 -translate-y-1/2 rounded-full border-2 border-background bg-foreground shadow\"\n          [style.left.%]=\"clampedMarker\"\n        ></span>\n      </div>\n\n      <p class=\"sr-only\">{{ summary }}</p>\n    </div>\n  `,\n})\nexport class CategoryBarComponent implements OnChanges {\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Identity for `*ngFor`, so a redraw patches nodes instead of replacing them. */\n  trackByIndex = (index: number): number => index;\n\n  /** Width of each segment. Values that are not finite and greater than zero are dropped. @default [] */\n  @Input() values: number[] = [];\n  /** Name for each segment, used in the accessible summary and as a title tooltip. @default [] */\n  @Input() labels: string[] = [];\n  /** Paint for each segment, by index. Falls back to the chart palette --chart-1 through --chart-5. @default [] */\n  @Input() colors: string[] = [];\n  /** Position of the pointer, 0-100 on the same scale the segments sum to. Omit to draw no pointer. @default null */\n  @Input() markerValue: number | null = null;\n  /** Accessible name, prefixed onto the sr-only summary of segments and marker. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the bar via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  private get total(): number {\n    return this.values.reduce((sum, v) => (Number.isFinite(v) && v > 0 ? sum + v : sum), 0);\n  }\n\n  get segments(): CategoryBarSegment[] {\n    const total = this.total;\n    if (total <= 0) return [];\n\n    return this.values\n      .map((value, i) => ({ value, i }))\n      .filter(({ value }) => Number.isFinite(value) && value > 0)\n      .map(({ value, i }) => ({\n        label: this.labels[i] ?? '',\n        value,\n        percent: (value / total) * 100,\n        color: this.colors[i] || 'rgb(var(--chart-' + ((i % 5) + 1) + '))',\n      }));\n  }\n\n  get clampedMarker(): number | null {\n    if (this.markerValue == null || !Number.isFinite(this.markerValue)) return null;\n    return Math.min(100, Math.max(0, this.markerValue));\n  }\n\n  get summary(): string {\n    const parts = this.segments.map((s) => (s.label ? s.label + ': ' : '') + s.percent.toFixed(0) + '%');\n    const marker = this.clampedMarker !== null ? ', current position ' + this.clampedMarker.toFixed(0) + '%' : '';\n    const prefix = this.ariaLabel ? this.ariaLabel + '. ' : '';\n    return prefix + parts.join(', ') + marker;\n  }\n\n  get computedClass() {\n    return cn('w-full', this.class);\n  }\n}\n"]}

package/esm2022/lib/chart-spark.component.mjs

@@ -0,0 +1,120 @@
+import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ChartComponent, ChartLineComponent, ChartAreaComponent, ChartBarComponent, } from './chart.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * A minimal inline chart: one series, no grid, no axes, no legend — sized to
+ * sit next to a number in a table cell or a stat card. A thin composition
+ * over `tolle-chart`; it draws nothing of its own and inherits `--chart-1`
+ * the same way any other single-series chart in this library does.
+ * @new
+ */
+export class ChartSparkComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Rows to plot, in x order. @default [] */
+    data = [];
+    /** Row key holding each row's numeric value. @default 'value' */
+    valueKey = 'value';
+    /** Row key holding each row's x position. Only matters once `hover` is on. @default '' */
+    xKey = '';
+    /** Which mark to draw. @default 'line' */
+    type = 'line';
+    /** Interpolation for line/area. @default 'linear' */
+    curve = 'linear';
+    /** Largest bar thickness in px, used when `type` is 'bar'. @default 6 */
+    maxBarWidth = 6;
+    /** Height in px. @default 32 */
+    height = 32;
+    /** Renders the crosshair, hit layer and tooltip. @default false */
+    hover = false;
+    /** Shows the data table instead of leaving it visually hidden. @default false */
+    showTable = false;
+    /** Accessible name, used as the svg <title>. @default '' */
+    ariaLabel = '';
+    /** Longer summary used as the svg <desc>. Falls back to `ariaLabel`. @default '' */
+    description = '';
+    /** Space reserved around the plot — a sparkline has no axis labels to fit. @default { top: 2, right: 2, bottom: 2, left: 2 } */
+    margin = { top: 2, right: 2, bottom: 2, left: 2 };
+    /** Extra Tailwind classes merged onto the chart via `cn()` (last-wins). */
+    class = '';
+    cdr = inject(ChangeDetectorRef);
+    /** Always exactly one series, reading `valueKey` off each row. */
+    get series() {
+        return [{ key: this.valueKey, label: this.ariaLabel || this.valueKey }];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartSparkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartSparkComponent, isStandalone: true, selector: "tolle-chart-spark", inputs: { data: "data", valueKey: "valueKey", xKey: "xKey", type: "type", curve: "curve", maxBarWidth: "maxBarWidth", height: "height", hover: "hover", showTable: "showTable", ariaLabel: "ariaLabel", description: "description", margin: "margin", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <tolle-chart
+      [class]="class"
+      [data]="data"
+      [series]="series"
+      [xKey]="xKey"
+      [height]="height"
+      [margin]="margin"
+      [hover]="hover"
+      [showTable]="showTable"
+      [ariaLabel]="ariaLabel"
+      [description]="description"
+    >
+      <svg:g *ngIf="type === 'line'" tolle-chart-line [seriesKey]="valueKey" [curve]="curve"></svg:g>
+      <svg:g *ngIf="type === 'area'" tolle-chart-area [seriesKey]="valueKey" [curve]="curve"></svg:g>
+      <svg:g *ngIf="type === 'bar'" tolle-chart-bar [seriesKey]="valueKey" [maxWidth]="maxBarWidth"></svg:g>
+    </tolle-chart>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: ChartComponent, selector: "tolle-chart", inputs: ["data", "series", "xKey", "height", "margin", "ariaLabel", "description", "stacked", "orientation", "hover", "showTable", "xHeader", "variant", "density", "class"], outputs: ["activeIndexChange"] }, { kind: "component", type: ChartLineComponent, selector: "svg:g[tolle-chart-line]", inputs: ["seriesKey", "curve", "showDots", "dotRadius", "class"] }, { kind: "component", type: ChartAreaComponent, selector: "svg:g[tolle-chart-area]", inputs: ["seriesKey", "curve", "fillOpacity", "class"] }, { kind: "component", type: ChartBarComponent, selector: "svg:g[tolle-chart-bar]", inputs: ["seriesKey", "radius", "maxWidth", "gap", "class"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartSparkComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chart-spark', standalone: true, imports: [CommonModule, ChartComponent, ChartLineComponent, ChartAreaComponent, ChartBarComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <tolle-chart
+      [class]="class"
+      [data]="data"
+      [series]="series"
+      [xKey]="xKey"
+      [height]="height"
+      [margin]="margin"
+      [hover]="hover"
+      [showTable]="showTable"
+      [ariaLabel]="ariaLabel"
+      [description]="description"
+    >
+      <svg:g *ngIf="type === 'line'" tolle-chart-line [seriesKey]="valueKey" [curve]="curve"></svg:g>
+      <svg:g *ngIf="type === 'area'" tolle-chart-area [seriesKey]="valueKey" [curve]="curve"></svg:g>
+      <svg:g *ngIf="type === 'bar'" tolle-chart-bar [seriesKey]="valueKey" [maxWidth]="maxBarWidth"></svg:g>
+    </tolle-chart>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], valueKey: [{
+                type: Input
+            }], xKey: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], curve: [{
+                type: Input
+            }], maxBarWidth: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hover: [{
+                type: Input
+            }], showTable: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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