@dou-ui/pivot 0.0.0-stage → 0.1.0-alpha.0

package/dist/types/engine/types.d.ts

@@ -0,0 +1,148 @@
+import type { PivotGroupBy } from './group';
+/** What a field holds; it decides how values are grouped, sorted and shown. */
+export type PivotFieldType = 'string' | 'number' | 'date' | 'boolean';
+/**
+ * How a value or a group label is written: options for `Intl.NumberFormat`
+ * (numbers) or `Intl.DateTimeFormat` (dates), or a function.
+ */
+export type PivotFormat = Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | ((value: any) => string);
+/** A field of the records: something to group by, or to sum up. */
+export interface PivotField<Row = Record<string, unknown>> {
+    /** The key on each record, and how the config refers to the field. */
+    name: string;
+    /** The name in headers and the field list; `name` when left out. */
+    label?: string;
+    /** Guessed from the first records when left out. */
+    type?: PivotFieldType;
+    /** Reads the field from a record, for fields that are worked out per record. */
+    value?: (row: Row, index: number) => unknown;
+    /** How the field's group labels, or the values summed up from it, are written. */
+    format?: PivotFormat;
+    /** Groups in this order come first, in this order; the rest follow, sorted. */
+    order?: readonly unknown[];
+}
+/** A field on the row or column axis: its name, or the name with options. */
+export type PivotDimension = string | {
+    field: string;
+    /** By group label; `'asc'` (the default) puts Chinese in pinyin order and numbers by size. */
+    sort?: 'asc' | 'desc';
+    /** Whether its groups show a total of their own; `true` by default. */
+    subtotal?: boolean;
+    /** Groups dates by a period, or numbers in ranges, instead of by each value. */
+    by?: PivotGroupBy;
+};
+/** The built-in ways to sum up a field. */
+export type PivotAggregateName = 'sum' | 'count' | 'avg' | 'min' | 'max' | 'distinct' | 'median';
+/**
+ * How a value is shown instead of as it is summed up:
+ *
+ * - `percentOfTotal`, `percentOfRow`, `percentOfColumn`: its share of the grand
+ *   total, of its row's total, or of its column's total
+ * - `percentOfParent`: its share of the group it is in
+ * - `difference`, `percentDifference`: how far it is from the group before it
+ * - `runningTotal`: it and every group before it, added up
+ * - `rank`: its place among the groups beside it, the largest first
+ */
+export type PivotShowAs = 'percentOfTotal' | 'percentOfRow' | 'percentOfColumn' | 'percentOfParent' | 'difference' | 'percentDifference' | 'runningTotal' | 'rank';
+/** A way of showing a value, with the axis it works along. */
+export interface PivotShow {
+    as: PivotShowAs;
+    /**
+     * The axis whose groups come "before" or "beside" (`difference`,
+     * `percentDifference`, `runningTotal`, `rank`) or "above" (`percentOfParent`).
+     * `'columns'` by default for the first three and `'rows'` for the others;
+     * the other axis when that one has no fields.
+     */
+    axis?: 'rows' | 'columns';
+}
+/** The colors a mark can take. */
+export type PivotTone = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+/** Colors the innermost cells of a value by where they fall between its smallest and largest. */
+export interface PivotMark {
+    /** `'bar'` draws a bar under the number; `'scale'` tints the cell, deeper for larger values. */
+    type: 'bar' | 'scale';
+    /** `'neutral'` by default. */
+    tone?: PivotTone;
+}
+/** A value to show: a field to sum up, or the name of a field (summed when numeric, counted otherwise). */
+export type PivotValue = string | {
+    /** The field to sum up; leave out for `count` to count the records. */
+    field?: string;
+    /** A built-in name or one from `defineAggregator`; `'sum'` for numbers, `'count'` otherwise. */
+    aggregate?: PivotAggregateName | (string & {});
+    /**
+     * A calculated value worked out from other fields, such as `profit / amount`
+     * (see `parsePivotFormula`); `field` and `aggregate` are then left out.
+     */
+    formula?: string;
+    /** The header; worked out from the field and the aggregate when left out. */
+    label?: string;
+    /** How the value is written; the field's `format` when left out. */
+    format?: PivotFormat;
+    /** Shows the value as a share, a difference, a running total or a rank. */
+    show?: PivotShowAs | PivotShow;
+    /** Colors the cells by their values. */
+    mark?: 'bar' | 'scale' | PivotMark;
+};
+/** Keeps the groups of a field with the largest (or smallest) totals of a value. */
+export interface PivotTopFilter {
+    count: number;
+    /** Which value, by its place in `values`; the first by default. */
+    valueIndex?: number;
+    /** `'desc'` (the default) keeps the largest. */
+    order?: 'asc' | 'desc';
+}
+/** Keeps the groups of a field whose totals of a value are within a range. */
+export interface PivotRangeFilter {
+    /** Which value, by its place in `values`; the first by default. */
+    valueIndex?: number;
+    min?: number;
+    max?: number;
+}
+/**
+ * Keeps only some groups of a field: those listed in `include`, or all but
+ * those in `exclude`; then, by their totals, the `top` ones or those `between`
+ * two numbers (worked out over the records the other filters keep).
+ */
+export interface PivotFilter {
+    include?: readonly unknown[];
+    exclude?: readonly unknown[];
+    top?: PivotTopFilter;
+    between?: PivotRangeFilter;
+    /**
+     * The values above are groups of this grouping. Left out, it is the
+     * field's grouping on the rows or columns, if it is there.
+     */
+    by?: PivotGroupBy;
+}
+/** Orders the row groups by the values in one column (what clicking a value header does). */
+export interface PivotValueSort {
+    /** Which value, by its place in `values`. */
+    valueIndex: number;
+    /** The column's path of group labels; `[]` (the default) for the grand total. */
+    column?: readonly unknown[];
+    order: 'asc' | 'desc';
+}
+/** Which fields go where. Plain data, so it can be saved and sent to a worker. */
+export interface PivotConfig {
+    rows?: readonly PivotDimension[];
+    columns?: readonly PivotDimension[];
+    /** Leave empty to count the records. */
+    values?: readonly PivotValue[];
+    filters?: Readonly<Record<string, PivotFilter>>;
+    /** Where the values go when there are several; `'columns'` by default. */
+    valuesOn?: 'columns' | 'rows';
+    sort?: PivotValueSort | null;
+    /** The grand total row and column; both shown by default. */
+    totals?: {
+        rows?: boolean;
+        columns?: boolean;
+    };
+}
+/** A group's labels from the outermost field in. */
+export type PivotPath = readonly unknown[];
+/** The groups that are collapsed, by their paths. */
+export interface PivotCollapsed {
+    rows?: readonly PivotPath[];
+    columns?: readonly PivotPath[];
+}

package/dist/types/fields/fields.vue.d.ts

@@ -0,0 +1,26 @@
+import type { HTMLAttributes } from 'vue';
+import type { ForwardedAttributes } from 'dou-ui';
+import type { PivotConfig } from '../engine/types';
+import type { PivotFieldsProps } from '../types';
+declare const __VLS_export: <Row = Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(PivotFieldsProps<Row> & ForwardedAttributes<HTMLAttributes, PivotFieldsProps<Row>> & {
+        config?: PivotConfig;
+    }) & {
+        "onUpdate:config"?: ((value: PivotConfig) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (event: "update:config", value: PivotConfig) => void;
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/fields/filter-list.vue.d.ts

@@ -0,0 +1,20 @@
+import type { PivotSource } from '../engine';
+import type { PivotGroupBy } from '../engine/group';
+import type { PivotFilter } from '../engine/types';
+import { type PivotMessages } from '../locale';
+type __VLS_Props = {
+    source: PivotSource<unknown>;
+    field: string;
+    by?: PivotGroupBy;
+    filter?: PivotFilter;
+    messages: PivotMessages;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    apply: (filter: PivotFilter | null) => any;
+    cancel: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onApply?: ((filter: PivotFilter | null) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/fields/formula-dialog.vue.d.ts

@@ -0,0 +1,30 @@
+import { type PivotSource } from '../engine';
+import type { PivotMessages } from '../locale';
+type __VLS_Props = {
+    source: PivotSource<unknown>;
+    messages: PivotMessages;
+    /** The value being changed, or null for a new one. */
+    initial: {
+        formula: string;
+        label?: string;
+    } | null;
+};
+type __VLS_ModelProps = {
+    'open': boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    apply: (value: {
+        formula: string;
+        label?: string;
+    }) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onApply?: ((value: {
+        formula: string;
+        label?: string;
+    }) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/fields/model.d.ts

@@ -0,0 +1,52 @@
+import type { PivotGroupBy } from '../engine/group';
+import type { PivotConfig, PivotFilter, PivotShowAs } from '../engine/types';
+/** The four places a field can go. */
+export type PivotArea = 'filters' | 'columns' | 'rows' | 'values';
+export declare const AREAS: readonly PivotArea[];
+/**
+ * A field as the panel shows it. `kind` tells where it came from: the list
+ * of all fields, an axis, the values or the filters; `index` is its place
+ * in `values` for a value.
+ */
+export interface PivotFieldItem {
+    key: string;
+    kind: 'field' | 'dimension' | 'value' | 'filter';
+    /** The field's name; `''` for a count of records. */
+    field: string;
+    index: number;
+}
+export type PivotAreas = Record<PivotArea, PivotFieldItem[]>;
+/** Whether a filter keeps out anything. */
+export declare const isFiltering: (filter: PivotFilter | undefined) => boolean;
+/** The fields in each area. A field filtered on an axis stays on its axis, not in the filters. */
+export declare function areasOf(config: PivotConfig): PivotAreas;
+/** The config with the areas as given: what an axis knew of a field (sort, grouping) moves with it. */
+export declare function configOf(areas: PivotAreas, config: PivotConfig): PivotConfig;
+/** Moves an item to the end of an area (what "移到…" in a field's menu does). */
+export declare function moveItem(areas: PivotAreas, from: PivotArea | null, item: PivotFieldItem, to: PivotArea | null): PivotAreas;
+/** A dimension with some of its options changed; plain names stay plain while they can. */
+export declare function withDimension(config: PivotConfig, axis: 'rows' | 'columns', field: string, patch: {
+    sort?: 'asc' | 'desc';
+    subtotal?: boolean;
+    by?: PivotGroupBy | null;
+}): PivotConfig;
+/** A value with its way of summing up changed. */
+export declare function withAggregate(config: PivotConfig, index: number, aggregate: string): PivotConfig;
+/** A value with its way of showing, its mark or its formula changed; `null` takes one away. */
+export declare function withValue(config: PivotConfig, index: number, patch: {
+    show?: PivotShowAs | null;
+    mark?: 'bar' | 'scale' | null;
+    formula?: string;
+    label?: string | null;
+}): PivotConfig;
+/** Which groups of a field to keep by their totals: the top (or bottom) N, or a range. */
+export type PivotRank = Pick<PivotFilter, 'top' | 'between'>;
+/** A field's filter with its `top` or `between` set, or both taken away; its lists stay as they are. */
+export declare function withRank(config: PivotConfig, field: string, rank: PivotRank | null, inFilters: boolean): PivotConfig;
+/** A field's filter replaced; an axis field without a filter left has none. */
+export declare function withFilter(config: PivotConfig, field: string, filter: PivotFilter | null, inFilters: boolean): PivotConfig;
+/**
+ * Round range sizes for a number field: about 10, 5 and 20 ranges over
+ * its values, each 1, 2 or 5 times a power of ten.
+ */
+export declare function stepsFor(min: number, max: number): number[];

package/dist/types/fields/top-dialog.vue.d.ts

@@ -0,0 +1,25 @@
+import type { PivotFilter } from '../engine/types';
+import type { PivotMessages } from '../locale';
+import type { PivotRank } from './model';
+type __VLS_Props = {
+    messages: PivotMessages;
+    /** The field's name as shown. */
+    field: string;
+    /** The values to rank by, with their headers. */
+    values: string[];
+    /** The field's filter as it is. */
+    filter: PivotFilter | undefined;
+};
+type __VLS_ModelProps = {
+    'open': boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    apply: (rank: PivotRank | null) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onApply?: ((rank: PivotRank | null) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;