@mono-lit/helper 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,45 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoModal_base: import('../../composables/hybird-prop').Constructor<import('./modal-core.js').MonoModalCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-modal` (the default build).
+ *
+ * Renders into a `<div data-mono-modal-portal>` appended to `<body>` (same
+ * pattern drawer uses — the only reliable way to escape transformed / filtered
+ * ancestors that would otherwise hijack the containing block of a
+ * `position: fixed` overlay). The portal div IS the `.mono-modal` root, so the
+ * shared markup from `MonoModalCore._renderModalBody()` is rendered straight
+ * into it; state classes + `--modal-z` are applied imperatively to the portal,
+ * and the head/title/subtitle/body/foot slots are captured from light-DOM children and
+ * re-parented into `[data-mono-slot]` placeholders. The SSR build lives in
+ * `mono-modal.shadow.ts`; all logic is shared via `MonoModalCore`.
+ */
+export declare class MonoModal extends MonoModal_base {
+    static styles: import('lit').CSSResult[];
+    private _portal;
+    private _appliedPortalClasses;
+    private _slotHead;
+    private _slotTitle;
+    private _slotSubtitle;
+    private _slotBody;
+    private _slotFoot;
+    /** `slot="header"` / `slot="footer"` — aliases that OUTRANK `head`/`foot`. */
+    private _slotHeaderAlias;
+    private _slotFooterAlias;
+    /** Detached parking for captured nodes that lost the alias contest. */
+    private _orphanHolder?;
+    protected createRenderRoot(): HTMLElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _updatePortalClasses;
+    private _updatePortalAttributes;
+    protected render(): TemplateResult;
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-modal': MonoModal;
+    }
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { LitElement, TemplateResult } from 'lit';
+import { ModalSlotName } from './modal-core.js';
+declare const MonoModalShadow_base: import('../../composables/hybird-prop').Constructor<import('./modal-core.js').MonoModalCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-modal` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/modal`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM. Unlike the light build (which renders into a `<body>`
+ * portal that IS the `.mono-modal` root), the shadow build can't portal — so it
+ * renders an inner `.mono-modal` root inside the shadow tree and carries the
+ * state classes + `--modal-z` there (mirrors `mono-dropdown.shadow.ts`'s inner
+ * root). The overlay/panel stay `position: fixed`; z-stacking / scroll-lock /
+ * Escape all flow through the SSR-safe `popup-stack`. Slots are native `<slot>`s
+ * (default = body), scanned in `firstUpdated`/`updated`. Shares all logic with
+ * the light build via `MonoModalCore`; both register `mono-modal`.
+ */
+export declare class MonoModalShadow extends MonoModalShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected get _slotsAlwaysRender(): boolean;
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    /** `string`, not `ModalSlotName` — this also resolves the alias names. */
+    private _slotFor;
+    private _defaultSlot;
+    private _slotHasContent;
+    private _onSlotChange;
+    /**
+     * Does this region have content under EITHER of its names? `head`/`foot` each
+     * also answer to an alias (`header`/`footer`), so presence is the union.
+     */
+    private _regionHasContent;
+    /** Reconcile the 4 slot-presence flags from their slots' assigned content.
+     *  Body is the default (unnamed) slot OR an explicit `slot="body"`. */
+    private _scanSlots;
+    /**
+     * Native `<slot>`. Body accepts both the default (unnamed) slot and an
+     * explicit `slot="body"` — matching the light build's capture, which treats
+     * unslotted children and `slot="body"` alike.
+     */
+    protected _slotOutlet(name: ModalSlotName, fallback?: unknown): TemplateResult;
+    /** Inline SVG — the global `.mono-icon`/`i-mdi-close` UnoCSS icon can't reach
+     *  a shadow root. */
+    protected renderIcon(_name: 'close'): TemplateResult;
+    /** Ids are scoped to this shadow root, so a constant is unique enough — and,
+     *  unlike a counter, the same on the server and the client. */
+    protected get _headingIdBase(): string;
+    protected render(): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,4 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoNav } from './mono-nav.js';
+export type { NavDensity, NavColor, NavVariant, NavCssClass, NavProps, NavEvents, } from './nav-types.js';
+export { getNavHeight, generateNavRootClasses, validateNavProps, } from './nav-utils.js';

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

@@ -0,0 +1,6 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoNavShadow } from './mono-nav.shadow.js';
+export { MonoNavCore } from './nav-core.js';
+export type { NavSlotName } from './nav-core.js';
+export type { NavDensity, NavColor, NavVariant, NavCssClass, NavProps, NavEvents, } from './nav-types.js';
+export { getNavHeight, generateNavRootClasses, validateNavProps, } from './nav-utils.js';

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

@@ -0,0 +1,41 @@
+import { LitElement } from 'lit';
+declare const MonoNav_base: import('../../composables/hybird-prop').Constructor<import('./nav-core.js').MonoNavCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-nav` (the default build, `@mono-lit/helper/ui/nav`).
+ *
+ * Renders into the host itself (`createRenderRoot` → `this`) so the global
+ * `dist/ui/index.css` styles it, and uses the light-DOM slot strategy: direct
+ * children are captured in `connectedCallback`, the chrome renders empty
+ * `[data-mono-slot]` targets, and the captured nodes are appended back in
+ * `updated()`. All render-mode-agnostic logic lives in `MonoNavCore`.
+ *
+ * The shadow-DOM build (`@mono-lit/helper/ui/shadow/nav`) shares `MonoNavCore` but
+ * uses a real shadow root + native `<slot>`. Both register the SAME tag, so a
+ * given document must load only one of the two builds.
+ */
+export declare class MonoNav extends MonoNav_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotsCaptured;
+    private _slotNodes;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    /**
+     * Pull every direct child into one of four buckets:
+     *  - `slot="start"`  → start
+     *  - `slot="end"`    → end
+     *  - `slot="extension"` → extension
+     *  - everything else (no slot attr) → default (center)
+     *
+     * Captured nodes are removed from the host root and re-inserted into the
+     * matching `[data-mono-slot]` target during `updated()`.
+     */
+    private _captureSlots;
+    private _placeSlots;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-nav': MonoNav;
+    }
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { LitElement, TemplateResult } from 'lit';
+import { NavSlotName } from './nav-core.js';
+declare const MonoNavShadow_base: import('../../composables/hybird-prop').Constructor<import('./nav-core.js').MonoNavCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-nav` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/nav`).
+ *
+ * Renders into a real shadow root (no `createRenderRoot` override), so:
+ *  - `@lit-labs/ssr` can serialize it to Declarative Shadow DOM on the server,
+ *  - styles are scoped via `static styles` (the `:host`-adapted nav sheet),
+ *  - slotting uses native `<slot>` instead of the light build's capture hack.
+ *
+ * Shares ALL behavior with the light build via `MonoNavCore`. Both register the
+ * SAME `mono-nav` tag, so a given document must load only one of the two builds
+ * (see plan/2026-06-23-shadow-dom-ssr-mixin-spike.md).
+ */
+export declare class MonoNavShadow extends MonoNavShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    protected renderSlot(slotName: NavSlotName): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,34 @@
+import { LitElement, TemplateResult } from 'lit';
+import { NavDensity, NavColor, NavVariant, NavCssClass } from './nav-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Slot regions the nav chrome lays out. `default` is the unnamed center slot. */
+export type NavSlotName = 'start' | 'default' | 'end' | 'extension';
+/**
+ * Public surface the core mixin adds. Declared so the mixin's type can be
+ * exported and so the light/shadow wrappers (and the tag map) see the API.
+ */
+export declare class MonoNavCoreInterface {
+    density: NavDensity;
+    color: NavColor;
+    variant: NavVariant;
+    sticky: boolean;
+    extension: boolean;
+    cssClass: NavCssClass;
+    cssClassName: string;
+    /** Resolved bar height in px, including the extension row when enabled. */
+    getHeight(): number;
+    /** Per-region slot content hook — overridden by the light/shadow wrappers. */
+    protected renderSlot(slotName: NavSlotName): TemplateResult;
+}
+/**
+ * `MonoNavCore` — every render-mode-agnostic concern for `mono-nav`:
+ * reactive props, the `css-class`/`cssclass` hybrid aliases, attribute
+ * observation, layout-var side effects, and the chrome `render()`.
+ *
+ * What it deliberately does NOT decide:
+ *  - `createRenderRoot()` (light vs shadow) — set by each wrapper.
+ *  - how styles apply (global sheet vs `static styles`) — set by each wrapper.
+ *  - the slot strategy — `renderSlot()` is a hook each wrapper overrides
+ *    (light: empty, nodes are captured/placed; shadow: native `<slot>`).
+ */
+export declare const MonoNavCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoNavCoreInterface> & T;

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

@@ -0,0 +1,48 @@
+/**
+ * Nav (top app bar) Component Type Definitions
+ */
+export type NavDensity = 'compact' | 'comfortable' | 'default';
+/**
+ * A theme palette slot, `surface` for the unpainted default, or any CSS color —
+ * `#7c3aed`, `rgb(124 58 237)`, `hsl(258 90% 66%)`.
+ *
+ * A slot name follows the active `.theme-color-*` preset automatically; a literal is
+ * carried inline and its ink is derived from its own luminance. Note `teal` and
+ * `purple` are CSS keywords too — the slot list is matched first, so they always mean
+ * the theme colour.
+ *
+ * The `(string & {})` arm keeps the slot names in editor autocomplete.
+ */
+export type NavColorToken = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark' | 'surface';
+export type NavColor = NavColorToken | (string & {}) | 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark' | 'surface';
+export type NavVariant = 'flat' | 'elevated' | 'outlined';
+export interface NavCssClass {
+    root?: string;
+    inner?: string;
+    start?: string;
+    center?: string;
+    end?: string;
+    extension?: string;
+}
+export interface NavProps {
+    /** Sticks the bar to the top of the viewport on scroll. */
+    sticky?: boolean;
+    /** Vertical spacing density of the bar. */
+    density?: NavDensity;
+    /** Theme color of the bar background. */
+    color?: NavColor;
+    /** Visual style of the bar (flat, elevated, or outlined). */
+    variant?: NavVariant;
+    /** Renders an additional extension row below the bar. */
+    extension?: boolean;
+    /** Per-part class overrides for internal elements. */
+    cssClass?: NavCssClass;
+    cssclass?: NavCssClass;
+    'css-class'?: NavCssClass | string;
+}
+/**
+ * Nav emits no events of its own — slotted buttons drive behavior.
+ * Type kept for symmetry with other components but intentionally empty.
+ */
+export interface NavEvents {
+}

package/dist/src/components/nav/nav-utils.d.ts

@@ -0,0 +1,12 @@
+import { NavDensity, NavProps } from './nav-types.js';
+export declare function getNavHeight(density: NavDensity): number;
+export declare function generateNavRootClasses(props: {
+    density: NavDensity;
+    color: string;
+    variant: string;
+    sticky: boolean;
+    extension: boolean;
+    rootExtra?: string;
+    cssClassName?: string;
+}): string;
+export declare function validateNavProps(props: NavProps): string[];

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

@@ -0,0 +1,4 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoRadio } from './mono-radio.js';
+export type { RadioSize, RadioColor, RadioProps, RadioEvents } from './radio-types.js';
+export { validateRadioProps, generateRadioAttributes } from './radio-utils.js';

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

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoRadioShadow } from './mono-radio.shadow.js';
+export { MonoRadioCore } from './radio-core.js';
+export type { RadioSize, RadioColor, RadioProps, RadioEvents, } from './radio-types.js';
+export { validateRadioProps, generateRadioAttributes, } from './radio-utils.js';

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

@@ -0,0 +1,31 @@
+import { LitElement } from 'lit';
+declare const MonoRadio_base: import('../../composables/hybird-prop').Constructor<import('./radio-core.js').MonoRadioCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-radio` (default build, `@mono-lit/helper/ui/radio`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`). The `slot="label"`/`slot="description"` children use the
+ * light-DOM strategy: captured in `connectedCallback`, the template renders empty
+ * `[data-mono-slot]` targets (via the core's default `_renderLabelBlock`), and the
+ * captured nodes are re-placed in `updated()`. All render-mode-agnostic logic
+ * lives in `MonoRadioCore`. The shadow build (`@mono-lit/helper/ui/shadow/radio`)
+ * shares the mixin but uses native `<slot>`. Both register `mono-radio`, so a
+ * document loads only one.
+ */
+export declare class MonoRadio extends MonoRadio_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotsCaptured;
+    private _slotLabel;
+    private _slotDescription;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-radio': MonoRadio;
+    }
+}
+export {};

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

@@ -0,0 +1,35 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+declare const MonoRadioShadow_base: import('../../composables/hybird-prop').Constructor<import('./radio-core.js').MonoRadioCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-radio` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/radio`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM and styles are scoped (`mono-radio`→`:host`). The radio
+ * circle + dot are pure CSS, and the selected state is the `mono-radio-checked`
+ * wrapper class, so the checked state server-renders from `this.modelValue ===
+ * this.value` (no icons, no input-attribute concerns). The `label`/`description`
+ * slots carry the prop text as native fallback (shown server-side); slot presence
+ * is detected in `firstUpdated()` via `assignedNodes()` (DSD assigns at parse time
+ * → no `slotchange` after upgrade). Interactivity needs the first client update to
+ * flush (so `@change` binds) — hence the defer-hydration poll. Shares all logic
+ * with the light build via `MonoRadioCore`; both register `mono-radio`, so a
+ * document loads one.
+ */
+export declare class MonoRadioShadow extends MonoRadioShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _slotFor;
+    private _slotHasContent;
+    private _onSlotChange;
+    /**
+     * The sublabel region answers to `slot="sublabel"` and to the older
+     * `slot="description"` (nested inside it), so its presence is the union.
+     */
+    private _sublabelHasContent;
+    private _setSlotState;
+    private _scanSlots;
+    protected _renderLabelBlock(): TemplateResult | typeof nothing;
+}
+export {};

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

@@ -0,0 +1,45 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+import { RadioSize, RadioColor, RadioValue, RadioCssClass } from './radio-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoRadioCoreInterface {
+    size: RadioSize;
+    color: RadioColor;
+    value: RadioValue;
+    modelValue: RadioValue;
+    disabled: boolean;
+    label: string;
+    /** Secondary line under the label. */
+    sublabel: string;
+    /** The same as `sublabel`, kept for existing code. */
+    description: string;
+    ariaLabelText?: string;
+    cssClass: RadioCssClass;
+    cssClassName: string;
+    focus(): void;
+    blur(): void;
+    protected _hasLabelSlotState: boolean;
+    protected _hasDescriptionSlotState: boolean;
+    protected _setCssClass(value: unknown): void;
+    protected _toRadioValue(value: unknown): RadioValue;
+    protected _cls(base: string, key: keyof RadioCssClass): string;
+    protected get _checked(): boolean;
+    protected get _wrapperClasses(): string;
+    protected _hasLabelContent(): boolean;
+    protected _hasDescriptionContent(): boolean;
+    protected _handleChange(event: Event): void;
+    protected _renderLabelBlock(): TemplateResult | typeof nothing;
+}
+/**
+ * `MonoRadioCore` — all render-mode-agnostic logic for `mono-radio`: reactive
+ * props (incl. SSR `disabled` coercion), hybrid aliases (incl. the
+ * `ariaLabel`/`aria-label`/`arialabel` → `ariaLabelText` getters), camelCase
+ * attribute fallbacks, class computation, the `mno-change` interactivity, and the
+ * shared `<label><input><circle><dot></circle><labelBlock></label>` `render()`
+ * (the radio dot is pure CSS — no icons). Only the label/description region is a
+ * hook (`_renderLabelBlock`) — the light build uses `data-mono-slot`, the shadow
+ * build native `<slot>` (mirrors `mono-checkbox`).
+ *
+ * SSR-safe: no `document`/`window` access; `focus`/`blur` query `this.renderRoot`.
+ */
+export declare const MonoRadioCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoRadioCoreInterface> & T;

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

@@ -0,0 +1,58 @@
+import { VisibilityProps } from '../../composables/visibility';
+export type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type RadioColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+export type RadioValue = string | number | boolean | null;
+export interface RadioCssClass {
+    root?: string;
+    input?: string;
+    circle?: string;
+    dot?: string;
+    label?: string;
+    labelText?: string;
+    description?: string;
+}
+export type RadioModelEventDetail<TValue = RadioValue> = {
+    modelValue: TValue;
+    currentValue: TValue;
+    oldValue: TValue;
+    value: TValue;
+    checked: boolean;
+    sourceEvent?: Event;
+};
+export type RadioModelEvent<TValue = RadioValue> = CustomEvent<RadioModelEventDetail<TValue>>;
+export interface RadioProps extends VisibilityProps {
+    /** The value this radio represents within its group. */
+    value?: RadioValue;
+    /** The currently selected value of the radio group. */
+    modelValue?: RadioValue;
+    'model-value'?: RadioValue;
+    modelvalue?: RadioValue;
+    /** Color theme applied to the radio. */
+    color?: RadioColor;
+    /** Visual size of the radio. */
+    size?: RadioSize;
+    /** Disables the radio, preventing selection. */
+    disabled?: boolean;
+    /** Text label shown beside the radio. */
+    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;
+    /** Custom CSS classes applied to internal radio parts. */
+    cssClass?: RadioCssClass;
+    cssclass?: RadioCssClass;
+    'css-class'?: RadioCssClass | string;
+    /** Accessible label used when no visible label is present. */
+    ariaLabelText?: string;
+    ariaLabel?: string;
+    'aria-label'?: string;
+    'aria-label-text'?: string;
+    arialabel?: string;
+    arialabeltext?: string;
+}
+export interface RadioEvents {
+    change: RadioModelEvent;
+    'mno-change': RadioModelEvent;
+    mnoChange: RadioModelEvent;
+}

package/dist/src/components/radio/radio-utils.d.ts

@@ -0,0 +1,12 @@
+import { RadioSize, RadioColor } from './radio-types.js';
+/**
+ * Validate radio props
+ */
+export declare function validateRadioProps(props: {
+    size?: RadioSize;
+    color?: RadioColor;
+}): boolean;
+/**
+ * Generate ARIA attributes for accessibility
+ */
+export declare function generateRadioAttributes(disabled: boolean, checked: boolean, label: string | undefined): Record<string, string | boolean | undefined>;

package/dist/src/components/rich-text-editor/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoRichTextEditor } from './mono-rich-text-editor.js';
+export { loadSunEditor, loadSunEditorCss, loadSunEditorLang, loadSunEditorPlugins, SUNEDITOR_LANG_CODES, } from './rich-text-editor-loader.js';
+export { TOOLBAR_BASIC, TOOLBAR_STANDARD, TOOLBAR_FULL, TOOLBAR_DEFAULT, TOOLBAR_PRESETS, SUNEDITOR_CORE_BUTTONS, AUTO_EXCLUDED_PLUGINS, resolveToolbar, resolvePlugins, pruneToolbar, } from './rich-text-editor-toolbar.js';
+export type { RichTextEditorSize, RichTextEditorColor, RichTextEditorVariant, RichTextEditorValidationState, RichTextEditorMode, RichTextEditorToolbar, RichTextEditorToolbarPreset, RichTextEditorButtonList, RichTextEditorPlugins, RichTextEditorInstance, RichTextEditorOptions, RichTextEditorCssClass, RichTextEditorModelEventDetail, RichTextEditorModelEvent, RichTextEditorReadyEventDetail, RichTextEditorErrorEventDetail, RichTextEditorFocusEventDetail, RichTextEditorProps, RichTextEditorEvents, } from './rich-text-editor-types.js';

package/dist/src/components/rich-text-editor/index.shadow.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoRichTextEditorShadow } from './mono-rich-text-editor.shadow.js';
+export { MonoRichTextEditorCore, type RichTextEditorSlotName } from './rich-text-editor-core.js';
+export { loadSunEditor, loadSunEditorCss, loadSunEditorLang, loadSunEditorPlugins, SUNEDITOR_LANG_CODES, } from './rich-text-editor-loader.js';
+export { TOOLBAR_BASIC, TOOLBAR_STANDARD, TOOLBAR_FULL, TOOLBAR_DEFAULT, TOOLBAR_PRESETS, SUNEDITOR_CORE_BUTTONS, AUTO_EXCLUDED_PLUGINS, resolveToolbar, resolvePlugins, pruneToolbar, } from './rich-text-editor-toolbar.js';
+export type { RichTextEditorSize, RichTextEditorColor, RichTextEditorVariant, RichTextEditorValidationState, RichTextEditorMode, RichTextEditorToolbar, RichTextEditorToolbarPreset, RichTextEditorButtonList, RichTextEditorPlugins, RichTextEditorInstance, RichTextEditorOptions, RichTextEditorCssClass, RichTextEditorModelEventDetail, RichTextEditorModelEvent, RichTextEditorReadyEventDetail, RichTextEditorErrorEventDetail, RichTextEditorFocusEventDetail, RichTextEditorProps, RichTextEditorEvents, } from './rich-text-editor-types.js';

package/dist/src/components/rich-text-editor/mono-rich-text-editor.d.ts

@@ -0,0 +1,31 @@
+import { LitElement } from 'lit';
+declare const MonoRichTextEditor_base: import('../../composables/hybird-prop').Constructor<import('./rich-text-editor-core.js').MonoRichTextEditorCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-rich-text-editor` (default build, `@mono-lit/helper/ui/rich-text-editor`).
+ *
+ * `createRenderRoot()` returns `this`, so it renders into light DOM and inherits
+ * the page's global stylesheet — which is also where SunEditor's own sheet
+ * lives. Named slots (label/helper) are captured from the light-DOM children in
+ * `connectedCallback` and re-parented into the rendered `data-mono-slot`
+ * placeholders in `updated()`; the editor mount is re-homed into the field frame
+ * the same way by the core (`_placeMount`). All render-mode-agnostic logic is
+ * shared with the shadow build (`@mono-lit/helper/ui/shadow/rich-text-editor`) via
+ * `MonoRichTextEditorCore`.
+ */
+export declare class MonoRichTextEditor extends MonoRichTextEditor_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotsCaptured;
+    private _slotLabel;
+    private _slotHelper;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-rich-text-editor': MonoRichTextEditor;
+    }
+}
+export {};

package/dist/src/components/rich-text-editor/mono-rich-text-editor.shadow.d.ts

@@ -0,0 +1,34 @@
+import { LitElement, TemplateResult } from 'lit';
+import { RichTextEditorSlotName } from './rich-text-editor-core.js';
+declare const MonoRichTextEditorShadow_base: import('../../composables/hybird-prop').Constructor<import('./rich-text-editor-core.js').MonoRichTextEditorCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-rich-text-editor` (the opt-in SSR build,
+ * `@mono-lit/helper/ui/shadow/rich-text-editor`).
+ *
+ * Real shadow root + `static styles` for the CHROME (label, frame, messages),
+ * serialised to Declarative Shadow DOM by `@lit-labs/ssr`. The EDITOR itself is
+ * never in the shadow root: SunEditor's stylesheet is global and its modals are
+ * parked on `<body>`, so the core keeps the mount as a light child of the host
+ * and this build projects it through `<slot name="editor">` — the page sheet
+ * styles it, and the `--se-*` remap declared on the frame still reaches it
+ * through the flat tree. On the server the slot is empty (an editor is client
+ * state); the first client update builds it.
+ */
+export declare class MonoRichTextEditorShadow extends MonoRichTextEditorShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected get _slotsAlwaysRender(): boolean;
+    protected get _useNativeSlots(): boolean;
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _slotFor;
+    private _slotHasContent;
+    private _onSlotChange;
+    /** Reconcile the 2 slot-presence flags from their slots' assigned content. */
+    private _scanSlots;
+    /** Native `<slot>` carrying the prop fallback as native slot content. */
+    protected _slotOutlet(name: RichTextEditorSlotName, fallback?: unknown): TemplateResult;
+    /** The frame projects the light-DOM mount the core keeps on the host. */
+    protected _renderEditorOutlet(fieldClass: string): TemplateResult;
+}
+export {};