@trebco/treb 36.1.4 → 37.0.1

package/build/treb-charts/src/chart-types.d.ts

@@ -0,0 +1,233 @@
+import type { RangeScale } from 'treb-utils';
+import type { Area } from './rectangle';
+import type { UnitAddress } from 'treb-parser';
+import { type ArrayUnion, type CellValue, type ExtendedUnion, type UnionValue } from 'treb-base-types';
+export interface ReferenceMetadata {
+    type: 'metadata';
+    address: UnitAddress;
+    value: CellValue;
+    format?: string;
+}
+export interface ReferenceSeries extends ExtendedUnion {
+    key: 'series';
+    value: {
+        label?: string;
+        x?: UnionValue;
+        y?: UnionValue;
+        z?: UnionValue;
+        index?: number;
+        subtype?: string;
+        data_labels?: string[];
+        axis?: number;
+    };
+}
+export declare const IsMetadata: (value?: unknown) => value is ExtendedUnion & {
+    value: ReferenceMetadata;
+};
+export declare const IsSeries: (value?: unknown) => value is ReferenceSeries;
+export declare const IsArrayUnion: (value?: unknown) => value is ArrayUnion;
+export type NumberOrUndefinedArray = Array<number | undefined>;
+export interface AxisOptions {
+    /** show labels */
+    labels?: boolean;
+    /** label number format */
+    format?: string;
+    /** tickmarks, only on x-axis (atm) */
+    ticks?: boolean;
+}
+export interface CalloutType {
+    value: number;
+    label?: string;
+}
+export interface CellData {
+    address: {
+        row: number;
+        column: number;
+    };
+    value?: unknown;
+    format?: string;
+}
+export interface DonutSlice {
+    index: number;
+    value: number;
+    percent: number;
+    label?: string;
+    title?: string;
+}
+/** common to all chart data types */
+export interface ChartDataBaseType {
+    title?: string;
+    legend?: Array<{
+        label: string;
+        index?: number;
+    }>;
+    legend_position?: LegendPosition;
+    legend_style?: LegendStyle;
+    title_layout?: 'top' | 'bottom';
+    lines?: boolean;
+    filled?: boolean;
+    markers?: boolean;
+    smooth?: boolean;
+    data_labels?: boolean;
+    class_name?: string;
+    /** different marker type for scatter plot */
+    points?: boolean;
+}
+/** default, empty chart (you can still add a title, I suppose) */
+export interface NullChartData extends ChartDataBaseType {
+    type: 'null';
+}
+/** scatter plot (only used for correlation, atm) */
+export interface ScatterData extends ChartDataBaseType {
+    type: 'scatter';
+    x: number[];
+    y: number[];
+    count: number;
+}
+/** scatter plot used for line charting */
+export interface ScatterData2 extends ChartDataBaseType {
+    type: 'scatter2';
+    series?: SeriesType[];
+    x_scale: RangeScale;
+    y_scale: RangeScale;
+    y2_scale?: RangeScale;
+    x_labels?: string[];
+    y_labels?: string[];
+    y2_labels?: string[];
+    style?: 'plot' | 'line' | 'area';
+}
+export interface BubbleChartData extends ChartDataBaseType {
+    type: 'bubble';
+    series: SeriesType[];
+    x_scale: RangeScale;
+    y_scale: RangeScale;
+    x_labels?: string[];
+    y_labels?: string[];
+}
+/** base for column types (FIXME: probably common to scatter/line/area also) */
+export interface ColumnDataBaseType extends ChartDataBaseType {
+    column_width: number;
+    x_labels?: string[];
+    y_labels?: string[];
+}
+/** histogram */
+export interface HistogramData extends ColumnDataBaseType {
+    type: 'histogram';
+    bins: number[];
+    min: number;
+    max: number;
+    count: number;
+    scale: RangeScale;
+    titles?: string[];
+}
+export interface LineBaseData extends ChartDataBaseType {
+    series?: NumberOrUndefinedArray[];
+    series2?: SeriesType[];
+    stacked_series?: SeriesType[];
+    scale: RangeScale;
+    x_scale?: RangeScale;
+    titles?: string[];
+    x_labels?: string[];
+    y_labels?: string[];
+    callouts?: CalloutType[];
+    smooth?: boolean;
+}
+export interface BoxPlotData extends ChartDataBaseType {
+    type: 'box';
+    series: SeriesType[];
+    x_labels?: string[];
+    series_names?: string[];
+    y_labels?: string[];
+    scale: RangeScale;
+    max_n: number;
+    data: {
+        data: number[];
+        quartiles: [number, number, number];
+        whiskers: [number, number];
+        iqr: number;
+        n: number;
+        min: number;
+        max: number;
+        mean: number;
+    }[];
+}
+export interface LineData extends LineBaseData {
+    type: 'line';
+}
+export interface AreaData extends LineBaseData {
+    type: 'area';
+}
+export interface ColumnData extends LineBaseData {
+    type: 'column';
+    round?: boolean;
+    space?: number;
+}
+export interface HistogramData2 extends LineBaseData {
+    type: 'histogram2';
+    round?: boolean;
+    space?: number;
+}
+export interface BarData extends LineBaseData {
+    type: 'bar';
+    round?: boolean;
+    space?: number;
+    stacked?: boolean;
+}
+export interface DonutDataBaseType extends ChartDataBaseType {
+    slices: DonutSlice[];
+}
+/** donut (FIXME: common type for pie, donut) */
+export interface DonutChartData extends DonutDataBaseType {
+    type: 'donut';
+}
+/** pie (FIXME: common type for pie, donut) */
+export interface PieChartData extends DonutDataBaseType {
+    type: 'pie';
+}
+/** union type */
+export type ChartData = NullChartData | DonutChartData | HistogramData | HistogramData2 | PieChartData | ScatterData | ScatterData2 | LineData | AreaData | ColumnData | BarData | BubbleChartData | BoxPlotData;
+export declare enum LegendLayout {
+    horizontal = 0,
+    vertical = 1
+}
+export declare enum LegendPosition {
+    top = 0,
+    bottom = 1,
+    left = 2,
+    right = 3
+}
+export declare enum LegendStyle {
+    line = 0,
+    marker = 1,
+    bubble = 2
+}
+export interface LegendOptions {
+    labels: Array<{
+        label: string;
+        index?: number;
+    }>;
+    layout?: LegendLayout;
+    position?: LegendPosition;
+    style?: LegendStyle;
+    area: Area;
+}
+export interface SubSeries {
+    data: Array<number | undefined>;
+    format?: string;
+    range?: {
+        min: number;
+        max: number;
+    };
+    labels?: Array<string | undefined>;
+}
+export interface SeriesType {
+    label?: string;
+    subtype?: string;
+    x: SubSeries;
+    y: SubSeries;
+    y2?: SubSeries;
+    z?: SubSeries;
+    index?: number;
+    labels?: string[];
+    axis?: number;
+}

package/build/treb-charts/src/chart-types.js

@@ -0,0 +1,57 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+import { ValueType } from 'treb-base-types';
+export const IsMetadata = (value) => {
+    return (!!value && (typeof value === 'object')
+        && value.key === 'metadata'
+        && !!value.value
+        && value.value.type === 'metadata');
+};
+export const IsSeries = (value) => {
+    return (!!value && (typeof value === 'object')
+        && value.key === 'series'
+        // && Array.isArray((value as ReferenceSeries).value));
+        && (typeof value.value === 'object'));
+};
+export const IsArrayUnion = (value) => {
+    return (!!value && (typeof value === 'object')
+        && value.type === ValueType.array
+        && Array.isArray(value.value));
+};
+export var LegendLayout;
+(function (LegendLayout) {
+    LegendLayout[LegendLayout["horizontal"] = 0] = "horizontal";
+    LegendLayout[LegendLayout["vertical"] = 1] = "vertical";
+})(LegendLayout || (LegendLayout = {}));
+export var LegendPosition;
+(function (LegendPosition) {
+    LegendPosition[LegendPosition["top"] = 0] = "top";
+    LegendPosition[LegendPosition["bottom"] = 1] = "bottom";
+    LegendPosition[LegendPosition["left"] = 2] = "left";
+    LegendPosition[LegendPosition["right"] = 3] = "right";
+})(LegendPosition || (LegendPosition = {}));
+export var LegendStyle;
+(function (LegendStyle) {
+    LegendStyle[LegendStyle["line"] = 0] = "line";
+    LegendStyle[LegendStyle["marker"] = 1] = "marker";
+    LegendStyle[LegendStyle["bubble"] = 2] = "bubble";
+})(LegendStyle || (LegendStyle = {}));
+//# sourceMappingURL=chart-types.js.map

package/build/treb-charts/src/chart-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-types.js","sourceRoot":"","sources":["../../../treb-charts/src/chart-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,EAAE,SAAS,EAAwE,MAAM,iBAAiB,CAAC;AAoClH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAe,EAAyD,EAAE;IACnG,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;WACxC,KAAuB,CAAC,GAAG,KAAK,UAAU;WAC3C,CAAC,CAAE,KAAuB,CAAC,KAAK;WAC/B,KAAqC,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;AACzE,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAe,EAA4B,EAAE;IACpE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;WACxC,KAAyB,CAAC,GAAG,KAAK,QAAQ;QAC9C,uDAAuD;WACpD,CAAC,OAAQ,KAAyB,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC;AAC/D,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAe,EAAuB,EAAE;IACnE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;WACxC,KAAoB,CAAC,IAAI,KAAK,SAAS,CAAC,KAAK;WAC9C,KAAK,CAAC,OAAO,CAAE,KAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;AACnD,CAAC,CAAC;AA6NF,MAAM,CAAN,IAAY,YAEX;AAFD,WAAY,YAAY;IACtB,2DAAU,CAAA;IAAE,uDAAQ,CAAA;AACtB,CAAC,EAFW,YAAY,KAAZ,YAAY,QAEvB;AAED,MAAM,CAAN,IAAY,cAEX;AAFD,WAAY,cAAc;IACxB,iDAAG,CAAA;IAAE,uDAAM,CAAA;IAAE,mDAAI,CAAA;IAAE,qDAAK,CAAA;AAC1B,CAAC,EAFW,cAAc,KAAd,cAAc,QAEzB;AAED,MAAM,CAAN,IAAY,WAEX;AAFD,WAAY,WAAW;IACrB,6CAAI,CAAA;IAAE,iDAAM,CAAA;IAAE,iDAAM,CAAA;AACtB,CAAC,EAFW,WAAW,KAAX,WAAW,QAEtB"}

package/build/treb-charts/src/chart-utils.d.ts

@@ -0,0 +1,106 @@
+import { type UnionValue, type ArrayUnion } from 'treb-base-types';
+import type { SeriesType, ChartData } from './chart-types';
+import type { ReferenceSeries } from './chart-types';
+import type { RangeScale } from 'treb-utils';
+export declare const ArrayMinMax: (data: number[]) => {
+    min: number;
+    max: number;
+};
+export declare const ReadSeries: (data: ReferenceSeries["value"]) => SeriesType;
+export declare const ArrayToSeries: (array_data: ArrayUnion) => SeriesType;
+/**
+ * composite data -> series. composite data can be
+ *
+ * (1) set of Y values, with X not provided;
+ * (2) SERIES(label, X, Y) with Y required, others optional
+ * (3) GROUP(a, b, ...), where entries are either arrays as (1) or SERIES as (2)
+ *
+ * FIXME: consider supporting GROUP(SERIES, [y], ...)
+ *
+ * NOTE: (1) could be an array of boxed (union) values...
+ *
+ */
+export declare const TransformSeriesData: (raw_data?: UnionValue, default_x?: UnionValue) => SeriesType[];
+/** get a unified scale, and formats */
+export declare const CommonData: (series: SeriesType[], y_floor?: number, y_ceiling?: number, x_floor?: number, x_ceiling?: number, auto_number_format?: boolean) => {
+    legend?: {
+        label: string;
+        index?: number;
+    }[];
+    x: {
+        format: string;
+        scale: RangeScale;
+        labels?: string[];
+    };
+    y: {
+        format: string;
+        scale: RangeScale;
+        labels?: string[];
+    };
+    y2?: {
+        format: string;
+        scale: RangeScale;
+        labels?: string[];
+    };
+};
+/**
+ * return quartiles. we use the Tukey hinge-style. See
+ *
+ * https://en.wikipedia.org/wiki/Quartile
+ *
+ * Specifically,
+ *
+ * - Use the median to divide the ordered data set into two halves. The median
+ *   becomes the second quartiles.
+ *
+ *   - If there are an odd number of data points in the original ordered data
+ *     set, include the median (the central value in the ordered list) in both
+ *     halves.
+ *
+ *   - If there are an even number of data points in the original ordered data
+ *     set, split this data set exactly in half.
+ *
+ * - The lower quartile value is the median of the lower half of the data. The
+ *   upper quartile value is the median of the upper half of the data.
+ *
+ * @param data - must be sorted with no holes
+ */
+export declare const BoxStats: (data: number[]) => {
+    data: number[];
+    quartiles: [number, number, number];
+    whiskers: [number, number];
+    iqr: number;
+    n: number;
+    mean: number;
+    min: number;
+    max: number;
+};
+export declare const CreateBoxPlot: (args: UnionValue[]) => ChartData;
+export declare const CreateBubbleChart: (args: UnionValue[]) => ChartData;
+/**
+ * args is [data, title, options]
+ *
+ * args[0] is the scatter data. this can be
+ *
+ * (1) set of Y values, with X not provided;
+ * (2) SERIES(label, X, Y) with Y required, others optional
+ * (3) GROUP(SERIES(label, X, Y), SERIES(label, X, Y), ...), with same rule for each series
+ *
+ * @param args
+ */
+export declare const CreateScatterChart: (args: [UnionValue, string, string], style?: "plot" | "line") => ChartData;
+/**
+ * column/bar chart, now using common Series data and routines
+ *
+ * @param args arguments: data, categories, title, options
+ * @param type
+ */
+export declare const CreateColumnChart: (args: [UnionValue?, UnionValue?, string?, string?], type: "bar" | "column") => ChartData;
+/**
+ * args: data, labels, title, callouts, "smooth"
+ */
+export declare const CreateLineChart: (args: [UnionValue, UnionValue, string, string], type: "line" | "area") => ChartData;
+/**
+ * arguments are values, labels, title, sort, label option, ...
+ */
+export declare const CreateDonut: (args: [UnionValue?, UnionValue?, string?, string?, string?], pie_chart?: boolean) => ChartData;