@internetstiftelsen/charts 0.5.1 → 0.6.0

package/grouped-data.d.ts

@@ -0,0 +1,19 @@
+import type { ChartData, DataItem, GroupedDataGroup } from './types.js';
+export declare const GROUPED_CATEGORY_ID_KEY = "__iis_grouped_category_id__";
+export declare const GROUPED_CATEGORY_LABEL_KEY = "__iis_grouped_category_label__";
+export declare const GROUPED_GROUP_LABEL_KEY = "__iis_grouped_group_label__";
+export declare const GROUPED_GAP_TICK_PREFIX = "__iis_group_gap__";
+export declare const GROUPED_EMPTY_GROUP_ERROR = "Grouped data requires non-empty group names";
+export type DataSchema = {
+    grouped: boolean;
+    categoryKey: string;
+    metricKeys: string[];
+};
+export type NormalizedChartData = {
+    data: DataItem[];
+    schema: DataSchema;
+};
+export declare function hasEmptyGroupNames(data: GroupedDataGroup[]): boolean;
+export declare function isGroupedData(data: unknown): data is GroupedDataGroup[];
+export declare function resolveDataSchema(data: ChartData): DataSchema;
+export declare function normalizeChartData(data: ChartData): NormalizedChartData;

package/grouped-data.js

@@ -0,0 +1,122 @@
+export const GROUPED_CATEGORY_ID_KEY = '__iis_grouped_category_id__';
+export const GROUPED_CATEGORY_LABEL_KEY = '__iis_grouped_category_label__';
+export const GROUPED_GROUP_LABEL_KEY = '__iis_grouped_group_label__';
+export const GROUPED_GAP_TICK_PREFIX = '__iis_group_gap__';
+export const GROUPED_EMPTY_GROUP_ERROR = 'Grouped data requires non-empty group names';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function hasNonEmptyGroupName(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function hasEmptyGroupNames(data) {
+    return data.some((group) => !hasNonEmptyGroupName(group.group));
+}
+function assertNonEmptyGroupNames(data) {
+    if (hasEmptyGroupNames(data)) {
+        throw new Error(GROUPED_EMPTY_GROUP_ERROR);
+    }
+}
+export function isGroupedData(data) {
+    if (!Array.isArray(data) || data.length === 0) {
+        return false;
+    }
+    return data.every((item) => {
+        if (!isRecord(item) || !Array.isArray(item['data'])) {
+            return false;
+        }
+        return item['data'].every((row) => {
+            return isRecord(row);
+        });
+    });
+}
+function resolveFlatSchema(data) {
+    if (data.length === 0) {
+        return {
+            grouped: false,
+            categoryKey: 'column',
+            metricKeys: [],
+        };
+    }
+    const keys = Object.keys(data[0]);
+    const categoryKey = keys[0] ?? 'column';
+    const metricKeys = [];
+    const seen = new Set();
+    data.forEach((row) => {
+        Object.keys(row).forEach((key) => {
+            if (key === categoryKey || seen.has(key)) {
+                return;
+            }
+            seen.add(key);
+            metricKeys.push(key);
+        });
+    });
+    return {
+        grouped: false,
+        categoryKey,
+        metricKeys,
+    };
+}
+function resolveGroupedSchema(data) {
+    let firstRow = null;
+    for (const group of data) {
+        if (group.data.length > 0) {
+            firstRow = group.data[0];
+            break;
+        }
+    }
+    const categoryKey = firstRow ? Object.keys(firstRow)[0] ?? 'category' : 'category';
+    const metricKeys = [];
+    const seen = new Set();
+    data.forEach((group) => {
+        group.data.forEach((row) => {
+            Object.keys(row).forEach((key) => {
+                if (key === categoryKey || seen.has(key)) {
+                    return;
+                }
+                seen.add(key);
+                metricKeys.push(key);
+            });
+        });
+    });
+    return {
+        grouped: true,
+        categoryKey,
+        metricKeys,
+    };
+}
+export function resolveDataSchema(data) {
+    if (isGroupedData(data)) {
+        return resolveGroupedSchema(data);
+    }
+    return resolveFlatSchema(data);
+}
+function normalizeGroupedData(data) {
+    assertNonEmptyGroupNames(data);
+    const schema = resolveGroupedSchema(data);
+    const categoryKey = schema.categoryKey;
+    const normalizedRows = data.flatMap((group, groupIndex) => {
+        return group.data.map((row, rowIndex) => {
+            const categoryLabel = String(row[categoryKey] ?? '');
+            return {
+                [GROUPED_CATEGORY_ID_KEY]: `g${groupIndex}r${rowIndex}`,
+                [GROUPED_CATEGORY_LABEL_KEY]: categoryLabel,
+                [GROUPED_GROUP_LABEL_KEY]: String(group.group ?? ''),
+                ...row,
+            };
+        });
+    });
+    return {
+        data: normalizedRows,
+        schema,
+    };
+}
+export function normalizeChartData(data) {
+    if (isGroupedData(data)) {
+        return normalizeGroupedData(data);
+    }
+    return {
+        data,
+        schema: resolveFlatSchema(data),
+    };
+}

package/grouped-tabular.d.ts

@@ -0,0 +1,26 @@
+import type { GroupedDataGroup } from './types.js';
+export type GroupedSheetRow = {
+    kind: 'data';
+    values: unknown[];
+};
+export type GroupedSheetModel = {
+    headers: string[];
+    metricKeys: string[];
+    categoryKey: string;
+    rows: GroupedSheetRow[];
+    matrix: unknown[][];
+};
+export type GroupedRebuildResult = {
+    ok: true;
+    data: GroupedDataGroup[];
+} | {
+    ok: false;
+    error: 'FIRST_ROW_BLANK_GROUP';
+};
+export type GroupedTabularData = {
+    columns: string[];
+    rows: string[][];
+};
+export declare function buildGroupedSheetModel(data: GroupedDataGroup[], preferredMetricOrder?: string[]): GroupedSheetModel;
+export declare function rebuildGroupedDataFromSheet(matrix: unknown[][], categoryKey: string, metricKeys: string[]): GroupedRebuildResult;
+export declare function toGroupedTabularData(data: GroupedDataGroup[], preferredMetricOrder?: string[]): GroupedTabularData;

package/grouped-tabular.js

@@ -0,0 +1,149 @@
+import { GROUPED_EMPTY_GROUP_ERROR, hasEmptyGroupNames, resolveDataSchema, } from './grouped-data.js';
+function isBlankValue(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return value.trim() === '';
+    }
+    return false;
+}
+function asString(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    return String(value);
+}
+function rowHasMetricContent(values) {
+    return values.some((value) => !isBlankValue(value));
+}
+function applyMetricOrder(metricKeys, preferredOrder) {
+    if (!preferredOrder || preferredOrder.length === 0) {
+        return metricKeys;
+    }
+    const ordered = [];
+    const seen = new Set();
+    preferredOrder.forEach((key) => {
+        if (metricKeys.includes(key) && !seen.has(key)) {
+            seen.add(key);
+            ordered.push(key);
+        }
+    });
+    metricKeys.forEach((key) => {
+        if (!seen.has(key)) {
+            seen.add(key);
+            ordered.push(key);
+        }
+    });
+    return ordered;
+}
+export function buildGroupedSheetModel(data, preferredMetricOrder) {
+    if (hasEmptyGroupNames(data)) {
+        throw new Error(GROUPED_EMPTY_GROUP_ERROR);
+    }
+    const schema = resolveDataSchema(data);
+    const metricKeys = applyMetricOrder(schema.metricKeys, preferredMetricOrder);
+    const categoryKey = schema.categoryKey;
+    const headers = ['', '', ...metricKeys];
+    const rows = [];
+    data.forEach((group) => {
+        group.data.forEach((row, rowIndex) => {
+            const values = [
+                rowIndex === 0 ? group.group : '',
+                row[categoryKey] ?? '',
+                ...metricKeys.map((metricKey) => row[metricKey] ?? ''),
+            ];
+            rows.push({
+                kind: 'data',
+                values,
+            });
+        });
+    });
+    return {
+        headers,
+        metricKeys,
+        categoryKey,
+        rows,
+        matrix: rows.map((row) => row.values),
+    };
+}
+export function rebuildGroupedDataFromSheet(matrix, categoryKey, metricKeys) {
+    const groups = [];
+    let currentGroup = '';
+    matrix.forEach((row) => {
+        const groupCell = row[0];
+        const categoryCell = row[1];
+        const metricCells = metricKeys.map((_, index) => row[index + 2]);
+        const hasCategory = !isBlankValue(categoryCell);
+        const hasMetrics = rowHasMetricContent(metricCells);
+        const hasGroup = !isBlankValue(groupCell);
+        if (!hasCategory && !hasMetrics) {
+            return;
+        }
+        if (hasGroup) {
+            currentGroup = asString(groupCell);
+        }
+        else if (!currentGroup) {
+            groups.length = 0;
+            return;
+        }
+        const groupName = currentGroup;
+        if (!groupName) {
+            return;
+        }
+        let targetGroup = groups[groups.length - 1];
+        if (!targetGroup || targetGroup.group !== groupName) {
+            targetGroup = {
+                group: groupName,
+                data: [],
+            };
+            groups.push(targetGroup);
+        }
+        const rebuiltRow = {
+            [categoryKey]: categoryCell ?? '',
+        };
+        metricKeys.forEach((metricKey, index) => {
+            rebuiltRow[metricKey] = metricCells[index] ?? '';
+        });
+        targetGroup.data.push(rebuiltRow);
+    });
+    const firstDataRow = matrix.find((row) => {
+        const categoryCell = row[1];
+        const metricCells = metricKeys.map((_, index) => row[index + 2]);
+        return !isBlankValue(categoryCell) || rowHasMetricContent(metricCells);
+    });
+    if (firstDataRow && isBlankValue(firstDataRow[0])) {
+        return {
+            ok: false,
+            error: 'FIRST_ROW_BLANK_GROUP',
+        };
+    }
+    return {
+        ok: true,
+        data: groups,
+    };
+}
+function normalizeTableValue(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+export function toGroupedTabularData(data, preferredMetricOrder) {
+    const model = buildGroupedSheetModel(data, preferredMetricOrder);
+    return {
+        columns: model.headers,
+        rows: model.matrix.map((row) => row.map((value) => normalizeTableValue(value))),
+    };
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.5.1",
+    "version": "0.6.0",
     "name": "@internetstiftelsen/charts",
     "type": "module",
     "sideEffects": false,

package/pie-chart.d.ts

@@ -0,0 +1,80 @@
+import type { DataItem } from './types.js';
+import { BaseChart, type BaseChartConfig } from './base-chart.js';
+import type { ChartComponent, LayoutAwareComponent } from './chart-interface.js';
+export type PieSort = 'none' | 'ascending' | 'descending' | ((a: PieSegmentData, b: PieSegmentData) => number);
+export type PieConfig = {
+    innerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    padAngle?: number;
+    cornerRadius?: number;
+    sort?: PieSort;
+};
+export type PieValueLabelPosition = 'inside' | 'outside' | 'auto';
+export type PieValueLabelConfig = {
+    show?: boolean;
+    position?: PieValueLabelPosition;
+    minInsidePercentage?: number;
+    outsideOffset?: number;
+    insideMargin?: number;
+    minVerticalSpacing?: number;
+};
+export type PieLabelsConfig = {
+    show?: boolean;
+    mode?: 'adaptive' | 'inside' | 'outside';
+    minInsidePercentage?: number;
+    outsideOffset?: number;
+    minVerticalSpacing?: number;
+};
+export type PieChartConfig = BaseChartConfig & {
+    pie?: PieConfig;
+    valueLabel?: PieValueLabelConfig;
+    /** @deprecated Use valueLabel instead */
+    labels?: PieLabelsConfig;
+    valueKey?: string;
+    labelKey?: string;
+};
+type PieSegmentData = {
+    label: string;
+    value: number;
+    color: string;
+    source: DataItem;
+};
+export declare class PieChart extends BaseChart {
+    private readonly innerRadiusRatio;
+    private readonly startAngle;
+    private readonly endAngle;
+    private readonly padAngle;
+    private readonly cornerRadius;
+    private readonly sort;
+    private readonly valueKey;
+    private readonly labelKey;
+    private readonly valueLabel;
+    private segments;
+    constructor(config: PieChartConfig);
+    private validatePieData;
+    private prepareSegments;
+    private warnOnTinySlices;
+    addChild(component: ChartComponent): this;
+    protected getExportComponents(): ChartComponent[];
+    update(data: DataItem[]): void;
+    protected getLayoutComponents(): LayoutAwareComponent[];
+    protected createExportChart(): BaseChart;
+    protected renderChart(): void;
+    private resolveFontScale;
+    private resolveSortComparator;
+    private renderSegments;
+    private handleSegmentKeyNavigation;
+    private getRenderedSegments;
+    private buildAriaLabel;
+    private positionTooltip;
+    private positionTooltipAtElement;
+    private buildTooltipContent;
+    private getArcPoint;
+    private renderLabels;
+    private resolveValueLabelPlacement;
+    private canFitInsideLabel;
+    private resolveOutsideLabel;
+    private adjustOutsideLabelPositions;
+}
+export {};