@synopackageland/ui 0.4.2 → 0.5.4

package/dist/components/primitives/icon/useIconButton.d.ts

@@ -0,0 +1,30 @@
+import { MaybeRefOrGetter } from 'vue';
+export interface IconButtonOptions {
+    /** Accessible name. Required unless `ariaLabelledby` is given. */
+    ariaLabel?: MaybeRefOrGetter<string | undefined>;
+    /** Accessible name from an existing element. */
+    ariaLabelledby?: MaybeRefOrGetter<string | undefined>;
+    disabled?: MaybeRefOrGetter<boolean>;
+    onClick?: (event: MouseEvent | KeyboardEvent) => void;
+}
+/**
+ * Turns a bare icon into the minimum a button has to be when a design rule
+ * forbids `<button>` (dense row actions, input suffixes): role, accessible
+ * name, tab stop, `aria-disabled`, and Enter/Space activation going through the
+ * same handler as the mouse. It is not a native button: form submission,
+ * label association and browser-level event blocking are not provided.
+ */
+export declare function useIconButton(options: IconButtonOptions): {
+    el: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    attrs: import('vue').ComputedRef<{
+        role: string;
+        tabindex: number;
+        'aria-disabled': boolean | undefined;
+        'aria-label': string | undefined;
+        'aria-labelledby': string | undefined;
+        'aria-hidden': boolean;
+    }>;
+    onClick: (event: MouseEvent | KeyboardEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+    focus: () => void;
+};

package/dist/components/primitives/input/Input.vue.d.ts

@@ -3,8 +3,13 @@ type __VLS_Props = {
     type?: string;
     placeholder?: string;
     disabled?: boolean;
+    readonly?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md' | 'lg';
+    id?: string;
+    name?: string;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
@@ -15,6 +20,7 @@ declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {
     type: string;
     disabled: boolean;
     modelValue: string | number;
+    readonly: boolean;
     invalid: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/components/primitives/input/Textarea.vue.d.ts

@@ -2,8 +2,13 @@ type __VLS_Props = {
     modelValue?: string;
     placeholder?: string;
     disabled?: boolean;
+    readonly?: boolean;
     invalid?: boolean;
     rows?: number;
+    id?: string;
+    name?: string;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
@@ -12,6 +17,7 @@ declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {
 }>, {
     disabled: boolean;
     modelValue: string;
+    readonly: boolean;
     invalid: boolean;
     rows: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/components/primitives/input-steppers/InputSteppers.vue.d.ts

@@ -0,0 +1,60 @@
+export type InputSteppersMenuItem = {
+    title: string;
+    value: number;
+};
+/**
+ * Number semantics of this component (documented contract):
+ * - `min` / `max` clamp every committed value.
+ * - `step` is the increment used by the +/- buttons and by ArrowUp / ArrowDown.
+ * - `precision` (optional) rounds every committed value to N decimals. Without it
+ *   a manually typed value keeps its decimals; step arithmetic only rounds away
+ *   binary float noise (0.1 + 0.2 becomes 0.3, 1.5 + 1 stays 2.5).
+ * - Typing is committed on blur or Enter. An empty or non-numeric entry reverts to
+ *   the last valid value; an out-of-range entry is clamped. This is intentional:
+ *   the reference component left manual entries unclamped.
+ * - `patchNum` runs before clamping and may reject a value with `false`, which also
+ *   reverts to the last valid value.
+ */
+type __VLS_Props = {
+    modelValue?: number;
+    /** Lower bound; defaults to Number.MIN_SAFE_INTEGER when omitted. */
+    min?: number | string;
+    /** Upper bound; defaults to Number.MAX_SAFE_INTEGER when omitted. */
+    max?: number | string;
+    /** Increment for the buttons and arrow keys. Defaults to 1. */
+    step?: number | string;
+    /** Decimal places applied to every committed value. */
+    precision?: number;
+    /** Rendered width in pixels. */
+    width?: number;
+    controlsType?: 'right-left' | 'up-down';
+    /** Draws a divider between the input and its controls. */
+    hasDivider?: boolean;
+    disabled?: boolean;
+    /** Selects the input text when it receives focus. */
+    selectOnFocus?: boolean;
+    /** Preset values offered in a listbox. When empty no listbox is rendered. */
+    menu?: InputSteppersMenuItem[];
+    /** Custom correction applied before clamping; `false` rejects the value. */
+    patchNum?: (value: number) => number | false;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    name?: string;
+    placeholder?: string;
+    id?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    menu: InputSteppersMenuItem[];
+    disabled: boolean;
+    modelValue: number;
+    width: number;
+    controlsType: "right-left" | "up-down";
+    hasDivider: boolean;
+    selectOnFocus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/layout/Col.vue.d.ts

@@ -0,0 +1,24 @@
+import { Responsive } from './breakpoints';
+/**
+ * A Grid track span, or a flex item inside a Row. The parent type decides:
+ * `flex={6}` spans 6 of the parent's columns in a Grid and sets `flex: 6` in a Row.
+ * Outside both containers this stays a plain element.
+ */
+type __VLS_Props = {
+    flex?: Responsive<string | number>;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    flex: Responsive<string | number>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/layout/Grid.vue.d.ts

@@ -0,0 +1,35 @@
+import { Responsive } from './breakpoints';
+import { GapValue } from './gap';
+import { LayoutAlign, LayoutJustify } from './context';
+/** A CSS Grid container; `Col` children span its tracks. */
+type __VLS_Props = {
+    /** Track count, or a responsive object of counts. `24` by default. */
+    columns?: Responsive<string | number>;
+    /** Row count, or a responsive object of counts. `1` by default. */
+    rows?: Responsive<string | number>;
+    /** A full `grid-template-columns` value (`"200px 1fr"`) that replaces `columns`. */
+    gridTemplateColumns?: Responsive<string | readonly string[]>;
+    /** A full `grid-template-rows` value that replaces `rows`. */
+    gridTemplateRows?: Responsive<string | readonly string[]>;
+    /** Cross axis: `align-items`. A `Col` keeps the height of its content by default. */
+    align?: Responsive<LayoutAlign>;
+    /**
+     * Main axis: `justify-content`, the room the tracks take in the container, so
+     * `Col` children keep spanning whole tracks instead of shrinking to their text.
+     */
+    justify?: Responsive<LayoutJustify>;
+    gap?: Responsive<GapValue>;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/layout/Row.vue.d.ts

@@ -0,0 +1,23 @@
+import { Responsive } from './breakpoints';
+import { LayoutAlign, LayoutJustify } from './context';
+import { GapValue } from './gap';
+/** A flex row; `Col` children become flex items. */
+type __VLS_Props = {
+    align?: Responsive<LayoutAlign>;
+    justify?: Responsive<LayoutJustify>;
+    flexWrap?: Responsive<boolean>;
+    gap?: Responsive<GapValue>;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/layout/breakpoints.d.ts

@@ -0,0 +1,24 @@
+import { InjectionKey, Ref } from 'vue';
+export type BreakpointKey = 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** Viewport thresholds in px, keyed by breakpoint. */
+export type GridBreakpoints = Record<BreakpointKey, number>;
+/** A value, or one value per breakpoint resolved mobile first. */
+export type Responsive<T> = T | Partial<Record<BreakpointKey, T>>;
+export declare const BREAKPOINT_KEYS: readonly BreakpointKey[];
+/** The SVC v11 defaults. An app can override them with `provide(GRID_BREAKPOINTS, …)`. */
+export declare const DEFAULT_BREAKPOINTS: GridBreakpoints;
+/** Provide a custom breakpoint set (a BreakpointManager) to a whole subtree. */
+export declare const GRID_BREAKPOINTS: InjectionKey<GridBreakpoints>;
+export declare function isResponsive<T>(value: Responsive<T> | undefined): value is Partial<Record<BreakpointKey, T>>;
+/** The breakpoint a viewport width falls into, mobile first. */
+export declare function breakpointForWidth(width: number, breakpoints?: GridBreakpoints): BreakpointKey;
+/**
+ * The value that applies at `active`: the last breakpoint at or below it, or the
+ * smallest defined one when the responsive object starts above the viewport.
+ */
+export declare function resolveResponsive<T>(value: Responsive<T> | undefined, active: BreakpointKey): T | undefined;
+/**
+ * Tracks the active breakpoint for the viewport. `matchMedia` drives the updates
+ * and a `resize` listener is the fallback where it is missing (SSR, jsdom).
+ */
+export declare function useActiveBreakpoint(provided?: GridBreakpoints): Ref<BreakpointKey>;

package/dist/components/primitives/layout/context.d.ts

@@ -0,0 +1,22 @@
+import { ComputedRef, InjectionKey, Ref } from 'vue';
+import { BreakpointKey } from './breakpoints';
+export type LayoutType = 'grid' | 'row';
+/** Cross-axis values shared by Grid and Row. */
+export type LayoutAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+/** Main-axis values; the `space-*` forms only exist for Row. */
+export type LayoutJustify = LayoutAlign | 'space-between' | 'space-around' | 'space-evenly';
+/**
+ * What a `Col` needs from its container. A `Col` outside one renders a plain
+ * element, exactly like SVC v11, where the parent type is detected through
+ * injection and nothing is applied when there is no container.
+ */
+export type GridLayoutContext = {
+    type: LayoutType;
+    active: Ref<BreakpointKey>;
+    columns: ComputedRef<number>;
+};
+export declare const GRID_LAYOUT: InjectionKey<GridLayoutContext>;
+export type AlignItemsCss = 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
+export type JustifyContentCss = AlignItemsCss | 'space-between' | 'space-around' | 'space-evenly';
+export declare function alignItemsValue(align: LayoutAlign): AlignItemsCss;
+export declare function justifyContentValue(justify: LayoutJustify): JustifyContentCss;

package/dist/components/primitives/layout/gap.d.ts

@@ -0,0 +1,12 @@
+/** `16` → `16px`; strings are passed through, exactly as CSS received them. */
+export declare function cssSize(value: string | number): string;
+/** One size for both axes, or a `[column, row]` pair. */
+export type GapValue = string | number | readonly [string | number, string | number];
+export type GapStyle = {
+    columnGap: string;
+    rowGap: string;
+};
+export declare function gapStyle(gap: GapValue | undefined): GapStyle | undefined;
+/** Normalises the `columns` / `rows` props (a number, a `"3"`, or a track list) into a track list. */
+export declare function trackTemplate(value: string | number | readonly string[] | undefined, fallbackCount: number): string;
+export declare function trackCount(value: string | number | readonly string[] | undefined, fallback: number): number;

package/dist/components/primitives/multiple-select/MultipleSelect.vue.d.ts

@@ -0,0 +1,32 @@
+import { SelectFieldProps, SelectOption } from '../select/internal/types';
+type __VLS_Props = Omit<SelectFieldProps, 'multiple' | 'modelValue' | 'defaultValue'> & {
+    modelValue?: string[];
+    defaultValue?: string[];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (option: SelectOption) => any;
+    invalid: (text: string) => any;
+    "update:modelValue": (value: string[]) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    "update:loading": (loading: boolean) => any;
+    create: (value: string) => any;
+    "open-dropdown": () => any;
+    "close-dropdown": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((option: SelectOption) => any) | undefined;
+    onInvalid?: ((text: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:loading"?: ((loading: boolean) => any) | undefined;
+    onCreate?: ((value: string) => any) | undefined;
+    "onOpen-dropdown"?: (() => any) | undefined;
+    "onClose-dropdown"?: (() => any) | undefined;
+}>, {
+    modelValue: string[];
+    defaultValue: string[];
+    editable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/pagination/Pagination.vue.d.ts

@@ -0,0 +1,111 @@
+import { PaginationLabels, PaginationTotalTextMode } from './labels';
+export type { PaginationLabels, PaginationTotalTextMode };
+export type PaginationPageSizeOption = {
+    label: string;
+    value: number;
+};
+export type PaginationSwitch = {
+    pageNum: number;
+    pageSize: number;
+};
+export type PaginationBeforeSwitchPage = (params: PaginationSwitch) => PromiseLike<boolean | void> | boolean | void;
+type __VLS_Props = {
+    modelValue?: number;
+    /** Record count; unknown (endless) paging uses `endless` instead. */
+    total?: string | number;
+    pageSize?: number;
+    /** Overrides the derived state. */
+    hasNext?: boolean;
+    hasPrev?: boolean;
+    /** First/end record of the current page; derived from `modelValue`/`pageSize` when unset. */
+    start?: string | number;
+    end?: string | number;
+    selectedCount?: string | number;
+    filteredCount?: string | number;
+    /** `false` renders the pager as read-only feedback: page clicks are ignored. */
+    switchPage?: boolean;
+    /** Pages a first/previous/next/last control skips. */
+    pageShiftUnit?: number;
+    showTotal?: boolean;
+    /** Page-size choices; `false` hides the selector. Bind `v-model:page-size` to follow it. */
+    itemsPerPage?: false | PaginationPageSizeOption[];
+    mode?: 'normal' | 'less';
+    hasFirstBtn?: boolean;
+    hasLastBtn?: boolean;
+    /** Unknown total: no page numbers and no totals, only previous/next. */
+    endless?: boolean;
+    /** Switches to `mode="less"` when the container is narrower than `lessWidth`. */
+    autoLess?: boolean;
+    lessWidth?: number;
+    maxPageButtons?: number;
+    /** Shows the refresh control, which emits `refresh`. */
+    refresh?: boolean;
+    totalTextMode?: PaginationTotalTextMode;
+    totalTextFormat?: Partial<Record<PaginationTotalTextMode, string>>;
+    labels?: Partial<PaginationLabels>;
+    /** Returning `false` (or a promise of it) cancels the page change. */
+    beforeSwitchPage?: PaginationBeforeSwitchPage;
+};
+declare var __VLS_1: {
+    total: number;
+    page: number;
+    pageCount: number;
+    start: number;
+    end: number;
+}, __VLS_59: {}, __VLS_81: {};
+type __VLS_Slots = {} & {
+    total?: (props: typeof __VLS_1) => any;
+} & {
+    right?: (props: typeof __VLS_59) => any;
+} & {
+    'right-wrapper'?: (props: typeof __VLS_81) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    focusPrevious: () => void;
+    focusNext: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (page: number) => any;
+    change: (page: number) => any;
+    refresh: () => any;
+    "update:pageSize": (pageSize: number) => any;
+    changePage: (payload: PaginationSwitch) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((page: number) => any) | undefined;
+    onChange?: ((page: number) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
+    "onUpdate:pageSize"?: ((pageSize: number) => any) | undefined;
+    onChangePage?: ((payload: PaginationSwitch) => any) | undefined;
+}>, {
+    modelValue: number;
+    end: string | number;
+    mode: "normal" | "less";
+    start: string | number;
+    refresh: boolean;
+    total: string | number;
+    pageSize: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+    selectedCount: string | number;
+    filteredCount: string | number;
+    switchPage: boolean;
+    pageShiftUnit: number;
+    showTotal: boolean;
+    itemsPerPage: false | PaginationPageSizeOption[];
+    hasFirstBtn: boolean;
+    hasLastBtn: boolean;
+    endless: boolean;
+    autoLess: boolean;
+    lessWidth: number;
+    maxPageButtons: number;
+    totalTextMode: PaginationTotalTextMode;
+    totalTextFormat: Partial<Record<PaginationTotalTextMode, string>>;
+    labels: Partial<PaginationLabels>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/pagination/labels.d.ts

@@ -0,0 +1,18 @@
+export type PaginationTotalTextMode = 'total' | 'range' | 'filter' | 'select';
+export type PaginationLabels = {
+    /** Accessible name of the paging landmark. */
+    nav: (total: number, endless: boolean) => string;
+    first: string;
+    previous: string;
+    next: string;
+    last: string;
+    refresh: string;
+    /** Accessible name of the active page button. */
+    page: (page: number) => string;
+    /** Accessible name of an inactive page button. */
+    goToPage: (page: number) => string;
+    itemsPerPage: string;
+    /** Templates for `totalTextMode`; `{total}`, `{start}`, `{end}`, `{filteredCount}` and `{selectedCount}` are replaced. */
+    totalText: Record<PaginationTotalTextMode, string>;
+};
+export declare const defaultPaginationLabels: PaginationLabels;

package/dist/components/primitives/pagination/model.d.ts

@@ -0,0 +1,13 @@
+export type PageWindowEntry = number | 'ellipsis';
+/** Total pages for a record count, never below one. */
+export declare function pageCountOf(total: number, pageSize: number): number;
+/** Clamps a requested page into `1..pageCount`. */
+export declare function clampPage(page: number, pageCount: number): number;
+/**
+ * Page buttons around the current page: the first and last page are always
+ * shown, the middle is a window of at most `max` buttons with `ellipsis`
+ * markers where pages are skipped.
+ */
+export declare function pageWindow(current: number, pageCount: number, max?: number): PageWindowEntry[];
+/** Replaces `{name}` placeholders, leaving unknown names untouched. */
+export declare function formatTotalText(template: string, values: Record<string, string | number>): string;

package/dist/components/primitives/progress/Progress.vue.d.ts

@@ -2,6 +2,8 @@ type __VLS_Props = {
     value?: number;
     max?: number;
     label?: string;
+    /** Overrides the trailing percentage text, e.g. an explicit `"60%"` from a caller. */
+    valueLabel?: string;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     value: number;

package/dist/components/primitives/rich-text/RichText.vue.d.ts

@@ -0,0 +1,57 @@
+import { PropType, VNode } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** HTML string to parse and render. */
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Tag allowlist; tags outside it are removed while their content is kept. */
+    parseTags: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    /** Tags treated as clickable links, reported through `click-link`. */
+    linkTags: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    /** Attribute allowlist. `class` and `style` are always kept. */
+    allowAttrs: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'click-link': (linkId: string, attrs: Record<string, string>, event: MouseEvent | KeyboardEvent) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** HTML string to parse and render. */
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Tag allowlist; tags outside it are removed while their content is kept. */
+    parseTags: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    /** Tags treated as clickable links, reported through `click-link`. */
+    linkTags: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    /** Attribute allowlist. `class` and `style` are always kept. */
+    allowAttrs: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+}>> & Readonly<{
+    "onClick-link"?: ((linkId: string, attrs: Record<string, string>, event: KeyboardEvent | MouseEvent) => any) | undefined;
+}>, {
+    text: string;
+    parseTags: string[];
+    linkTags: string[];
+    allowAttrs: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/primitives/rich-text/parseRichText.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_PARSE_TAGS: string[];
+export declare const DEFAULT_LINK_TAGS: string[];
+export declare const DEFAULT_ALLOW_ATTRS: string[];
+/**
+ * True when a URL is relative or a fragment, or uses an allowlisted scheme.
+ * `javascript:`, `data:`, `vbscript:` and every other scheme are rejected, with
+ * or without the whitespace and control characters browsers strip while
+ * parsing one (`java\tscript:`).
+ */
+export declare function isSafeRichTextUrl(value: string): boolean;
+export interface RichTextTextNode {
+    type: 'text';
+    value: string;
+}
+export interface RichTextElementNode {
+    type: 'element';
+    tag: string;
+    attrs: Record<string, string>;
+    /** Marks a tag listed in `linkTags`; clicks are reported through `click-link`. */
+    link: boolean;
+    /** The `link-id` attribute, passed through even when it is not in `allowAttrs`. */
+    linkId?: string;
+    children: RichTextNode[];
+}
+export type RichTextNode = RichTextTextNode | RichTextElementNode;
+export interface ParseRichTextOptions {
+    parseTags?: string[];
+    linkTags?: string[];
+    allowAttrs?: string[];
+}
+export declare function parseRichText(html: string, options?: ParseRichTextOptions): RichTextNode[];

package/dist/components/primitives/schedule-table/ScheduleTable.vue.d.ts

@@ -0,0 +1,65 @@
+import { ScheduleOption, ScheduleSplitMinute } from './schedule';
+type __VLS_Props = {
+    /** Digit string; length must be `168 * (60 / splitMinute)`. */
+    modelValue: string;
+    options?: ScheduleOption[];
+    splitMinute?: ScheduleSplitMinute;
+    optionsCountPerRow?: number;
+    optionsMaxWidth?: string | number;
+    defaultSelected?: number;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    prefix?: string;
+};
+declare var __VLS_1: {}, __VLS_4: string, __VLS_5: {}, __VLS_12: {}, __VLS_15: string, __VLS_16: {
+    cellCls: string;
+    style: Record<string, string>;
+    day: number;
+    hour: number;
+    hourSplitIndex: number;
+    cellKey: string;
+    click: () => void;
+}, __VLS_18: {};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_4>]?: (props: typeof __VLS_5) => any;
+} & {
+    [K in NonNullable<typeof __VLS_15>]?: (props: typeof __VLS_16) => any;
+} & {
+    control?: (props: typeof __VLS_1) => any;
+} & {
+    description?: (props: typeof __VLS_12) => any;
+} & {
+    detail?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    selected: (payload: {
+        index: number;
+        option: ScheduleOption | undefined;
+        cells: number[];
+    }) => any;
+    "edit-option": (option: ScheduleOption) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onSelected?: ((payload: {
+        index: number;
+        option: ScheduleOption | undefined;
+        cells: number[];
+    }) => any) | undefined;
+    "onEdit-option"?: ((option: ScheduleOption) => any) | undefined;
+}>, {
+    prefix: string;
+    options: ScheduleOption[];
+    defaultSelected: number;
+    splitMinute: ScheduleSplitMinute;
+    optionsCountPerRow: number;
+    optionsMaxWidth: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};