@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/src/composables/data-source-controller.d.ts

@@ -0,0 +1,84 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * Minimal structural shape of a devextreme DataSource. Declared locally so
+ * @mono-lit/helper stays dependency-free; a real devextreme DataSource satisfies it.
+ */
+export interface MonoDataSource<T = unknown> {
+    load: () => PromiseLike<T[]> | T[];
+    items: () => T[];
+    isLoading?: () => boolean;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+    paginate?(value?: boolean): boolean;
+    pageSize?(value?: number): number;
+    pageIndex?(value?: number): number;
+    isLastPage?: () => boolean;
+    totalCount?: () => number;
+}
+/**
+ * Incremental loading mode. Works with BOTH a paged DataSource and a plain
+ * `items` array (the array is revealed one `pageSize` chunk at a time):
+ * - 'button' → render a "Load more" button at the end of the list.
+ * - 'scroll' → load/reveal the next chunk when scrolled near the bottom.
+ */
+export type LoadMoreMode = 'button' | 'scroll';
+export interface DataSourceControllerOptions<T> {
+    /** Current bound DataSource (or null) — read live from the host property. */
+    getDataSource: () => MonoDataSource<T> | null;
+    /** The raw plain `items` array, used when no DataSource is bound. */
+    getItems: () => T[];
+    /** Auto-load the source on attach when it has no items yet. */
+    getImmediate: () => boolean;
+    /** Effective load-more mode, or undefined when disabled. */
+    getLoadMoreMode: () => LoadMoreMode | undefined;
+    /** Sanitized chunk size (>= 1) for array-mode paging. */
+    getPageSize: () => number;
+}
+/**
+ * Encapsulates the generic DataSource + incremental-loading logic shared by
+ * `mono-select`, `mono-tag-input`, etc. The host owns the rendering and any
+ * scroll/height ergonomics; this controller owns binding, event wiring, page
+ * accumulation, and array-mode chunking.
+ *
+ * Every state mutation calls `host.requestUpdate()` so the host re-renders.
+ */
+export declare class DataSourceController<T = unknown> implements ReactiveController {
+    private readonly host;
+    private readonly opts;
+    private _dsItems;
+    private _dsLoading;
+    private _loadingMore;
+    private _isLastPage;
+    private _visibleCount;
+    private _internalLoad;
+    private _bound;
+    constructor(host: ReactiveControllerHost, opts: DataSourceControllerOptions<T>);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /** Attach/detach listeners for a (possibly new) DataSource and seed state. */
+    bind(ds: MonoDataSource<T> | null): void;
+    maybeImmediateLoad(): void;
+    /** Call when the load-more mode changes; refreshes paging assumptions. */
+    onLoadMoreModeChange(): void;
+    /** Reset array-mode paging to the first chunk. */
+    resetVisible(): void;
+    /** Load/reveal the next page and append it to the accumulated list. */
+    loadMore(): Promise<void>;
+    /** Raw source array: accumulated DataSource items, or the plain `items`. */
+    get sourceItems(): T[];
+    /** Rows to actually render (array-mode reveals a slice; else everything). */
+    get visibleItems(): T[];
+    get loading(): boolean;
+    get loadingMore(): boolean;
+    /** load-more is driving a plain `items` array (no DataSource bound). */
+    get isArrayLoadMore(): boolean;
+    /** Whether there's nothing left to load/reveal. */
+    get atLastPage(): boolean;
+    private readonly _onChanged;
+    private readonly _onLoadingChanged;
+    private _sync;
+    /** Load the first page, replacing the accumulated list. */
+    private _loadFirstPage;
+    private _detach;
+    private _changed;
+}

package/dist/src/composables/element-props.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Whether `key` can actually be assigned on `obj` — a plain expando, or an
+ * accessor/data property that isn't read-only.
+ *
+ * This matters because a controller's `props` object legitimately carries keys
+ * that are NOT element props: `monoDataGrid`'s `th[].summary` includes `prefix`
+ * and `precision`, which the controller consumes for formatting. `prefix`
+ * collides with the read-only native `Element.prefix`, and assigning it throws —
+ * which took down the whole docs page render until this check existed.
+ */
+export declare function isSettable(obj: object, key: string): boolean;
+/** `{ onChange, onToggle, onLoadingChange, … }` typed from a component's `*Events` interface. */
+export type MonoEventProps<E> = {
+    [K in Extract<keyof E, string> as K extends `${string}-${string}` ? never : `on${Capitalize<K>}`]?: (event: E[K]) => void;
+};
+/** Whether a props key names an event handler (`onClick`, `onLoadingChange`). */
+export declare function isEventHandlerKey(key: string): boolean;
+/**
+ * `onClick` → `click`, `onLoadingChange` → `loading-change`, `onMnoChange` →
+ * `mno-change` — the same rule Vue applies to an `on*` listener prop, so a key
+ * that works in a template works here.
+ */
+export declare function eventNameFromHandlerKey(key: string): string;
+/**
+ * Remove every handler `applyProps` attached to `el`. Call it where an element
+ * leaves its controller (an unbind, a re-bind to a different one) so the old
+ * controller's handlers do not keep firing beside the new one's.
+ */
+export declare function detachEventHandlers(el: object): void;
+/**
+ * Write a controller's props onto an element.
+ *
+ * Two guards, both load-bearing:
+ * - `undefined` values are skipped, so "not declared" never clobbers a value the
+ *   template set;
+ * - each write is equality-checked, so a sync can't schedule another update and
+ *   loop.
+ *
+ * Handler keys (`onClick`, `onToggle`, …) become event listeners — see the
+ * block above — never properties.
+ *
+ * Shared by `table-controller-core` (`monoDataGrid`/`monoDataDropdown` elements)
+ * and `form-control-core` (`monoForm` controls) — the write loop is identical
+ * and its failure modes are subtle enough to be worth having in one place.
+ */
+export declare function applyProps(el: object, patch: Record<string, unknown> | undefined): boolean;

package/dist/src/composables/field-icons.d.ts

@@ -0,0 +1,7 @@
+import { TemplateResult } from 'lit';
+/** Downward caret — the "this opens a panel" affordance. */
+export declare function caretIcon(): TemplateResult;
+/** The ✕ a clear button and a chip's remove button draw, at the caret's weight. */
+export declare function closeIcon(): TemplateResult;
+/** Left (`-1`) or right (`1`) chevron, matching {@link caretIcon}'s weight. */
+export declare function chevronIcon(dir: -1 | 1): TemplateResult;

package/dist/src/composables/hybird-prop.d.ts

@@ -0,0 +1,79 @@
+/** Generic constructor type for Lit mixins: `<T extends Constructor<LitElement>>`. */
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare function toKebabCase(value: string): string;
+export declare function toLowerCaseProp(value: string): string;
+export declare function defineHybridPropAliases<T extends object>(target: T, props: string[]): void;
+/**
+ * Register a cross-name alias for a controller-binding prop — e.g.
+ * `defineHybridPropAlias(el, 'controlTable', 'dataGrid')` makes `controlTable`,
+ * `control-table` and `controltable` all read/write the canonical reactive
+ * `dataGrid` property (so `.controlTable = …` still triggers Lit's update
+ * cycle). Used to rename the controller props without a breaking change: the
+ * new `control-*` spellings land here while the old `data-*` ones keep working.
+ */
+export declare function defineHybridPropAlias<T extends object>(target: T, aliasCamel: string, realProp: string): void;
+/**
+ * Lit `hasChanged` for an array prop.
+ *
+ * **Load-bearing**, for exactly the reason `rateLimitHasChanged` is (see
+ * `composables/rate-limit.ts`): `:items="[...]"` in a template allocates a NEW array
+ * on every parent re-render. Under Lit's default `!==` the element sees a change
+ * each time, so anything gated on `changed.has('items')` — resetting an
+ * infinite-scroll page, invalidating a search memo, rebuilding a cache — runs on
+ * renders where nothing about the data actually moved.
+ *
+ * Element-wise identity rather than a deep compare: rows are normally stable objects
+ * owned by a store, so this catches the re-created-wrapper case cheaply. If the
+ * consumer also rebuilds each row object the arrays are reported as different, which
+ * is the safe direction.
+ *
+ * **Why this needs no "repair" step, unlike `mono-button-dropdown`.** That element
+ * compares entries by CONTENT and deliberately ignores function fields, so it reports
+ * "same" for entries that really were rebuilt — leaving cached listener state pointing
+ * at the previous array (hence `_retargetItemParts()`). `arrayHasChanged` says "same"
+ * only when the array holds literally the same objects in the same order, so nothing
+ * item-related can have moved and there is nothing to retarget. Reach for the deeper
+ * compare only where the callbacks are resolved late, and prove it.
+ *
+ * **Do NOT add this (or any `hasChanged`) to these — they hang real work off the
+ * update cycle, so suppressing an update silently drops it:**
+ *   - `chart-core.ts` — `updated()` IS the chart pipeline; its last step `_applyData()`
+ *     is the only place chart.js is redrawn. A skipped update freezes the canvas.
+ *   - `date-core.ts` — `updated()` drives `_rebuild()` / `_applyModelValue()`, so
+ *     flatpickr would be stranded on stale config.
+ *   - every `mono-table-*` element — `table-controller-core.ts` overrides `update()` to
+ *     pull each element's slice of `monoDataGrid({ props })`.
+ *   - every `monoForm`-bound control and `filter-builder-core.ts` — same `update()` hook
+ *     (`form-control-core.ts`), used for form binding and visibility.
+ *
+ * Surveyed 2026-08-17 across all 26 component directories; the guarded props are
+ * `select`/`tag-input` `items`, `tag-input` `modelValue`/`value`, `menu` +
+ * `mono-menu-list` `items`, `tabs` `items`, both `breadcrumb` `items`, and
+ * `file-upload` `modelValue`.
+ */
+export declare function arrayHasChanged(value: unknown, old: unknown): boolean;
+export declare const booleanStringConverter: {
+    fromAttribute(value: unknown): boolean;
+    toAttribute(value: boolean): string | null;
+};
+export declare const numberStringConverter: {
+    fromAttribute(value: string | null): number;
+    toAttribute(value: number): string | null;
+};
+/**
+ * Like {@link numberStringConverter}, but an absent/blank attribute stays
+ * `undefined` instead of collapsing to `0`.
+ *
+ * Needed wherever 0 is a meaningful value AND "not set" has to mean "fall back to
+ * whatever the component computes" — e.g. `mono-modal` / `mono-drawer`'s `z-index`,
+ * where 0 is a legal stacking level and unset means "let the popup stack decide".
+ * Using the plain number converter there would pin every dialog to `z-index: 0`.
+ */
+export declare const optionalNumberConverter: {
+    fromAttribute(value: string | null): number | undefined;
+    toAttribute(value: number | undefined): string | null;
+};
+export declare const stringConverter: {
+    fromAttribute(value: string | null): string;
+    toAttribute(value: string): string | null;
+};

package/dist/src/composables/hydration-flush.d.ts

@@ -0,0 +1,34 @@
+import { ReactiveElement } from 'lit';
+export interface FlushSsrHydrationOptions {
+    /**
+     * Withhold hydration until this returns `true`; polling continues meanwhile.
+     *
+     * Needed for elements that render a LIST from a property the server also
+     * rendered (`:items.prop`): Vue assigns the property asynchronously AFTER
+     * connect, so hydrating early makes the client render fewer children than the
+     * server's `<!--lit-part-->` markers → "Unhandled shorter than expected
+     * iterable" plus a duplicate render. Gate on the client count having caught
+     * up with the server count.
+     */
+    gate?: () => boolean;
+    /** How many ticks to attempt before giving up (default 30). */
+    maxTries?: number;
+}
+/**
+ * Force an SSR'd element's first client update to flush.
+ *
+ * Under `nuxt-ssr-lit` the server-rendered element can stay `hasUpdated: false`
+ * with updates disabled even after `<LitWrapper>` removes `defer-hydration` —
+ * so `render()` never re-runs and its event handlers never bind. The element is
+ * then frozen at whatever the SERVER assumed, while its JS properties keep
+ * taking client values: a silent divergence between the rendered DOM and the
+ * live props.
+ *
+ * Poll `requestUpdate()` for a few ticks until the element reports `hasUpdated`.
+ * A no-op once the element has hydrated normally.
+ *
+ * Scheduling races `requestAnimationFrame` against a `setTimeout` backstop:
+ * rAF does NOT fire in a hidden, minimized, or fully occluded tab, and relying
+ * on it alone leaves the element frozen until the tab is next painted.
+ */
+export declare function flushSsrHydration(el: ReactiveElement, options?: FlushSsrHydrationOptions): void;

package/dist/src/composables/icon.d.ts

@@ -0,0 +1,17 @@
+import { TemplateResult } from 'lit';
+/**
+ * Detect whether an icon string is an iconify utility class — e.g.
+ * `i-mdi-close`, `i-tabler-upload`. UnoCSS's preset-icons resolves these to a
+ * background/mask, so components render them as an empty `<span class="i-...">`.
+ *
+ * Single source of truth — components re-export this from their own
+ * `*-utils.ts` so their public API stays stable.
+ */
+export declare function isIconifyClass(icon: string | undefined | null): boolean;
+/**
+ * Draw an `i-mdi-*` glyph as inline SVG — the SHADOW builds' counterpart to the
+ * light builds' UnoCSS mask. Both come from `@iconify-json/mdi`, so one `icon`
+ * value paints the same artwork in either build. Returns `undefined` when the
+ * glyph is not bundled (see `scripts/mdi-glyphs.mjs`), so a caller can fall back.
+ */
+export declare function mdiGlyph(icon: string | undefined | null): TemplateResult | undefined;

package/dist/src/composables/layout-var.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Refcounted document-level layout variables.
+ *
+ * Several components publish their own size as a custom property on
+ * `document.documentElement` so page content can offset itself —
+ * `--mono-nav-height`, `--mono-sidebar-left-width`, `--mono-sidebar-right-width`.
+ * The property is global but the writers are not: two navs, or two sidebars on the
+ * same side, all write the SAME property.
+ *
+ * Removing it outright on the first unmount blanked the offset for every writer that
+ * was still mounted — the page content jumped back underneath a nav or sidebar that
+ * is still on screen. That bug was found independently in BOTH `mono-sidebar` and
+ * `mono-nav`, which is why the fix lives here rather than being written twice.
+ *
+ * Ownership is therefore refcounted: the property is removed only when the LAST
+ * owner releases it, and until then it is handed back to a remaining owner's last
+ * known value. Note that a refcount has two failure modes — releasing too early
+ * (survivor loses the var) and never reaching zero (the var is stranded on the
+ * document forever). Both are covered by assertions in `docs/e2e/stress.mjs` (repo root).
+ */
+/**
+ * Publish `value` for `name` on behalf of `owner`.
+ *
+ * Re-claiming with the same owner just updates that owner's value, so this is safe
+ * to call on every render.
+ */
+export declare function claimLayoutVar(name: string, owner: object, value: string): void;
+/**
+ * Drop `owner`'s claim on `name`.
+ *
+ * The property is only removed once nobody holds it; while another owner remains,
+ * that owner's last published value is restored instead.
+ */
+export declare function releaseLayoutVar(name: string, owner: object): void;

package/dist/src/composables/light-slots.d.ts

@@ -0,0 +1,133 @@
+/** Captured nodes, keyed by slot name, in document order. */
+export type LightSlotBuckets = Map<string, Node[]>;
+export interface CaptureLightSlotsOptions {
+    /** Named `slot="…"` values this component lays out. */
+    names: readonly string[];
+    /** Bucket for unnamed content and framework anchors. Default `'default'`. */
+    fallback?: string;
+    /**
+     * Install the `textContent` guard on the host (default `true`). Opt out only for
+     * a component that never renders a `[data-mono-slot]` region for `fallback`.
+     */
+    guardTextContent?: boolean;
+}
+/**
+ * Take ownership of the host's current children. Run **once**, from
+ * `connectedCallback`, before the first render.
+ *
+ * Only nodes that were bucketed are detached from the host — anything left
+ * unclaimed stays exactly where the consumer put it.
+ */
+export declare function captureLightSlots(host: HTMLElement, options: CaptureLightSlotsOptions): LightSlotBuckets;
+export interface HostTextGuardOptions {
+    /** Bucket a bare text write lands in. Default `'default'`. */
+    fallback?: string;
+    /**
+     * Ran after a write that changed the captured content — normally
+     * `requestUpdate()`, because slot emptiness is read during render and is not
+     * itself reactive.
+     */
+    onWrite?: () => void;
+}
+/**
+ * Redirect `host.textContent = …` into the captured default region.
+ *
+ * A light-DOM component renders into its own host, so the host's children are the
+ * component. Vue compiles a lone interpolation to a `TEXT`-flagged vnode and
+ * patches it with `el.textContent = next` (`runtime-dom`'s `setElementText`) —
+ * on the HOST. That single assignment removes every rendered node, Lit's
+ * `<!--lit-part-->` markers included, and replaces them with one bare text node:
+ * the component visually disappears and no later render repairs it, because
+ * Lit's parts now point at detached nodes. `patchChildren` does the same when
+ * children go array→text or are cleared, and so does `v-text`.
+ *
+ * Static text never hit this (Vue skips the write when the string is unchanged),
+ * which is why it only showed up on dynamic captions. Shadow builds are immune —
+ * there the host's children really are slotted content.
+ *
+ * So the write is intercepted and applied to the text node the consumer already
+ * owns inside `[data-mono-slot="<fallback>"]`, which is what the framework meant
+ * by it anyway. Framework anchors (zero-length text nodes, comments) and element
+ * children are left alone — repurposing an anchor would break the consumer's next
+ * patch just as badly as dropping one.
+ *
+ * `innerHTML` is deliberately not guarded: only `v-html` on the host reaches it,
+ * and that is a consumer asking to own the element outright.
+ */
+export declare function guardHostTextContent(host: HTMLElement, buckets: LightSlotBuckets, options?: HostTextGuardOptions): void;
+/**
+ * Move one captured node into its region — unless the consumer has taken it back.
+ *
+ * The obvious form of this, `if (node.parentNode !== target) target.appendChild(node)`,
+ * cannot tell "not placed yet" from "the framework DELETED this". A child behind a
+ * `v-if` that flips false ends up with `parentNode === null`, looks unplaced, and the
+ * very next render puts it straight back: the element **resurrects** and no amount of
+ * consumer state removes it. That was reproduced in `mono-accordion` and `mono-input`
+ * and the same loop was copied into every light-DOM component.
+ *
+ * So: place freely until a node has been placed once. After that, only re-home it
+ * while it is still inside one of OUR regions — which is what happens when a
+ * re-render swaps the region element, the case the original guard existed for. A
+ * null parent means deleted and any other parent means the consumer moved it; both
+ * are left alone.
+ */
+export declare function placeSlotNode(target: Element, node: Node): void;
+/**
+ * Move captured nodes into their `[data-mono-slot]` regions. Run from `updated()`,
+ * after Lit has rendered them.
+ *
+ * Nodes already sitting in the right region are left untouched — that guard is
+ * what stops a re-render from re-ordering content the consumer's framework
+ * inserted after capture. See {@link placeSlotNode} for why "not in the target"
+ * is not enough on its own.
+ */
+export declare function placeLightSlots(host: HTMLElement, buckets: LightSlotBuckets): void;
+/**
+ * Park captured nodes that couldn't be placed — because their `[data-mono-slot]`
+ * target isn't rendered (a slot naming an item that doesn't exist *yet*, e.g. one
+ * bound to async-loaded data) — in a detached holder so they always keep a live
+ * parent. A captured node left with `parentNode === null` crashes the consumer
+ * framework's next patch (`Cannot read properties of null`); any parent avoids that
+ * while keeping the node invisible until its real target appears and placement moves
+ * it out. Returns the holder (created lazily on first orphan) so the caller can cache
+ * it. Pass the previously-returned holder back in on later calls.
+ */
+export declare function parkDetachedNodes(holder: HTMLElement | undefined, nodes: Iterable<Node>): HTMLElement | undefined;
+/**
+ * Whether a bucket holds anything the user can actually see — used to decide
+ * whether a region is worth rendering.
+ *
+ * Comments are explicitly excluded: an anchor like `<!--v-if-->` has a non-blank
+ * `textContent`, so a naive check would report an empty region as occupied.
+ */
+export declare function bucketHasContent(nodes: Node[] | undefined): boolean;
+/**
+ * Watches a host for a named slot child that arrives AFTER `connectedCallback`.
+ *
+ * The one-shot capture the light builds do at connect is right for the common case — a framework
+ * mounts an element's children before inserting it — but it is not the only case. A `<ClientOnly>`
+ * boundary, a hydration pass, or a `v-if` flipping later all append the child to an element that
+ * is already connected, and a capture that has already run will never see it. In the light build
+ * that leaves the node sitting in the host's own flow, visible OUTSIDE the region it was meant
+ * for; in the shadow build the flag that renders the `<slot>` never turns on, so nothing projects.
+ *
+ * Deliberately not a Lit controller: it has to work from inside a mixin whose host may be either
+ * build, and all it needs is connect/disconnect.
+ */
+export declare class LateSlotWatcher {
+    private readonly host;
+    private readonly name;
+    private readonly onFound;
+    private _observer?;
+    constructor(host: Element, name: string, onFound: () => void);
+    /**
+     * The host's own child carrying `slot="<name>"`, or `null`.
+     *
+     * Walks `children` rather than running a `:scope >` selector — only a DIRECT child is
+     * assignable to a slot, and this way the check is one cheap loop over a handful of nodes with
+     * no selector engine involved.
+     */
+    find(): Element | null;
+    start(): void;
+    stop(): void;
+}

package/dist/src/composables/mdi-glyphs.d.ts

@@ -0,0 +1,4 @@
+/** `i-mdi-<name>` → the inner SVG markup of that glyph, on a 24x24 viewBox. */
+export declare const MDI_GLYPHS: Readonly<Record<string, string>>;
+/** The artwork for an `i-mdi-*` class, or `undefined` when it is not bundled. */
+export declare function mdiGlyphBody(icon: string | undefined | null): string | undefined;

package/dist/src/composables/mono-element.d.ts

@@ -0,0 +1,9 @@
+type ElementClass = CustomElementConstructor;
+/** Register `cls` as `tag` with the app-wide defaults applied. Returns the registered class. */
+export declare function defineMonoElement<T extends ElementClass>(tag: string, cls: T): T;
+/**
+ * Drop-in for Lit's `@customElement(tag)`: registers the class (wrapped so
+ * `createMonoUI` defaults apply and `pending` exists) and replaces the class binding with it.
+ */
+export declare function customElement(tag: string): <T extends ElementClass>(cls: T) => T;
+export {};

package/dist/src/composables/mono-event.d.ts

@@ -0,0 +1,55 @@
+/** Options for {@link dispatchMonoEvent}. */
+export interface MonoEventOptions {
+    /**
+     * The native DOM event this mono event was derived from, if any. Defaults to
+     * `detail.sourceEvent` when that is an `Event` — which is what every model
+     * detail already carries.
+     */
+    sourceEvent?: Event | null;
+    /**
+     * The plain (unprefixed) name to emit. Defaults to `name`. Give a different
+     * one when the mono name is not what the plain event means — `mno-click` on
+     * a modal is an open-state change, so its plain name is `toggle`. `false`
+     * emits no plain event at all.
+     */
+    alias?: string | false;
+}
+/**
+ * Device-originated event names — decorated when native, never synthesized.
+ * See the header for why.
+ */
+export declare const MONO_DEVICE_EVENTS: ReadonlySet<string>;
+/**
+ * Plain names dispatched WITHOUT bubbling when synthesized: their native
+ * namesakes do not bubble either, and something above the element (a form, the
+ * window's error reporting, a focus trap) would act on a stray one.
+ */
+export declare const MONO_NON_BUBBLING_ALIASES: ReadonlySet<string>;
+/** `loading-change` → `loadingChange`; a single word is unchanged. */
+export declare function toCamelEventName(name: string): string;
+/**
+ * Whether `event`, dispatched where it was, will arrive at `host` on its own.
+ *
+ * At the host itself: yes. From inside the host's shadow tree: only if it is
+ * composed (`input`, `click`, `focus` are; `change` is not). From a light-DOM
+ * descendant: only if it bubbles (`focus` / `blur` do not). From anywhere else
+ * (a document-level listener's event, say): no.
+ */
+export declare function reachesHost(event: Event, host: EventTarget): boolean;
+/**
+ * Attach the mono payload to a native event as its `detail`, keeping the
+ * browser's own value (a click count, an input's `detail` of 0) as `nativeDetail`.
+ */
+export declare function decorateEvent<T>(event: Event, detail: T): void;
+/**
+ * Dispatch a mono component event: the plain name (`change`), plus the
+ * `mno-change` / `mnoChange` aliases. Bubbling + composed, so every form crosses
+ * the shadow boundary. See the header for the plain name's decorate /
+ * synthesize rule.
+ *
+ *   dispatchMonoEvent(this, 'change', detail)                          // change + mno-change + mnoChange
+ *   dispatchMonoEvent(this, 'click', detail, { sourceEvent: event })   // decorates the native click; mno-click + mnoClick
+ *   dispatchMonoEvent(this, 'click', detail, { alias: 'toggle' })      // toggle + mno-click + mnoClick
+ *   dispatchMonoEvent(this, 'loading-change', detail)                  // loading-change + loadingChange + mno-loading-change + mnoLoadingChange
+ */
+export declare function dispatchMonoEvent<T>(target: EventTarget, name: string, detail: T, options?: MonoEventOptions): void;

package/dist/src/composables/mono-pending.d.ts

@@ -0,0 +1,8 @@
+import { LitElement } from 'lit';
+import { Constructor } from './hybird-prop';
+/**
+ * Applied to every registered element class by the mono `customElement` decorator.
+ * The property itself is registered separately (`registerPendingProperty`) so it lands in
+ * Lit's attribute map before `customElements.define`.
+ */
+export declare function withMonoPending<T extends Constructor<LitElement>>(superClass: T, tag: string): T;