@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/src/components/chart/chart-types.d.ts

@@ -0,0 +1,337 @@
+import { CssSizeValue } from '../../composables/css-size';
+import { MonoGridSource } from '../table/mono-data-grid.js';
+import { MaybeReactive } from '../../composables/reactive.js';
+import { MonoDataSourceOptions, MonoOdataOptions } from '../../utils/data-source-options.js';
+/** Chart.js chart types the addon exposes. */
+export type MonoChartType = 'bar' | 'line' | 'pie' | 'doughnut' | 'radar' | 'polarArea' | 'scatter' | 'bubble';
+/** Aggregate applied to a series' values when rows are bucketed by `groupBy`. */
+export type MonoChartAgg = 'sum' | 'avg' | 'count' | 'min' | 'max';
+/**
+ * The mono color names a chart understands: Basecoat's five chart colours
+ * (`chart-1` … `chart-5`, the default palette in that order) and the roles the
+ * rest of the library's `color` prop takes. They resolve through
+ * `--mono-chart-<name>` to the Basecoat tokens, so re-theming the app — a
+ * colour preset, a flavour, dark mode — re-themes the charts.
+ *
+ * Anywhere a color is accepted — `color`, `colors`, a series' `color` — you can
+ * use one of these names OR any CSS color (`#2e6bb0`, `rgb(…)`, `oklch(…)`).
+ */
+export type MonoChartColor = 'chart-1' | 'chart-2' | 'chart-3' | 'chart-4' | 'chart-5' | 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'danger' | 'info';
+/** Any source `monoChart` accepts for row data — a devextreme DataSource or an array. */
+export type MonoChartSource<T = any> = MonoGridSource<T>;
+/** A chart.js dataset, loosely typed so consumers can pass anything chart.js accepts. */
+export interface MonoChartDataset {
+    label?: string;
+    data: unknown[];
+    [key: string]: unknown;
+}
+/** A raw chart.js `data` object — the passthrough shape. */
+export interface MonoChartData {
+    labels?: unknown[];
+    datasets: MonoChartDataset[];
+}
+/**
+ * One dataset, mapped off a row field.
+ *
+ * @example
+ * series: [
+ *   { field: 'sales', label: 'Sales', agg: 'sum' },
+ *   { field: 'costs', label: 'Costs', agg: 'sum', type: 'line' },
+ * ]
+ */
+export interface MonoChartSeries {
+    /**
+     * Row field holding this series' value. Accepts a **path expression**
+     * (`"Job.Budget"`, `"Items.[0].Total"`) exactly like the table's `field`.
+     */
+    field: string;
+    /** Legend label. Defaults to `field`. */
+    label?: string;
+    /**
+     * How to combine rows that fall in the same `groupBy` bucket. Defaults to
+     * `'sum'` when `groupBy` is set. Ignored when it isn't — one row is one point.
+     */
+    agg?: MonoChartAgg;
+    /**
+     * Explicit color — a mono color name (`success`, `danger`, …) or any CSS
+     * color. Otherwise taken from the palette by index.
+     */
+    color?: MonoChartColor | string;
+    /** Per-series type, for mixed charts (e.g. bars with a line overlay). */
+    type?: MonoChartType;
+    /** Extra chart.js dataset properties, merged over the generated ones. */
+    dataset?: Record<string, unknown>;
+}
+/** Options for {@link monoChart}. */
+/**
+ * Context handed to {@link MonoChartOdataOptions.aggregate}. Everything needed to
+ * shape the clause is pre-resolved, so the common case is `({ apply }) => apply`.
+ */
+export interface MonoChartAggregateCtx {
+    /**
+     * The clause built from the chart's own `groupBy` + `series`, e.g.
+     * `groupby((DeptNama),aggregate(TotalBudget with sum as TotalBudget))`.
+     */
+    apply: string;
+    /** The devextreme filter in play (`odata.options.filter`), or `undefined`. */
+    filter: unknown;
+    /** devextreme filter array → OData string, for composing your own clause. */
+    odataFilter: (filter: unknown) => string;
+    /** `filter(<expr>)/<apply>` — the standard composition, ready to return. */
+    withFilter: (apply: string, filter?: unknown) => string;
+    groupBy?: string;
+    series: MonoChartSeries[];
+}
+/**
+ * Point the chart at an OData endpoint and let `monoOdataFetch` do the fetching.
+ *
+ * **`aggregate` is the switch.** Supply it and the chart issues ONE
+ * `$apply` request and charts the rolled-up rows the server returns. Leave it out
+ * and the rows are fetched normally — trim the payload with `options.select` /
+ * `options.filter` and the roll-up happens client-side as before.
+ *
+ * Requires the optional peer `@mono-lit/utility` (loaded on demand, only on this path).
+ */
+export interface MonoChartOdataOptions {
+    /**
+     * Names an entry in your `fetching.api` config; resolves the base URL (and the
+     * odata source constructors) for you, overriding `baseUrl`.
+     */
+    configBaseUrl?: string;
+    /** Explicit base URL, when you aren't using `configBaseUrl`. */
+    baseUrl?: string;
+    /** Entity path, e.g. `'/DtoProgramTransfer'`. */
+    url: string;
+    method?: 'GET' | 'POST';
+    /**
+     * devextreme load options. On the plain path this is how you keep the payload
+     * small (`select`, `filter`, `sort`, `take`). On the `$apply` path `filter` is
+     * offered to `aggregate()` and `paginate` is forced off, so every bucket comes
+     * back rather than just the first page.
+     */
+    options?: Record<string, unknown>;
+    /**
+     * Shape the `$apply` clause. Receives the prebuilt one and returns the final
+     * string — return `apply` unchanged, or compose something richer.
+     *
+     * @example
+     * aggregate: ({ apply, filter, withFilter }) => withFilter(apply, filter)
+     */
+    aggregate?: (ctx: MonoChartAggregateCtx) => string;
+}
+export interface MonoChartOptions {
+    /** Chart type when the element doesn't fix one. Default `'bar'`. */
+    type?: MonoChartType;
+    /**
+     * Row field used for the category axis / slice labels. Accepts a path
+     * expression. When `groupBy` is set and this is omitted, `groupBy` is used.
+     */
+    labelField?: string;
+    /** Bucket rows by this field before charting, then aggregate each series. */
+    groupBy?: string;
+    /** One dataset per entry. */
+    series?: MonoChartSeries[];
+    /** Palette for datasets (bar/line) or slices (pie/doughnut). */
+    colors?: string[];
+    /** Raw chart.js options, deep-merged over the generated defaults. */
+    options?: Record<string, unknown>;
+    /**
+     * Fetch the chart's rows through `monoOdataFetch` instead of a DataSource you
+     * bind yourself. Set `aggregate` to have the server roll the data up with
+     * `$apply` and return one row per bucket — see {@link MonoChartOdataOptions}.
+     */
+    odata?: MonoChartOdataOptions;
+    /**
+     * Props for the bound `<mono-chart*>` element, declared here so the element
+     * needs no appearance bindings of its own. Read back with `props()`, changed
+     * with `setProps()`. Where both this and the template declare a key, the
+     * **controller wins** — same rule as `controlMonoTable({ props })`.
+     */
+    props?: MonoChartProps;
+    /**
+     * Pull the FULL result set from a remote DataSource rather than just the
+     * current page. Default `true` — a chart almost always wants everything.
+     */
+    loadAll?: boolean;
+    /**
+     * Whether a chart bound to a remote DataSource may ask the SERVER to roll the
+     * data up — ONE `$apply=groupby((groupBy),aggregate(…))` through the source's
+     * own store (its url, `beforeSend`, auth) — instead of draining every row and
+     * bucketing them here. Default `true`; needs `groupBy` and explicit `series`
+     * (the clause is built from their `field` / `agg`, exactly as `odata.aggregate`
+     * builds it). A backend that rejects it (4xx / 501) turns the path off for this
+     * controller and the drain takes over. Set `false` to never try.
+     */
+    serverApply?: boolean;
+    /** Chunk size used when draining a remote source. Default `100`. */
+    chunkSize?: number;
+    /**
+     * The base every query goes out on — the same option `controlMonoTable` takes.
+     * On a bound DataSource its `filter` is AND-ed under the source's own for the
+     * drain (and written onto the source for a `loadAll: false` chart), `select` /
+     * `sort` / `expand` shape the chunk requests; on the `odata` path it merges into
+     * `odata.options` and folds inside `$apply`. A value, a getter, or a `{ value }`
+     * box (a Vue `ref` / `computed`), read fresh at every `reload()`.
+     */
+    dataSourceOptions?: MaybeReactive<MonoDataSourceOptions>;
+    /** The same in raw OData (`$select`, `$filter`, `$expand`, `$orderby`, custom params). */
+    odataOptions?: MaybeReactive<MonoOdataOptions>;
+}
+/** Detail handed to {@link MonoChartController.onPointClick}. */
+export interface MonoChartPointEvent<T = any> {
+    /** Index of the clicked point within its dataset. */
+    index: number;
+    /** Index of the dataset the point belongs to. */
+    datasetIndex: number;
+    /** The category label at that index. */
+    label: unknown;
+    /** The numeric value at that index. */
+    value: unknown;
+    /** Rows that produced this point (all rows in the bucket when grouped). */
+    rows: T[];
+}
+/**
+ * Chart controller — the reactive bridge between a data source and the
+ * `mono-chart-*` elements. Create it in your app and bind it with
+ * `:data-chart.prop="chart"`.
+ */
+export interface MonoChartController<T = any> {
+    /** Rows currently backing the chart (empty in raw-data mode). */
+    readonly items: T[];
+    /** True while the bound source is loading. */
+    loading: boolean;
+    /** Current chart type. */
+    type: MonoChartType;
+    /** The bound source, or null. */
+    readonly dataSource: MonoChartSource<T> | null;
+    /** The live chart.js instance, or null before an element mounts it. */
+    readonly instance: unknown;
+    /** The projected chart.js `data` object. */
+    data(): MonoChartData;
+    /** The merged chart.js `options` object. */
+    options(): Record<string, unknown>;
+    /**
+     * The central element props (`controlMonoChart({ props })`).
+     *
+     * One object with a **stable identity, mutated in place** — same contract as
+     * `controlMonoTable`'s `table.props()` — so bound elements keep seeing updates
+     * without being re-bound.
+     */
+    props(): MonoChartProps;
+    /**
+     * Merge a patch into `props()` and notify, so every bound element re-applies
+     * at once. A merge, not a replace: keys you omit keep their current value.
+     */
+    setProps(patch: MonoChartProps): void;
+    setType(type: MonoChartType): void;
+    setSeries(series: MonoChartSeries[]): void;
+    setColors(colors: string[]): void;
+    /** Replace the data — raw chart.js data, or a fresh row array. */
+    setData(next: MonoChartData | T[]): void;
+    /** Attach (or swap) the source — a DataSource, an array, or raw chart data. */
+    bind(source: MonoChartSource<T> | T[] | MonoChartData | null): void;
+    /** Re-read the bound source (or re-fetch through `odata`). Reads the base options fresh. */
+    reload(): Promise<void>;
+    /** Alias of `reload()` — the call to make after the reactive state behind a base getter changed. */
+    refresh(): Promise<void>;
+    /** Replace `dataSourceOptions` and reload. */
+    setDataSourceOptions(next: MaybeReactive<MonoDataSourceOptions> | undefined): Promise<void>;
+    /** Replace `odataOptions` and reload. */
+    setOdataOptions(next: MaybeReactive<MonoOdataOptions> | undefined): Promise<void>;
+    /** The merged, normalised base as of the last query. */
+    resolvedDataSourceOptions(): Readonly<MonoDataSourceOptions>;
+    /** Called when a point/slice is clicked. Assign after creating the controller. */
+    onPointClick: ((event: MonoChartPointEvent<T>) => void) | null;
+    /** Subscribe to state changes; returns an unsubscribe function. */
+    subscribe(cb: () => void): () => void;
+    /** Detach listeners, destroy nothing (the element owns the chart), clear subscribers. */
+    dispose(): void;
+    /** @internal — elements register their chart.js instance here. */
+    _attachInstance(instance: unknown): void;
+    /**
+     * @internal — elements install a resolver that turns mono color NAMES into
+     * real values. The controller has no DOM, so it can't read the tokens itself.
+     */
+    _setColorResolver(fn: ((color: string) => string) | null): void;
+}
+/** Per-part class overrides for the chart elements. */
+export interface ChartCssClass {
+    /** The wrapper. */
+    root?: string;
+    /** The `<canvas>`. */
+    canvas?: string;
+    /** The empty-state / loading text. */
+    message?: string;
+}
+/**
+ * The chart elements' own props, declared centrally on the controller
+ * (`controlMonoChart({ props })`) so every `<mono-chart*>` bound to it is wired
+ * with just `:control-chart.prop="chart"`. Read back via `chart.props()` and
+ * updated with `chart.setProps()`.
+ *
+ * Flat rather than keyed by element (the way `controlMonoTable({ props })` is)
+ * because the presets are the same element with `type` fixed — `props` IS that
+ * element's bag.
+ *
+ * The controller-binding keys are deliberately absent: they name the controller
+ * itself, so setting them *from* the controller would be circular.
+ */
+export interface MonoChartProps {
+    /**
+     * Chart type. Ignored by the presets, which fix their own. When a controller
+     * is bound this overrides the controller's `type`.
+     */
+    type?: MonoChartType;
+    /**
+     * Raw chart.js data, for use WITHOUT a controller. Bind with `.prop`:
+     * `:data.prop="{ labels, datasets }"`.
+     */
+    data?: MonoChartData;
+    /** Raw chart.js options, merged over the defaults. Bind with `.prop`. */
+    chartOptions?: Record<string, unknown>;
+    'chart-options'?: Record<string, unknown>;
+    /** Canvas box sizing. A CSS length string or a number (px). */
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    /** `width / height` when no explicit height is set. Default `2`. */
+    aspectRatio?: number;
+    'aspect-ratio'?: number;
+    /** Show the legend (default `true`), or place it: `top` / `bottom` / `left` / `right`. */
+    legend?: boolean | 'top' | 'bottom' | 'left' | 'right';
+    /** Chart title rendered by chart.js. */
+    title?: string;
+    /** Stack bar/line datasets. Default `false`. */
+    stacked?: boolean;
+    /**
+     * Single accent for every dataset — a mono color name (`primary`, `success`,
+     * `danger`, …) or any CSS color. `colors` wins when both are set.
+     */
+    color?: MonoChartColor | string;
+    /**
+     * Palette. A comma-separated attribute (`colors="success,danger,warning"`) or
+     * an array via `.prop`. Entries may be mono color names or CSS colors, mixed.
+     */
+    colors?: string | string[];
+    /** Per-part class overrides. Object, or a JSON string via the `css-class` attribute. */
+    cssClass?: ChartCssClass;
+    cssclass?: ChartCssClass;
+    'css-class'?: ChartCssClass | string;
+    /** A single class added to the root. */
+    cssClassName?: string;
+    /** Anything else the element accepts. */
+    [key: string]: unknown;
+}
+/**
+ * Props for `<mono-chart>` and its presets (`<mono-chart-bar>`, `-line`, `-pie`,
+ * `-doughnut`, which fix `type` and otherwise behave identically).
+ */
+export interface ChartProps extends MonoChartProps {
+    /** The chart controller. Bind with `.prop`: `:control-chart.prop="chart"`. */
+    controlChart?: MonoChartController;
+    'control-chart'?: MonoChartController;
+    controlchart?: MonoChartController;
+    /** Renamed — `:data-chart` / `:dataChart` alias `controlChart` (both work). */
+    dataChart?: MonoChartController;
+    'data-chart'?: MonoChartController;
+    datachart?: MonoChartController;
+}

package/dist/src/components/chart/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoChart } from './mono-chart.js';
+export { MonoChartBar, MonoChartLine, MonoChartPie, MonoChartDoughnut, } from './mono-chart-presets.js';
+export { MonoChartCore, loadChartJs } from './chart-core.js';
+export { monoChart, controlMonoChart } from './mono-data-chart.js';
+export { buildChartApply, buildChartOdataRequest, composeApply } from './chart-odata.js';
+export type { MonoChartOdataRequest } from './chart-odata.js';
+export type { ChartCssClass, ChartProps, MonoChartAgg, MonoChartController, MonoChartData, MonoChartDataset, MonoChartOptions, MonoChartOdataOptions, MonoChartAggregateCtx, MonoChartProps, MonoChartPointEvent, MonoChartSeries, MonoChartSource, MonoChartType, } from './chart-types.js';

package/dist/src/components/chart/index.shadow.d.ts

@@ -0,0 +1,7 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoChartShadow } from './mono-chart.shadow.js';
+export { MonoChartBarShadow, MonoChartLineShadow, MonoChartPieShadow, MonoChartDoughnutShadow, } from './mono-chart-presets.shadow.js';
+export { MonoChartCore, loadChartJs } from './chart-core.js';
+export { monoChart, controlMonoChart } from './mono-data-chart.js';
+export { buildChartApply, composeApply } from './chart-odata.js';
+export type { ChartCssClass, ChartProps, MonoChartAgg, MonoChartController, MonoChartData, MonoChartDataset, MonoChartOptions, MonoChartOdataOptions, MonoChartAggregateCtx, MonoChartProps, MonoChartPointEvent, MonoChartSeries, MonoChartSource, MonoChartType, } from './chart-types.js';

package/dist/src/components/chart/mono-chart-presets.d.ts

@@ -0,0 +1,43 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoChartType } from './chart-types.js';
+declare const MonoChartBar_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-chart-bar>` — vertical bars. */
+export declare class MonoChartBar extends MonoChartBar_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    protected createRenderRoot(): HTMLElement;
+    protected render(): TemplateResult;
+}
+declare const MonoChartLine_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-chart-line>` — a line series. */
+export declare class MonoChartLine extends MonoChartLine_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    protected createRenderRoot(): HTMLElement;
+    protected render(): TemplateResult;
+}
+declare const MonoChartPie_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-chart-pie>` — pie slices. */
+export declare class MonoChartPie extends MonoChartPie_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    protected createRenderRoot(): HTMLElement;
+    protected render(): TemplateResult;
+}
+declare const MonoChartDoughnut_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-chart-doughnut>` — a pie with a hole. */
+export declare class MonoChartDoughnut extends MonoChartDoughnut_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    protected createRenderRoot(): HTMLElement;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-chart-bar': MonoChartBar;
+        'mono-chart-line': MonoChartLine;
+        'mono-chart-pie': MonoChartPie;
+        'mono-chart-doughnut': MonoChartDoughnut;
+    }
+}
+export {};

package/dist/src/components/chart/mono-chart-presets.shadow.d.ts

@@ -0,0 +1,43 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoChartType } from './chart-types.js';
+declare const MonoChartBarShadow_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-shadow-chart-bar>`. */
+export declare class MonoChartBarShadow extends MonoChartBarShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    connectedCallback(): void;
+    protected render(): TemplateResult;
+}
+declare const MonoChartLineShadow_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-shadow-chart-line>`. */
+export declare class MonoChartLineShadow extends MonoChartLineShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    connectedCallback(): void;
+    protected render(): TemplateResult;
+}
+declare const MonoChartPieShadow_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-shadow-chart-pie>`. */
+export declare class MonoChartPieShadow extends MonoChartPieShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    connectedCallback(): void;
+    protected render(): TemplateResult;
+}
+declare const MonoChartDoughnutShadow_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/** `<mono-shadow-chart-doughnut>`. */
+export declare class MonoChartDoughnutShadow extends MonoChartDoughnutShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected _presetType: MonoChartType;
+    connectedCallback(): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-shadow-chart-bar': MonoChartBarShadow;
+        'mono-shadow-chart-line': MonoChartLineShadow;
+        'mono-shadow-chart-pie': MonoChartPieShadow;
+        'mono-shadow-chart-doughnut': MonoChartDoughnutShadow;
+    }
+}
+export {};

package/dist/src/components/chart/mono-chart.d.ts

@@ -0,0 +1,30 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoChart_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/**
+ * `<mono-chart>` — a Chart.js canvas, light DOM.
+ *
+ * Bind a controller and let it project the data, or hand it a raw chart.js
+ * `data` object. `chart.js` is an OPTIONAL peer, loaded on first render.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import '@mono-lit/helper/ui/chart'
+ * import { monoChart } from '@mono-lit/helper'
+ * const chart = monoChart(rows, { groupBy: 'month', series: [{ field: 'amount' }] })
+ * </script>
+ *
+ * <mono-chart :data-chart.prop="chart" type="bar" height="320" />
+ * ```
+ */
+export declare class MonoChart extends MonoChart_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-chart': MonoChart;
+    }
+}
+export {};

package/dist/src/components/chart/mono-chart.shadow.d.ts

@@ -0,0 +1,22 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoChartShadow_base: import('../../composables/hybird-prop').Constructor<import('./chart-core.js').MonoChartCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `<mono-shadow-chart>` (`@mono-lit/helper/ui/shadow/chart`).
+ *
+ * A chart can't be server-rendered — Chart.js paints onto a canvas at runtime —
+ * so SSR emits a deterministic empty `<canvas>` of the right size and the chart
+ * is drawn on hydration. `flushSsrHydration` is what makes that happen: under
+ * nuxt-ssr-lit an SSR'd element can stay `hasUpdated: false` with updates
+ * disabled, so `firstUpdated` would never run and the canvas would stay blank.
+ */
+export declare class MonoChartShadow extends MonoChartShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-shadow-chart': MonoChartShadow;
+    }
+}
+export {};

package/dist/src/components/chart/mono-data-chart.d.ts

@@ -0,0 +1,27 @@
+import { MonoChartController, MonoChartData, MonoChartOptions, MonoChartSource } from './chart-types.js';
+/**
+ * Create a chart controller.
+ *
+ * Two data modes:
+ * - **field-mapped** — pass rows (an array or a devextreme DataSource) plus
+ *   `labelField` / `series`; optionally bucket them with `groupBy` + per-series
+ *   `agg`. Field names accept path expressions.
+ * - **raw** — pass a chart.js `{ labels, datasets }` object and it is used
+ *   verbatim; no mapping, no aggregation.
+ *
+ * @example
+ * const chart = controlMonoChart(rows, {
+ *   type: 'bar',
+ *   groupBy: 'month',
+ *   series: [{ field: 'amount', label: 'Revenue', agg: 'sum' }],
+ *   props: { height: 320, legend: 'bottom' },
+ * })
+ * chart.subscribe(() => { /* re-render *\/ })
+ *
+ * @example
+ * // raw passthrough
+ * const chart = controlMonoChart({ labels: ['A', 'B'], datasets: [{ label: 'x', data: [1, 2] }] })
+ */
+/** Renamed "control" alias of {@link monoChart} (no breaking change — both work). */
+export { monoChart as controlMonoChart };
+export declare function monoChart<T = any>(source?: MonoChartSource<T> | T[] | MonoChartData | null, opts?: MonoChartOptions): MonoChartController<T>;

package/dist/src/components/checkbox/checkbox-core.d.ts

@@ -0,0 +1,53 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+import { CheckboxSize, CheckboxColor, CheckboxCssClass } from './checkbox-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoCheckboxCoreInterface {
+    size: CheckboxSize;
+    color: CheckboxColor;
+    modelValue: boolean;
+    checked: boolean;
+    disabled: boolean;
+    indeterminate: boolean;
+    loading: boolean;
+    label: string;
+    /** Secondary line under the label. */
+    sublabel: string;
+    /** The same as `sublabel`, kept for existing code. */
+    description: string;
+    value: string;
+    name: string;
+    ariaLabelText?: string;
+    cssClass: CheckboxCssClass;
+    cssClassName: string;
+    focus(): void;
+    blur(): void;
+    protected _hasIcon: boolean;
+    protected _hasIndeterminateIcon: boolean;
+    protected _hasLabelSlotState: boolean;
+    protected _hasDescriptionSlotState: boolean;
+    protected _toBoolean(value: unknown): boolean;
+    protected _cls(base: string, key: keyof CheckboxCssClass): string;
+    protected get _wrapperClasses(): string;
+    protected get _inputClasses(): string;
+    protected get _boxClasses(): string;
+    protected _hasLabelContent(): boolean;
+    protected _hasDescriptionContent(): boolean;
+    protected _handleChange(event: Event): void;
+    protected _renderCustomIcon(): TemplateResult | typeof nothing;
+    protected _renderLoadingIcon(): TemplateResult;
+    protected _renderLabelBlock(): TemplateResult | typeof nothing;
+}
+/**
+ * `MonoCheckboxCore` — all render-mode-agnostic logic for `mono-checkbox`:
+ * reactive props (incl. SSR boolean coercion), hybrid aliases, camelCase
+ * attribute fallbacks, the `modelValue`↔`checked` sync, class computation,
+ * change interactivity (`mno-change`), `focus`/`blur`, AND the shared `render()`
+ * skeleton (`<label><input><box></box><labelBlock></label>`). The slot-bearing
+ * regions are two overridable hooks — `_renderCustomIcon()` / `_renderLabelBlock()`
+ * — that default to the light build's `[data-mono-slot]` placeholders; the shadow
+ * build overrides them with native `<slot>` (mirrors `mono-accordion`).
+ *
+ * SSR-safe: no `document`/`window` access; `focus`/`blur` query `this.renderRoot`.
+ */
+export declare const MonoCheckboxCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoCheckboxCoreInterface> & T;

package/dist/src/components/checkbox/checkbox-types.d.ts

@@ -0,0 +1,69 @@
+import { VisibilityProps } from '../../composables/visibility';
+export type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type CheckboxColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+export interface CheckboxCssClass {
+    root?: string;
+    input?: string;
+    box?: string;
+    icon?: string;
+    indeterminateIcon?: string;
+    label?: string;
+    labelText?: string;
+    description?: string;
+}
+export type MonoModelEventDetail<TValue = unknown, TNativeValue = unknown> = {
+    modelValue: TValue;
+    currentValue: TValue;
+    oldValue: TValue;
+    value?: TNativeValue;
+    checked?: boolean;
+    name?: string;
+    sourceEvent?: Event;
+};
+export type CheckboxModelEventDetail = MonoModelEventDetail<boolean, string>;
+export type CheckboxModelEvent = CustomEvent<CheckboxModelEventDetail>;
+export interface CheckboxProps extends VisibilityProps {
+    /** Bound checked state of the checkbox. */
+    modelValue?: boolean;
+    'model-value'?: boolean;
+    modelvalue?: boolean;
+    /** Whether the checkbox is checked. */
+    checked?: boolean;
+    /** Color theme of the checkbox. */
+    color?: CheckboxColor;
+    /** Visual size of the checkbox. */
+    size?: CheckboxSize;
+    /** Disables interaction and dims the checkbox. */
+    disabled?: boolean;
+    /** Shows the indeterminate (mixed) state. */
+    indeterminate?: boolean;
+    /** Label text shown next to the checkbox. */
+    label?: string;
+    /** Secondary line under the label. `slot="sublabel"` replaces it. */
+    sublabel?: string;
+    /** The same as `sublabel` — still accepted, both names share one value. */
+    description?: string;
+    /** Form value submitted when checked. */
+    value?: string;
+    /** Form field name of the checkbox. */
+    name?: string;
+    /** Accessible label text for screen readers. */
+    ariaLabelText?: string;
+    'aria-label-text'?: string;
+    arialabeltext?: string;
+    /** Per-element class overrides. */
+    cssClass?: CheckboxCssClass;
+    /**
+     * Simple HTML attribute.
+     * This applies to root only.
+     *
+     * Example:
+     * <mono-checkbox css-class="my-checkbox"></mono-checkbox>
+     */
+    'css-class'?: string;
+}
+export interface CheckboxEvents {
+    change: CheckboxModelEvent;
+    'mno-change': CheckboxModelEvent;
+    mnoChange: CheckboxModelEvent;
+}