@mono-lit/helper 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,88 @@
+/**
+ * Dropdown Component Type Definitions
+ */
+export type DropdownSide = 'top' | 'bottom' | 'left' | 'right';
+export type DropdownAlign = 'start' | 'end' | 'center';
+export type DropdownPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export type DropdownTrigger = 'click' | 'hover' | 'manual';
+export type DropdownSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type DropdownColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+export type DropdownSource = 'trigger' | 'outside' | 'escape' | 'manual' | 'hover';
+export interface DropdownCssClass {
+    root?: string;
+    main?: string;
+    panel?: string;
+    body?: string;
+}
+export type DropdownClickEventDetail = {
+    modelValue: boolean;
+    currentValue: boolean;
+    oldValue: boolean;
+    value: boolean;
+    source: DropdownSource;
+    sourceEvent?: Event;
+    resolvedSide: DropdownSide;
+};
+export type DropdownClickEvent = CustomEvent<DropdownClickEventDetail>;
+/**
+ * `open` and `close` reuse the same detail payload as `toggle`,
+ * but fire only on the matching transition. `toggle` always fires too —
+ * pick whichever channel reads cleaner in your handler.
+ */
+export type DropdownOpenEventDetail = DropdownClickEventDetail;
+export type DropdownCloseEventDetail = DropdownClickEventDetail;
+export type DropdownOpenEvent = CustomEvent<DropdownOpenEventDetail>;
+export type DropdownCloseEvent = CustomEvent<DropdownCloseEventDetail>;
+export interface DropdownProps {
+    /** Two-way bound open state of the dropdown. */
+    modelValue?: boolean;
+    'model-value'?: boolean;
+    modelvalue?: boolean;
+    /** Panel placement relative to the trigger. */
+    placement?: DropdownPlacement;
+    /** How the dropdown opens: click, hover, or manual. */
+    trigger?: DropdownTrigger;
+    /** Sizing scale of the dropdown panel. */
+    size?: DropdownSize;
+    /** Color theme applied to the dropdown. */
+    color?: DropdownColor;
+    /** Disables interaction and prevents opening. */
+    disabled?: boolean;
+    /**
+     * When true, the panel auto-flips to the opposite side when the preferred
+     * side does not have enough room in the viewport.
+     */
+    flip?: boolean;
+    /**
+     * When true, the panel shifts along the cross axis to stay inside the
+     * viewport instead of overflowing.
+     */
+    shift?: boolean;
+    /**
+     * Pixel gap between the activator and the panel.
+     */
+    offset?: number;
+    /** Closes the dropdown when clicking outside it. */
+    closeOnOutsideClick?: boolean;
+    'close-on-outside-click'?: boolean;
+    closeonoutsideclick?: boolean;
+    /** Closes the dropdown when the Escape key is pressed. */
+    closeOnEscape?: boolean;
+    'close-on-escape'?: boolean;
+    closeonescape?: boolean;
+    /** Per-element class overrides for internal parts. */
+    cssClass?: DropdownCssClass;
+    cssclass?: DropdownCssClass;
+    'css-class'?: DropdownCssClass | string;
+}
+export interface DropdownEvents {
+    toggle: DropdownClickEvent;
+    open: DropdownOpenEvent;
+    close: DropdownCloseEvent;
+    'mno-click': DropdownClickEvent;
+    mnoClick: DropdownClickEvent;
+    'mno-open': DropdownOpenEvent;
+    mnoOpen: DropdownOpenEvent;
+    'mno-close': DropdownCloseEvent;
+    mnoClose: DropdownCloseEvent;
+}

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

@@ -0,0 +1,3 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoDropdown } from './mono-dropdown.js';
+export type { DropdownPlacement, DropdownSide, DropdownAlign, DropdownTrigger, DropdownSize, DropdownColor, DropdownSource, DropdownCssClass, DropdownClickEventDetail, DropdownClickEvent, DropdownOpenEventDetail, DropdownOpenEvent, DropdownCloseEventDetail, DropdownCloseEvent, DropdownProps, DropdownEvents, } from './dropdown-types.js';

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

@@ -0,0 +1,4 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoDropdownShadow } from './mono-dropdown.shadow.js';
+export { MonoDropdownCore } from './dropdown-core.js';
+export type { DropdownPlacement, DropdownSide, DropdownAlign, DropdownTrigger, DropdownSize, DropdownColor, DropdownSource, DropdownCssClass, DropdownClickEventDetail, DropdownClickEvent, DropdownOpenEventDetail, DropdownOpenEvent, DropdownCloseEventDetail, DropdownCloseEvent, DropdownProps, DropdownEvents, } from './dropdown-types.js';

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

@@ -0,0 +1,34 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoDropdown_base: import('../../composables/hybird-prop').Constructor<import('./dropdown-core.js').MonoDropdownCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-dropdown` (default build, `@mono-lit/helper/ui/dropdown`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`) with the light-DOM slot strategy: `slot="main"`/`"body"`
+ * children are captured in `connectedCallback`, the template renders empty
+ * `[data-mono-slot]` targets, and the captured nodes are re-appended in
+ * `updated()`. All render-mode-agnostic logic lives in `MonoDropdownCore`. The
+ * shadow build (`@mono-lit/helper/ui/shadow/dropdown`) shares the mixin but uses native
+ * `<slot>`. Both register `mono-dropdown`, so a document loads only one.
+ */
+export declare class MonoDropdown extends MonoDropdown_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _hasBodySlotState;
+    private _slotsCaptured;
+    private _slotMain;
+    private _slotBody;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    protected _activeMainNodes(): HTMLElement[];
+    private _captureSlots;
+    private _placeSlot;
+    private _renderBody;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-dropdown': MonoDropdown;
+    }
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoDropdownShadow_base: import('../../composables/hybird-prop').Constructor<import('./dropdown-core.js').MonoDropdownCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-dropdown` (SSR build, `@mono-lit/helper/ui/shadow/dropdown`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM. Slotting uses native `<slot>` (named `main` for the
+ * activator, default for the panel body). Trigger listeners attach to the main
+ * slot's assigned elements, re-synced on `slotchange`.
+ *
+ * Shares all logic with the light build via `MonoDropdownCore`. Both register
+ * `mono-dropdown`, so a document loads only one build.
+ */
+export declare class MonoDropdownShadow extends MonoDropdownShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected _activeMainNodes(): HTMLElement[];
+    /**
+     * No-op: the shadow build carries state classes on an inner `.mono-dropdown`
+     * root rendered in `render()` (see below), NOT the host. The host's `class` is
+     * controlled by the framework (Vue), which would wipe host classes — including
+     * `open` — on every re-render, so the panel could never stay open.
+     */
+    protected _updateHostClasses(): void;
+    private _onMainSlotChange;
+    protected render(): TemplateResult;
+    connectedCallback(): void;
+}
+export {};

package/dist/src/components/dropdown-table/dropdown-table-core.d.ts

@@ -0,0 +1,65 @@
+import { LitElement, TemplateResult } from 'lit';
+import { PopupPortalController } from '../../composables/popup-portal.js';
+import { DropdownPlacement } from '../dropdown/dropdown-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+import { CssSizeValue } from '../../composables/css-size';
+import { MonoDropdownController } from './mono-data-dropdown.js';
+import { DropdownTableSize, DropdownTableColor, DropdownTableVariant, DropdownTableValidationState, DropdownPanelOptions, DropdownTableCssClass, DropdownTableChipProps } from './dropdown-table-types.js';
+/** Public surface added by the dropdown-table core mixin. */
+export declare class MonoDropdownTableCoreInterface {
+    dataDropdown?: MonoDropdownController;
+    size: DropdownTableSize;
+    color: DropdownTableColor;
+    variant: DropdownTableVariant;
+    label: string;
+    placeholder: string;
+    helperText: string;
+    validationState: DropdownTableValidationState;
+    validationMessage: string;
+    errorMessage: string;
+    successMessage: string;
+    required: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    clearable: boolean;
+    multiple: boolean;
+    max?: number;
+    min?: number;
+    maxVisible?: number;
+    minVisible?: number;
+    chip: DropdownTableChipProps;
+    modelValue: unknown;
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    minWidth?: CssSizeValue;
+    maxWidth?: CssSizeValue;
+    minHeight?: CssSizeValue;
+    maxHeight?: CssSizeValue;
+    dropdown?: DropdownPanelOptions;
+    placement: DropdownPlacement;
+    flip: boolean;
+    shift: boolean;
+    offset: number;
+    cssClass: DropdownTableCssClass;
+    cssClassName: string;
+    stayOpen: boolean;
+    /** The popup controller — the light build reads `panelRoot` for slot placement. */
+    protected _popup: PopupPortalController;
+    /** Render a panel region — light: a `data-mono-slot` capture target; shadow: native `<slot>`. */
+    protected _renderRegion(cls: string, name: string): TemplateResult;
+    readonly isOpen: boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+}
+/**
+ * `MonoDropdownTableCore` — the field + popup shell for `<mono-dropdown-table>`. The
+ * FIELD mirrors `<mono-select>` (same size/color/variant/validation/label props and
+ * an identical look); the selection/value/display magic lives in the bound
+ * {@link MonoDropdownController} (`monoDataDropdown`). The consumer's native `<table>`
+ * + `mono-table-*` are slotted into the body-portaled panel; row clicks delegate to
+ * `dd.toggleRow`. The panel is sized independently of the field via the `dropdown`
+ * object (`matchWidth` is intentionally off). Reuses `PopupPortalController`,
+ * `buildSizeStyle`, and the global `.mono-chip` classes.
+ */
+export declare const MonoDropdownTableCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoDropdownTableCoreInterface> & T;

package/dist/src/components/dropdown-table/dropdown-table-types.d.ts

@@ -0,0 +1,278 @@
+import { CssSizeValue, PanelSizeProps } from '../../composables/css-size';
+import { DropdownPlacement } from '../dropdown/dropdown-types.js';
+import { MonoDropdownController, MonoDropdownItem } from './mono-data-dropdown.js';
+import { VisibilityProps } from '../../composables/visibility';
+import { ChipBehaviour, ChipColor, ChipCssClass, ChipRounded, ChipSize, ChipVariant } from '../chip/chip-types';
+import { ChipLimitProps } from '../../composables/chip-limits';
+export type { DropdownPlacement, ChipBehaviour, ChipLimitProps };
+/**
+ * Configuration for the selection chips inside the field, passed as one object:
+ * `<mono-dropdown-table :chip.prop="{ size: 'md', behaviour: 'inline' }">`.
+ *
+ * The same object `<mono-tag-input>` takes. The chips are rendered as `mono-chip`
+ * markup and painted by `chip.css`, so every key here is the corresponding
+ * `MonoChipProps` prop and takes the same values. Anything left unset follows
+ * the control instead of a fixed default:
+ *
+ * - `color` — defaults to the control's `color`. Setting it pins the chips to a
+ *   hue of their own.
+ * - `variant` — defaults to a skin matching the control's `variant`
+ *   (`outlined` → `soft`, `filled` → `solid`, `underlined` → `outline`).
+ * - `size` — defaults to `sm` (`xs` on the two smallest field sizes).
+ * - `shape` — defaults to `pill`.
+ *
+ * CHANGED: chips used to be hard-coded `soft-primary` regardless of the field's
+ * `color`. They now follow it, like tag-input's always have. A field with a
+ * non-primary `color` that wants the old look can pin it back with
+ * `:chip.prop="{ color: 'primary' }"`.
+ */
+export interface DropdownTableChipProps extends ChipLimitProps {
+    /**
+     * How the chips are laid out in the field. Default `flex` — they wrap onto
+     * new lines and the field grows taller.
+     *
+     * `inline` keeps them on ONE line in a horizontally scrolling strip, so the
+     * field never changes height. The strip is moved ONLY by the `‹` / `›`
+     * buttons rendered before the clear button / caret: no scrollbar is painted,
+     * and wheel, click-drag and arrow-key scrolling are all inert.
+     *
+     * {@link DropdownTableProps.maxVisible} applies in both layouts: past it the
+     * rest collapse into a "+N more" chip (in the strip, when inline) whose panel
+     * lists them.
+     */
+    behaviour?: ChipBehaviour;
+    /** Chip scale. Defaults to `sm` (`xs` on `xs`/`sm` fields). */
+    size?: ChipSize;
+    /** Chip hue. Defaults to the control's `color`; setting it pins the chips. */
+    color?: ChipColor;
+    /** Chip skin. Defaults to the skin matching the control's `variant`. */
+    variant?: ChipVariant;
+    /** Corner radius. Unset keeps the pill a chip has by default. */
+    rounded?: ChipRounded;
+    /** Show a status dot before each label. */
+    dot?: boolean;
+    /** Accessible label for the remove button. Default `Remove <label>`. */
+    closeLabel?: string;
+    /** Per-part class overrides, same keys as `mono-chip`'s `cssClass`. */
+    cssClass?: ChipCssClass;
+}
+/** Visual size of the field. */
+export type DropdownTableSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+/** Color theme (drives the focus/accent color). */
+export type DropdownTableColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+/** Field style variant. */
+export type DropdownTableVariant = 'outlined' | 'filled' | 'underlined';
+/** Validation appearance. */
+export type DropdownTableValidationState = 'default' | 'valid' | 'invalid' | 'warning';
+/**
+ * Sizes the popup PANEL only (independent of the field). When unset the panel sizes to its table
+ * content (min ~18rem). Bind with `.prop`: `:dropdown.prop="{ width: 520, maxHeight: 320 }"`.
+ *
+ * CHANGED: `height` used to be the panel's max-height, because this object had no separate cap
+ * key. It now has one, so `height` is an exact height and `maxHeight` caps — matching
+ * `<mono-select>` and `<mono-tag-input>`, which take the same object. A `{ height }` that meant
+ * "cap it so the table scrolls" should become `{ maxHeight }`.
+ */
+export type DropdownPanelOptions = PanelSizeProps;
+/**
+ * Per-part class overrides for `<mono-dropdown-table>` (mirrors `SelectCssClass`).
+ * Each value is appended to the built-in class of that field part. Pass via the
+ * `cssClass` prop / `css-class` attribute (an object, or a JSON string in HTML).
+ */
+export interface DropdownTableCssClass {
+    /** The wrapper (grid stack). */
+    root?: string;
+    /** The `<label>`. */
+    label?: string;
+    /** The required `*` marker. */
+    required?: string;
+    /** The clickable field box. */
+    trigger?: string;
+    /** The value / placeholder text region. */
+    value?: string;
+    /** The placeholder text (added on top of `value` when empty). */
+    placeholder?: string;
+    /** The trailing actions wrapper (scroll buttons + clear / arrow). */
+    actions?: string;
+    /** The clear (✕) button. */
+    clear?: string;
+    /** The caret arrow. Shown in place of `clear` when there is no value. */
+    arrow?: string;
+    /** One selection chip. */
+    chip?: string;
+    /** A chip's label span. */
+    chipLabel?: string;
+    /** A chip's remove button. */
+    chipRemove?: string;
+    /** The clickable "+N more" chip. */
+    moreChip?: string;
+    /** The one-line scrolling chip strip (`chip.behaviour: 'inline'` only). */
+    chipStrip?: string;
+    /** The `‹` scroll-back button (inline only). */
+    scrollPrev?: string;
+    /** The `›` scroll-forward button (inline only). */
+    scrollNext?: string;
+    /** The helper / validation message line. */
+    message?: string;
+}
+/**
+ * Props for `<mono-dropdown-table>`. The selection / value / display magic lives in
+ * the bound {@link MonoDropdownController} (`monoDataDropdown`); the field presentation
+ * mirrors `<mono-select>`.
+ */
+export interface DropdownTableProps extends VisibilityProps {
+    /** The dropdown controller. Bind with `.prop`: `:data-dropdown.prop="dd"`. */
+    dataDropdown?: MonoDropdownController;
+    'data-dropdown'?: MonoDropdownController;
+    /** Renamed — `:control-data-dropdown` / `:controlDataDropdown` alias `dataDropdown`. */
+    controlDataDropdown?: MonoDropdownController;
+    'control-data-dropdown'?: MonoDropdownController;
+    /** Visual size of the field. */
+    size?: DropdownTableSize;
+    /** Color theme applied to the field (focus ring / accent). */
+    color?: DropdownTableColor;
+    /** Field style variant. */
+    variant?: DropdownTableVariant;
+    /** Text label shown above the field. */
+    label?: string;
+    /** Placeholder shown in the field when nothing is selected. */
+    placeholder?: string;
+    /** Helper text shown below the field. */
+    helperText?: string;
+    'helper-text'?: string;
+    /** Validation state controlling the field's appearance. */
+    validationState?: DropdownTableValidationState;
+    'validation-state'?: DropdownTableValidationState;
+    /** Validation message shown below the field. */
+    validationMessage?: string;
+    'validation-message'?: string;
+    /** Error message shown below the field (forces the invalid state). */
+    errorMessage?: string;
+    'error-message'?: string;
+    /** Success message shown below the field (forces the valid state). */
+    successMessage?: string;
+    'success-message'?: string;
+    /** Mark the field required (shows a `*` next to the label). */
+    required?: boolean;
+    /** Disable the control (no open, no selection). */
+    disabled?: boolean;
+    /** Read-only — the panel opens but selection can't change. */
+    readonly?: boolean;
+    /** Show a clear (✕) button in the field when there is a value. */
+    clearable?: boolean;
+    /** Multi-select — array value + chips. Falls back to the controller's `multiple`. */
+    multiple?: boolean;
+    /**
+     * Most rows the user can select (multi). Unset = unlimited. A pick past it is
+     * rejected — the row stays enabled, the pick just does not land and a
+     * `<mono-table-checkbox>` un-ticks itself. Overrides the controller's `max`;
+     * `chip.max` overrides this. A `model-value` pushed in is never trimmed.
+     */
+    max?: number;
+    /**
+     * Fewest rows the user can leave selected (multi). Unset = 0. At the floor the
+     * chips lose their ✕, un-ticking is rejected and the clear button hides.
+     * Overrides the controller's `min`; `chip.min` overrides this.
+     */
+    min?: number;
+    /**
+     * Chips drawn before the rest collapse into a "+N more" chip (multi). Default
+     * `5`; `0` = draw all. Applies in `flex` AND `inline` — in the strip the
+     * "+N more" chip sits after the visible chips. `chip.maxVisible` overrides.
+     */
+    maxVisible?: number;
+    'max-visible'?: number;
+    /**
+     * Collapse floor: while the selection is at or under this, every chip is drawn
+     * regardless of `max-visible`. Unset = collapse as soon as `max-visible` is
+     * exceeded. `chip.minVisible` overrides.
+     */
+    minVisible?: number;
+    'min-visible'?: number;
+    /**
+     * Chip configuration — the `mono-chip` props to apply to every selection chip,
+     * plus `behaviour` for the one-line scrolling layout. The same object
+     * `<mono-tag-input>` takes.
+     *
+     * Bind it as a real property (`:chip.prop="{ behaviour: 'inline' }"`); a plain
+     * `chip='{"size":"md"}'` JSON attribute also works for static HTML.
+     */
+    chip?: DropdownTableChipProps | string;
+    /** v-model value — scalar (single) or array (multi). Bind `:model-value` + `@change`. */
+    modelValue?: unknown;
+    'model-value'?: unknown;
+    /**
+     * Field sizing (the trigger + wrapper). A CSS length string (`"320px"`, `"80%"`) or
+     * a number (px). Distinct from `dropdown`, which sizes the popup panel.
+     */
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    minWidth?: CssSizeValue;
+    'min-width'?: CssSizeValue;
+    maxWidth?: CssSizeValue;
+    'max-width'?: CssSizeValue;
+    minHeight?: CssSizeValue;
+    'min-height'?: CssSizeValue;
+    maxHeight?: CssSizeValue;
+    'max-height'?: CssSizeValue;
+    /** Sizes the popup panel only (independent of the field). Bind with `.prop`. */
+    dropdown?: DropdownPanelOptions;
+    /**
+     * Preferred side + cross-axis alignment of the panel, e.g. `"bottom-start"`
+     * (default) or `"top-end"`. Same 12 values as `<mono-dropdown>`. With `flip`
+     * left on this is only a *preference* — the panel still moves out of the way
+     * of a viewport edge.
+     */
+    placement?: DropdownPlacement;
+    /**
+     * Open on the opposite side when the preferred one lacks room — e.g. a field
+     * near the bottom of the viewport drops UPWARD instead of being clipped.
+     * Default `true`.
+     */
+    flip?: boolean;
+    /**
+     * Slide the panel along the cross axis so it stays inside the viewport — e.g.
+     * a field near the right edge keeps its full width instead of overflowing.
+     * Default `true`.
+     */
+    shift?: boolean;
+    /** Gap between the field and the panel, in px. Default `6`. */
+    offset?: number;
+    /**
+     * Focus the panel's search box (a `<mono-table-search slot="search">`) as soon
+     * as the panel opens, so the user can type straight away. Default `true`.
+     * Turn it off when the focus would be unwelcome — e.g. on touch devices, where
+     * focusing an input pops the virtual keyboard over the rows.
+     */
+    autoFocusSearch?: boolean;
+    'auto-focus-search'?: boolean;
+    /**
+     * Exempt this dropdown from every automatic close — clicking or focusing
+     * anything outside it, which includes opening another one. Not a lock: its own
+     * trigger, Escape and picking a row still close it.
+     */
+    stayOpen?: boolean;
+    'stay-open'?: boolean;
+    stayopen?: boolean;
+    /** Per-part class overrides. Object, or a JSON string via the `css-class` attribute. */
+    cssClass?: DropdownTableCssClass;
+    cssclass?: DropdownTableCssClass;
+    'css-class'?: DropdownTableCssClass | string;
+    /** A single class added to the root (the string form of `css-class`). */
+    cssClassName?: string;
+}
+/** `detail` of the `change` event `<mono-dropdown-table>` emits on every selection change. */
+export interface DropdownTableChangeEventDetail {
+    /** The new value — a scalar (single) or an array (multiple). */
+    modelValue: unknown;
+    value: unknown;
+    /** The selected rows, resolved: `{ key, text, data }` each. */
+    selectedItems: Array<MonoDropdownItem>;
+}
+export type DropdownTableChangeEvent = CustomEvent<DropdownTableChangeEventDetail>;
+/** Events emitted by `<mono-dropdown-table>` (feeds the generated Vue types). */
+export interface DropdownTableEvents {
+    change: DropdownTableChangeEvent;
+    'mno-change': DropdownTableChangeEvent;
+    mnoChange: DropdownTableChangeEvent;
+}

package/dist/src/components/dropdown-table/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoDropdownTable } from './mono-dropdown-table.js';
+export { monoDataDropdown, controlMonoDataDropdown } from './mono-data-dropdown.js';
+export type { MonoDropdownController, MonoDropdownItem, MonoDataDropdownOptions, } from './mono-data-dropdown.js';
+export type { DropdownTableProps, DropdownTableEvents, DropdownTableChangeEvent, DropdownTableChangeEventDetail, DropdownTableSize, DropdownTableColor, DropdownTableVariant, DropdownTableValidationState, DropdownPanelOptions, DropdownTableChipProps, ChipBehaviour, } from './dropdown-table-types.js';

package/dist/src/components/dropdown-table/index.shadow.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoDropdownTableShadow } from './mono-dropdown-table.shadow.js';
+export { MonoDropdownTableCore } from './dropdown-table-core.js';
+export { monoDataDropdown } from './mono-data-dropdown.js';
+export type { MonoDropdownController, MonoDropdownItem, MonoDataDropdownOptions, } from './mono-data-dropdown.js';
+export type { DropdownTableProps, DropdownTableEvents, DropdownTableChangeEvent, DropdownTableChangeEventDetail, DropdownTableSize, DropdownTableColor, DropdownTableVariant, DropdownTableValidationState, DropdownPanelOptions, DropdownTableChipProps, ChipBehaviour, } from './dropdown-table-types.js';