@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/reactive-D3EERqgO.js

@@ -0,0 +1,47 @@
+//#region src/composables/reactive.ts
+/**
+* Unwrap a `ref()` / `computed()` wrapper and a `reactive()` proxy to the raw
+* target underneath. Returns the value unchanged when it isn't reactive.
+*/
+function unwrapReactive(value) {
+	let out = value;
+	if (out && typeof out === "object" && out.__v_isRef) out = out.value;
+	if (out && typeof out === "object" && out.__v_raw) out = out.__v_raw;
+	return out;
+}
+/**
+* Read a {@link MaybeReactive} option: call a getter, unwrap a ref/computed or a
+* reactive proxy, unbox a plain `{ value }`. Never caches — the caller decides
+* when "now" is.
+*/
+function resolveMaybeReactive(option) {
+	if (option === void 0 || option === null) return void 0;
+	if (typeof option === "function") return option();
+	const raw = unwrapReactive(option);
+	if (raw && typeof raw === "object") {
+		const keys = Object.keys(raw);
+		if (keys.length === 1 && keys[0] === "value") return unwrapReactive(raw.value);
+	}
+	return raw;
+}
+/**
+* {@link unwrapReactive}, then — for an **array** — unwrap each element too.
+*
+* Reading an index off a deep-reactive array yields a proxy of that element, so
+* unwrapping only the container still leaves proxies inside. One level of
+* elements is all the value models here need; this deliberately does not recurse
+* into nested objects, which would rewrite data the consumer owns.
+*/
+function unwrapReactiveDeep(value) {
+	const out = unwrapReactive(value);
+	if (!Array.isArray(out)) return out;
+	let changed = false;
+	const items = out.map((item) => {
+		const raw = unwrapReactive(item);
+		if (raw !== item) changed = true;
+		return raw;
+	});
+	return changed ? items : out;
+}
+//#endregion
+export { unwrapReactive as n, unwrapReactiveDeep as r, resolveMaybeReactive as t };

package/dist/search.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/search.js

@@ -0,0 +1,97 @@
+//#region src/search/odata-search.ts
+var INTEGER_TYPES = {
+	"Edm.Byte": true,
+	"Edm.SByte": true,
+	"Edm.Int16": true,
+	"Edm.Int32": true,
+	"Edm.Int64": true
+};
+var DECIMAL_TYPES = {
+	"Edm.Decimal": true,
+	"Edm.Double": true,
+	"Edm.Single": true
+};
+var CASE_FOLD_TERM = "Mono.Search.CaseFold";
+function childElements(element, name) {
+	return Array.from(element.children).filter((child) => child.localName === name);
+}
+function metadataDocument(metadata) {
+	if (typeof metadata !== "string") return metadata;
+	if (typeof DOMParser === "undefined") throw new Error("odataSearchExpr requires DOMParser when metadata is XML text.");
+	const document = new DOMParser().parseFromString(metadata, "application/xml");
+	if (document.querySelector("parsererror")) throw new Error("odataSearchExpr received invalid OData metadata.");
+	return document;
+}
+function entityTypeOf(document, requested) {
+	const separator = requested.lastIndexOf(".");
+	const namespace = separator < 0 ? null : requested.slice(0, separator);
+	const name = separator < 0 ? requested : requested.slice(separator + 1);
+	return Array.from(document.getElementsByTagNameNS("*", "EntityType")).find((entity) => entity.getAttribute("Name") === name && (!namespace || entity.parentElement?.getAttribute("Namespace") === namespace)) ?? null;
+}
+function odataLiteral(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+function caseFoldEnabled(document, entity, field) {
+	const inline = childElements(childElements(entity, "Property").find((property) => property.getAttribute("Name") === field) ?? entity, "Annotation");
+	const entityName = entity.getAttribute("Name");
+	const namespace = entity.parentElement?.getAttribute("Namespace");
+	const target = namespace && entityName ? `${namespace}.${entityName}/${field}` : null;
+	const external = target ? Array.from(document.getElementsByTagNameNS("*", "Annotations")).filter((annotations) => annotations.getAttribute("Target") === target).flatMap((annotations) => childElements(annotations, "Annotation")) : [];
+	return [...inline, ...external].find((candidate) => candidate.getAttribute("Term") === CASE_FOLD_TERM)?.getAttribute("Bool") !== "false";
+}
+function numericClause(field, type, value) {
+	const literal = value.trim();
+	if (INTEGER_TYPES[type] && /^[+-]?\d+$/.test(literal)) return `${field} eq ${literal}`;
+	if (DECIMAL_TYPES[type] && /^[+-]?(?:\d+|\d*\.\d+)$/.test(literal)) return `${field} eq ${literal}`;
+	return null;
+}
+/**
+* Compile selected CSDL properties into the grid's existing `searchExpr` contract.
+*
+* Strings retain case-insensitive matching unless the service annotates the property
+* with `Mono.Search.CaseFold=false`; numeric EDM properties accept a complete numeric
+* input as equality. Unsupported EDM types do not generate invalid text predicates.
+*/
+function odataSearchExpr(options) {
+	const document = metadataDocument(options.metadata);
+	const entity = entityTypeOf(document, options.entityType);
+	if (!entity) throw new Error(`odataSearchExpr could not find entity type "${options.entityType}" in metadata.`);
+	const properties = /* @__PURE__ */ new Map();
+	let owner = entity;
+	while (owner) {
+		for (const property of childElements(owner, "Property")) {
+			const name = property.getAttribute("Name");
+			if (name && !properties.has(name)) properties.set(name, {
+				property,
+				owner
+			});
+		}
+		const baseType = owner.getAttribute("BaseType");
+		owner = baseType ? entityTypeOf(document, baseType) : null;
+	}
+	const entries = [];
+	for (const field of options.fields) {
+		const entry = properties.get(field);
+		const type = entry?.property.getAttribute("Type");
+		if (!entry || !type) continue;
+		if (type === "Edm.String") {
+			const fold = caseFoldEnabled(document, entry.owner, field);
+			entries.push({
+				field,
+				custom: ({ value, operation }) => {
+					if (operation !== "contains") return null;
+					const literal = odataLiteral(fold ? value.toLocaleLowerCase() : value);
+					return fold ? `contains(tolower(${field}),${literal})` : `contains(${field},${literal})`;
+				}
+			});
+			continue;
+		}
+		if (INTEGER_TYPES[type] || DECIMAL_TYPES[type]) entries.push({
+			field,
+			custom: ({ value, operation }) => operation === "contains" ? numericClause(field, type, value) : null
+		});
+	}
+	return entries;
+}
+//#endregion
+export { odataSearchExpr };

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

@@ -0,0 +1,62 @@
+import { LitElement } from 'lit';
+import { AccordionSize, AccordionColor, AccordionCssClass } from './accordion-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/**
+ * Slot regions the accordion lays out. `default` is the unnamed body region.
+ * `title` / `subtitle` are canonical; `label` / `description` are their old
+ * names, still accepted (the canonical name wins when both are given).
+ * `header` replaces the title + subtitle text as a whole.
+ */
+export type AccordionSlotName = 'title' | 'subtitle' | 'label' | 'description' | 'header' | 'icon' | 'actions' | 'default';
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoAccordionCoreInterface {
+    size: AccordionSize;
+    color: AccordionColor;
+    /** Header headline. `label` is the old name, kept as an alias. */
+    title: string;
+    /** Header secondary line. `description` is the old name, kept as an alias. */
+    subtitle: string;
+    /** @deprecated alias of `title` */
+    label: string;
+    /** @deprecated alias of `subtitle` */
+    description: string;
+    modelValue: boolean;
+    disabled: boolean;
+    cssClass: AccordionCssClass;
+    cssClassName: string;
+    toggle(): void;
+    expand(): void;
+    collapse(): void;
+    focus(): void;
+    blur(): void;
+    protected _hasTitleSlotState: boolean;
+    protected _hasSubtitleSlotState: boolean;
+    protected _hasHeaderSlotState: boolean;
+    protected _hasIconSlotState: boolean;
+    protected _hasActionsSlotState: boolean;
+    protected _hasBodySlotState: boolean;
+    protected _headEl?: HTMLButtonElement;
+    protected _cls(base: string, key: keyof AccordionCssClass): string;
+    protected get _wrapperClasses(): string;
+    /** Ref for the root each build renders — where the styling attributes go. */
+    protected bindRoot: (el: Element | undefined) => void;
+    protected _computeRootAttrs(): Record<string, string | null>;
+    protected _applyRootAttrs(root: HTMLElement | null | undefined): void;
+    protected get _hasTitleContent(): boolean;
+    protected get _hasSubtitleContent(): boolean;
+    protected get _hasIconContent(): boolean;
+    protected _setCssClass(value: unknown): void;
+    protected _handleClick(event: Event): void;
+}
+/**
+ * `MonoAccordionCore` — all render-mode-agnostic logic for `mono-accordion`:
+ * reactive props, hybrid aliases, the camelCase attribute fallbacks, slot-presence
+ * `@state`, class/getter computation, click/toggle interactivity, and the
+ * imperative `focus/blur`. No `render()` — the light build keeps its
+ * `[data-mono-slot]` capture strategy and the shadow build uses native `<slot>`
+ * (each ships its own `render()`, mirroring `mono-card`).
+ *
+ * SSR-safe: no `document`/`window` access. `_headEl` (`@query`) is lazy and
+ * `focus/blur` only run client-side.
+ */
+export declare const MonoAccordionCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoAccordionCoreInterface> & T;

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

@@ -0,0 +1,62 @@
+/**
+ * Accordion Component Type Definitions
+ */
+export type AccordionSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type AccordionColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+export interface AccordionCssClass {
+    root?: string;
+    head?: string;
+    icon?: string;
+    title?: string;
+    /** The secondary line (`[mono-subtitle]`). The key keeps its original name. */
+    description?: string;
+    actions?: string;
+    arrow?: string;
+    body?: string;
+}
+export type AccordionClickEventDetail = {
+    modelValue: boolean;
+    currentValue: boolean;
+    oldValue: boolean;
+    value: boolean;
+    sourceEvent?: Event;
+};
+export type AccordionClickEvent = CustomEvent<AccordionClickEventDetail>;
+export interface AccordionProps {
+    /**
+     * Title text shown in the accordion header. `slot="title"` replaces it, and
+     * `slot="header"` replaces the icon, title and subtitle together.
+     */
+    title?: string;
+    /** Secondary text shown under the title. `slot="subtitle"` replaces it. */
+    subtitle?: string;
+    /** @deprecated Old name of `title`, still accepted. */
+    label?: string;
+    /** @deprecated Old name of `subtitle`, still accepted. */
+    description?: string;
+    /** Bound open state; true when the accordion is expanded. */
+    modelValue?: boolean;
+    'model-value'?: boolean;
+    modelvalue?: boolean;
+    /** Disables interaction and dims the accordion. */
+    disabled?: boolean;
+    /** Visual size of the accordion. */
+    size?: AccordionSize;
+    /** Color theme of the accordion. */
+    color?: AccordionColor;
+    /** Per-element class overrides. */
+    cssClass?: AccordionCssClass;
+    cssclass?: AccordionCssClass;
+    'css-class'?: AccordionCssClass | string;
+}
+export interface AccordionEvents {
+    toggle: AccordionClickEvent;
+    open: AccordionClickEvent;
+    close: AccordionClickEvent;
+    'mno-click': AccordionClickEvent;
+    mnoClick: AccordionClickEvent;
+    'mno-open': AccordionClickEvent;
+    mnoOpen: AccordionClickEvent;
+    'mno-close': AccordionClickEvent;
+    mnoClose: AccordionClickEvent;
+}

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

@@ -0,0 +1,3 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoAccordion } from './mono-accordion.js';
+export type { AccordionSize, AccordionColor, AccordionCssClass, AccordionClickEventDetail, AccordionClickEvent, AccordionProps, AccordionEvents, } from './accordion-types.js';

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

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoAccordionShadow } from './mono-accordion.shadow.js';
+export { MonoAccordionCore } from './accordion-core.js';
+export type { AccordionSlotName } from './accordion-core.js';
+export type { AccordionSize, AccordionColor, AccordionCssClass, AccordionClickEventDetail, AccordionClickEvent, AccordionProps, AccordionEvents, } from './accordion-types.js';

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

@@ -0,0 +1,55 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoAccordion_base: import('../../composables/hybird-prop').Constructor<import('./accordion-core.js').MonoAccordionCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-accordion` (default build, `@mono-lit/helper/ui/accordion`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`) with the light-DOM slot strategy: `slot="…"` 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 `MonoAccordionCore`. The shadow build
+ * (`@mono-lit/helper/ui/shadow/accordion`) shares the mixin but uses native `<slot>`.
+ * Both register `mono-accordion`, so a document loads only one.
+ */
+export declare class MonoAccordion extends MonoAccordion_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotObserver?;
+    private _slotTitle;
+    private _slotLabel;
+    private _slotSubtitle;
+    private _slotDescription;
+    private _slotHeader;
+    private _slotIcon;
+    private _slotActions;
+    private _slotBody;
+    /** Hidden detached holder for captured nodes that have no rendered target. */
+    private _parked?;
+    /** The title nodes that render: `slot="title"` beats its alias `slot="label"`. */
+    private get _titleNodes();
+    /** The subtitle nodes that render: `slot="subtitle"` beats `slot="description"`. */
+    private get _subtitleNodes();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _renderIcon;
+    private _renderText;
+    private _renderActions;
+    private _renderBody;
+    protected render(): TemplateResult;
+    /**
+     * Capture `slot="…"` named children + the unnamed/default body content into the
+     * per-region arrays. Safe to run MORE THAN ONCE: captured nodes are detached
+     * from the host (and named ones lose their `slot` attribute), so a re-scan never
+     * re-captures them — and the Lit-rendered wrapper (`.mono-accordion`) is skipped.
+     * Re-running lets the MutationObserver pick up children Vue appends after connect.
+     */
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-accordion': MonoAccordion;
+    }
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoAccordionShadow_base: import('../../composables/hybird-prop').Constructor<import('./accordion-core.js').MonoAccordionCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-accordion` (the opt-in SSR build,
+ * `@mono-lit/helper/ui/shadow/accordion`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM and styles are scoped (`mono-accordion`→`:host`).
+ * Slotting uses native `<slot>`. During SSR the element has no light children, so
+ * the slot-presence flags default `false` (hydration-matching) and the decorative
+ * regions render `mono-empty` (hidden by accordion.css itself); real presence is
+ * corrected in `firstUpdated()` (DSD assigns slotted content at parse time →
+ * `slotchange` doesn't fire after upgrade → scan `assignedNodes()`; `slotchange` is
+ * kept for later dynamic changes). `<slot name="label">${label}</slot>` carries the
+ * prop text as native fallback so it shows with no JS. The body region is always
+ * visible so main content never flashes. Shares all logic with the light build via
+ * `MonoAccordionCore`. Both register `mono-accordion`, so a document loads one.
+ */
+export declare class MonoAccordionShadow extends MonoAccordionShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    /**
+     * Presence of a region that may also answer to an old name (`label` →
+     * `title`, `description` → `subtitle`): the union of both slots.
+     */
+    private _regionHasContent;
+    /**
+     * `<slot name="title"><slot name="label">fallback</slot></slot>` — a slot's
+     * children are its fallback, shown only when nothing is assigned to it, so the
+     * canonical name wins and the old name is reached exactly when it is empty.
+     * Both slots recompute presence from BOTH names (an empty outer `slotchange`
+     * must not clear a filled inner one).
+     */
+    private _renderAliasedSlot;
+    private _slotFor;
+    /**
+     * Whether something is ASSIGNED to this slot. Not `assignedNodes({ flatten:
+     * true })`: for a slot with nothing assigned, flatten returns its FALLBACK
+     * content — and `<slot name="header">`'s fallback is the title/subtitle
+     * markup, so every accordion looked like it had a header slot and hid its
+     * icon. The old alias names (`label` / `description`) are nested slots of
+     * their own and are checked separately by the caller.
+     */
+    private _slotHasContent;
+    private _setSlotState;
+    private _onSlotChange;
+    private _renderIcon;
+    private _renderText;
+    private _renderActions;
+    private _renderBody;
+    /** Body presence: the named `body` slot or the default slot. */
+    private _bodyHasContent;
+    protected render(): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+import { AlertColor, AlertCssClass, AlertSize, AlertVariant } from './alert-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Regions the alert lays out. `body` also takes the unslotted children. */
+export type AlertSlotName = 'icon' | 'title' | 'subtitle' | 'body';
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoAlertCoreInterface {
+    /** The headline. */
+    title: string;
+    /** The line under the title. */
+    subtitle: string;
+    /** Leading icon — an iconify class or plain text. */
+    icon: string;
+    color: AlertColor;
+    variant: AlertVariant;
+    size: AlertSize;
+    /** Show the ✕ that hides the alert. */
+    clearable: boolean;
+    /** Same as `clearable`. */
+    closeable: boolean;
+    clearLabel: string;
+    cssClass: AlertCssClass;
+    protected _hasIconSlot: boolean;
+    protected _hasTitleSlot: boolean;
+    protected _hasSubtitleSlot: boolean;
+    protected _hasBodySlot: boolean;
+    protected _cls(base: string, key: keyof AlertCssClass): string;
+    protected get _showsIcon(): boolean;
+    protected get _showsTitle(): boolean;
+    protected get _showsSubtitle(): boolean;
+    protected _renderIconGlyph(): TemplateResult | typeof nothing;
+    protected _renderMain(): unknown;
+}
+/**
+ * `MonoAlertCore` — everything both builds share: props (with the `closeable`
+ * alias), the ✕ that hides the alert, and the root template. The regions are
+ * one overridable hook, `_renderMain()`: the light build fills `[data-mono-slot]`
+ * placeholders, the shadow build uses native `<slot>`s.
+ *
+ * The alert emits NO events of its own. `@click` on it is the browser's click;
+ * the ✕ only hides the element (the native `hidden` attribute), and stops its
+ * own click so a listener on the alert does not fire for it.
+ *
+ * SSR-safe: no `document`/`window` access.
+ */
+export declare const MonoAlertCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoAlertCoreInterface> & T;

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

@@ -0,0 +1,44 @@
+/** Scale step. `md` is Basecoat's alert; the rest scale it (see alert.css). */
+export type AlertSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+/** The same four looks as mono-button. `outline` is Basecoat's alert. */
+export type AlertVariant = 'outline' | 'solid' | 'tonal' | 'text';
+export type AlertColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+/** Extra classes per part (`cssClass`), e.g. `{ title: 'font-bold' }`. */
+export interface AlertCssClass {
+    root?: string;
+    icon?: string;
+    title?: string;
+    subtitle?: string;
+    body?: string;
+    clear?: string;
+}
+export interface AlertProps {
+    /** The headline. `slot="title"` replaces it. */
+    title?: string;
+    /** The line under the title. `slot="subtitle"` replaces it. */
+    subtitle?: string;
+    /**
+     * The leading icon: an iconify class (`i-mdi-information-outline`) or plain
+     * text (an emoji, a letter). `slot="icon"` replaces it.
+     */
+    icon?: string;
+    /** Colour role. `neutral` (default) is Basecoat's plain alert. */
+    color?: AlertColor;
+    /** `outline` (default, Basecoat's look), `tonal`, `solid` or `text`. */
+    variant?: AlertVariant;
+    /** Scale step, `xs` → `xxl`. Default `md`. */
+    size?: AlertSize;
+    /**
+     * Show a ✕ that hides the alert (it sets the element's own `hidden`
+     * attribute). The ✕ stays when `slot="body"` replaces the rest.
+     */
+    clearable?: boolean;
+    /** Same as `clearable`. */
+    closeable?: boolean;
+    /** Accessible name of the ✕. Default `'Close'`. */
+    clearLabel?: string;
+    'clear-label'?: string;
+    /** Extra classes per part. */
+    cssClass?: AlertCssClass;
+    'css-class'?: AlertCssClass;
+}

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

@@ -0,0 +1,3 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoAlert } from './mono-alert.js';
+export type { AlertSize, AlertVariant, AlertColor, AlertCssClass, AlertProps, } from './alert-types.js';

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

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoAlertShadow } from './mono-alert.shadow.js';
+export { MonoAlertCore } from './alert-core.js';
+export type { AlertSlotName } from './alert-core.js';
+export type { AlertSize, AlertVariant, AlertColor, AlertCssClass, AlertProps, } from './alert-types.js';

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

@@ -0,0 +1,44 @@
+import { LitElement } from 'lit';
+declare const MonoAlert_base: import('../../composables/hybird-prop').Constructor<import('./alert-core.js').MonoAlertCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-alert` (default build, `@mono-lit/helper/ui/alert`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`) with the light-DOM slot strategy of `mono-card`:
+ * `slot="icon|title|subtitle|body"` children — and unslotted ones, which are the
+ * body — are captured in `connectedCallback`, the template renders empty
+ * `[data-mono-slot]` regions, and the captured nodes are re-appended in
+ * `updated()`. The first render is forced SYNCHRONOUSLY so a framework's
+ * positional anchors are never observably detached (see mono-card).
+ *
+ * The body wins: when it has content the icon / title / subtitle regions are not
+ * rendered, and their captured nodes are parked (kept parented, invisible).
+ */
+export declare class MonoAlert extends MonoAlert_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotsCaptured;
+    private _buckets;
+    private _parked?;
+    /**
+     * The body region is ALWAYS rendered (like the card's): it is also the home
+     * of the consumer framework's positional anchors (`<!--v-if-->`), which must
+     * keep a live, visible parent — content a `v-if` inserts there later has to
+     * show up. It is `mono-empty` while it holds nothing but anchors, and a
+     * MutationObserver flips `_hasBodySlot` when real content arrives or leaves.
+     */
+    protected _renderMain(): unknown;
+    private _bodyObserver?;
+    /** Re-read body presence from the placed region (late `v-if` content). */
+    private _watchBody;
+    disconnectedCallback(): void;
+    connectedCallback(): void;
+    private _captureSlots;
+    protected updated(changed: Map<string, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-alert': MonoAlert;
+    }
+}
+export {};

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

@@ -0,0 +1,34 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+declare const MonoAlertShadow_base: import('../../composables/hybird-prop').Constructor<import('./alert-core.js').MonoAlertCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM alert (the opt-in SSR build, `@mono-lit/helper/ui/shadow/alert`).
+ *
+ * Registered as `<mono-shadow-alert>` — a distinct tag from the light build's
+ * `<mono-alert>` — so both can load side by side. Every region is rendered up
+ * front with its prop as the native slot fallback, and the empty ones are marked
+ * `[mono-empty]` (alert.css hides them). The body is `slot="body"` AND the
+ * unnamed default slot; when either has content it replaces the icon, title and
+ * subtitle, exactly as in the light build.
+ */
+export declare class MonoAlertShadow extends MonoAlertShadow_base {
+    static styles: import('lit').CSSResult[];
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _slot;
+    /**
+     * Whether something is ASSIGNED to a slot. Not `flatten: true`: for an empty
+     * slot that returns the FALLBACK (the prop text), which would count as content.
+     */
+    private _assigned;
+    private _scanSlots;
+    /** Iconify classes are drawn as inline SVG — page utility CSS cannot reach here. */
+    protected _renderIconGlyph(): TemplateResult | typeof nothing;
+    protected _renderMain(): unknown;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-shadow-alert': MonoAlertShadow;
+    }
+}
+export {};

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

@@ -0,0 +1,61 @@
+import { LitElement, TemplateResult } from 'lit';
+import { BreadcrumbItem, BreadcrumbVariant, BreadcrumbSize, BreadcrumbColor, BreadcrumbCssClass } from './breadcrumb-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+import { BreadcrumbRenderContext } from './breadcrumb-render.js';
+/**
+ * Minimal interface for descendant `<mono-breadcrumb-list>` instances. Avoids a
+ * circular import — the real class is in `mono-breadcrumb-list.ts`.
+ */
+export interface MonoBreadcrumbListLike extends HTMLElement {
+    requestUpdate(): void;
+    getBreadcrumbItems?(): BreadcrumbItem[];
+}
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoBreadcrumbCoreInterface {
+    items: BreadcrumbItem[];
+    modelValue: BreadcrumbItem | null;
+    variant: BreadcrumbVariant;
+    size: BreadcrumbSize;
+    color: BreadcrumbColor;
+    separator: string;
+    truncate: boolean;
+    disabled: boolean;
+    ariaLabel: string | null;
+    cssClass: BreadcrumbCssClass;
+    cssClassName: string;
+    select(id: string): void;
+    focus(): void;
+    requestItemActivation(item: BreadcrumbItem, index: number, event?: Event): void;
+    isItemCurrent(id: string): boolean;
+    getSlotIconNodes(id: string): Node[] | undefined;
+    hasSeparatorSlot(): boolean;
+    getSeparatorString(): string;
+    _registerListChild(child: MonoBreadcrumbListLike): void;
+    _unregisterListChild(child: MonoBreadcrumbListLike): void;
+    protected _slotIcons: Map<string, Node[]>;
+    protected _slotSeparator: Node[];
+    protected _listChildren: Set<MonoBreadcrumbListLike>;
+    protected _cls(base: string, key: keyof BreadcrumbCssClass): string;
+    protected get _rootClasses(): string;
+    protected _isCurrent(id: string): boolean;
+    protected _setCssClass(value: unknown): void;
+    protected _setModelValueFromAttribute(value: string | null): void;
+    protected _handleItemActivation(item: BreadcrumbItem, index: number, event?: Event): void;
+    protected _notifyListChildren(changed: Map<string, unknown>): void;
+    protected _renderContext(): BreadcrumbRenderContext;
+    protected _itemsForRender(): BreadcrumbItem[];
+    protected _renderBody(): TemplateResult;
+    protected _useIconSlots(): boolean;
+}
+/**
+ * `MonoBreadcrumbCore` — all render-mode-agnostic logic for `mono-breadcrumb`:
+ * reactive props (incl. the SSR `items` string→array coercion), hybrid aliases,
+ * camelCase attribute fallbacks, the child-list registry + state propagation,
+ * item activation + events, and the `<nav>` chrome `render()`. The light build
+ * keeps its `[data-mono-slot]` capture (`slot="body"`/`separator`/`icon-*`) and
+ * overrides `_renderBody()`; the shadow build renders the whole list from `items`
+ * in one shadow root and overrides `_useIconSlots()` (mirrors `mono-menu`).
+ *
+ * SSR-safe: no `document`/`window` access except `focus()` (guarded by isServer).
+ */
+export declare const MonoBreadcrumbCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoBreadcrumbCoreInterface> & T;