@synopackageland/ui 0.20.4 → 0.20.6

package/dist/components/primitives/sheet/BottomSheet.vue.d.ts

@@ -0,0 +1,69 @@
+/** `auto` fits the content up to 92%; `large` is 92% (a strip of the page stays, a tap there closes); `full` fills the screen. Any other value is a CSS height, capped at 92%. */
+export type BottomSheetHeight = 'auto' | 'large' | 'full' | (string & {});
+type __VLS_Props = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    title?: string;
+    description?: string;
+    height?: BottomSheetHeight;
+    /** Resting points as fractions of the screen (or px), e.g. `[0.5, 0.92]`. */
+    snapPoints?: (number | string)[];
+    closeLabel?: string;
+    showClose?: boolean;
+    /** `false` keeps the sheet open on a press outside it. */
+    closeOnOutside?: boolean;
+    /** `false` leaves the page usable behind the sheet: no scrim, scroll lock or focus trap. */
+    modal?: boolean;
+    /** The mask behind: `dim` (default), `light` or `none`. */
+    scrim?: 'dim' | 'light' | 'none';
+    /** Drops the body's padding and scrolling, for content that scrolls itself. */
+    flush?: boolean;
+    /** Asks "Discard changes?" before a swipe, Back, Escape, an outside press or the close button closes it (set while a form is dirty). */
+    confirmClose?: boolean;
+    /** Whether Back closes the sheet. Default: on a phone. */
+    backDismiss?: boolean;
+};
+declare var __VLS_16: {}, __VLS_71: {}, __VLS_90: {}, __VLS_98: {};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_16) => any;
+} & {
+    header?: (props: typeof __VLS_71) => any;
+} & {
+    default?: (props: typeof __VLS_90) => any;
+} & {
+    footer?: (props: typeof __VLS_98) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: Event) => any;
+    interactOutside: (event: Event) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: Event) => any) | undefined;
+    onInteractOutside?: ((event: Event) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    height: BottomSheetHeight;
+    open: boolean;
+    flush: boolean;
+    defaultOpen: boolean;
+    modal: boolean;
+    showClose: boolean;
+    closeOnOutside: boolean;
+    scrim: "dim" | "light" | "none";
+    confirmClose: boolean;
+    backDismiss: boolean;
+}, {}, {}, {}, 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/sheet/Sheet.vue.d.ts

@@ -2,7 +2,9 @@ type SheetSide = 'left' | 'right' | 'top' | 'bottom';
 type __VLS_Props = {
     open?: boolean;
     defaultOpen?: boolean;
+    /** `bottom` is the BottomSheet: a grabber, swipe down to close, keyboard aware. */
     side?: SheetSide;
+    /** The width of a side sheet, or the height of a top or bottom one. Without it a bottom sheet fits its content. */
     size?: string;
     title?: string;
     description?: string;
@@ -16,13 +18,19 @@ type __VLS_Props = {
     /** Whether a press outside closes the sheet. Defaults to `modal`: a non-modal sheet stays while the page behind is used. */
     closeOnOutside?: boolean;
 };
-declare var __VLS_14: {}, __VLS_62: {}, __VLS_70: {};
+declare var __VLS_15: {}, __VLS_17: {}, __VLS_20: {}, __VLS_35: {}, __VLS_83: {}, __VLS_91: {};
 type __VLS_Slots = {} & {
-    trigger?: (props: typeof __VLS_14) => any;
+    trigger?: (props: typeof __VLS_15) => any;
 } & {
-    default?: (props: typeof __VLS_62) => any;
+    default?: (props: typeof __VLS_17) => any;
 } & {
-    footer?: (props: typeof __VLS_70) => any;
+    footer?: (props: typeof __VLS_20) => any;
+} & {
+    trigger?: (props: typeof __VLS_35) => any;
+} & {
+    default?: (props: typeof __VLS_83) => any;
+} & {
+    footer?: (props: typeof __VLS_91) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;
@@ -40,9 +48,9 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     size: string;
+    open: boolean;
     side: SheetSide;
     defaultOpen: boolean;
-    open: boolean;
     modal: boolean;
     closeOnOutside: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/components/primitives/sheet/phone.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+/**
+ * True when the surface opens on a phone: the app's container is 640px or
+ * narrower (AppRoot/AppLayout presentation `mobile`). Outside an app root the
+ * viewport width decides instead. Call it in a component's setup.
+ */
+export declare function usePhonePresentation(): ComputedRef<boolean>;

package/dist/components/primitives/superbox-select/SuperboxSelect.vue.d.ts

@@ -6,21 +6,21 @@ type __VLS_Props = Omit<SelectFieldProps, 'multiple' | 'modelValue' | 'defaultVa
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     select: (option: SelectOption) => any;
     blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
     invalid: (text: string) => any;
     "update:modelValue": (value: string[]) => any;
-    focus: (event: FocusEvent) => any;
-    "update:loading": (loading: boolean) => any;
     create: (value: string) => any;
+    "update:loading": (loading: boolean) => any;
     "open-dropdown": () => any;
     "close-dropdown": () => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelect?: ((option: SelectOption) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
     onInvalid?: ((text: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
-    onFocus?: ((event: FocusEvent) => any) | undefined;
-    "onUpdate:loading"?: ((loading: boolean) => any) | undefined;
     onCreate?: ((value: string) => any) | undefined;
+    "onUpdate:loading"?: ((loading: boolean) => any) | undefined;
     "onOpen-dropdown"?: (() => any) | undefined;
     "onClose-dropdown"?: (() => any) | undefined;
 }>, {

package/dist/components/rich-text-editor/RichTextEditor.vue.d.ts

@@ -68,10 +68,10 @@ declare const __VLS_export: import('vue').DefineComponent<{
     variant: "compact" | "full";
     loading: boolean;
     disabled: boolean;
+    invalid: boolean;
     id: string;
     modelValue: string;
     placeholder: string;
-    invalid: boolean;
     ariaLabel: string;
     headings: boolean;
     files: (id: string) => FileItem | undefined;

package/dist/components/rich-text-editor/extensions.d.ts

@@ -23,6 +23,8 @@ export type ExtensionOptions = {
     mention: Omit<SuggestionOptions<MentionCandidate>, 'editor' | 'char'>;
     /** Ctrl+Enter or Cmd+Enter; returns whether it was taken. Never while an input method composes. */
     submit?: () => boolean;
+    /** Plain Enter, before it breaks the line; returns whether it was taken (a compact box on a touch screen sends). Never while an input method composes. */
+    enter?: () => boolean;
     /** Ctrl+K or Cmd+K. */
     link: () => boolean;
     escape: () => boolean;

package/dist/composables/formControl.d.ts

@@ -1,3 +1,11 @@
+/** The native `type` for an Input `type`: `integer` and `decimal` are text fields with a number keyboard (never `type="number"`). */
+export declare function nativeInputType(type: string): string;
+/**
+ * The on-screen keyboard a field of this type opens: its layout
+ * (`inputmode`), whether it capitalises and spell-checks, and the label of
+ * its Enter key. The caller's own attributes override every one of them.
+ */
+export declare function keyboardHints(type: string): Record<string, string>;
 /** One primary control per FormItem. Layout attrs stay on wrappers; all other
  * attrs belong to the focusable control. Composite controls consume the field
  * so their popup's internal inputs cannot steal its label or reuse its id. */
@@ -8,6 +16,16 @@ export declare function useFormControl(options: {
     ariaLabel?: () => string | undefined;
     ariaLabelledby?: () => string | undefined;
     invalid?: () => boolean | undefined;
+    /**
+     * A text entry field: its type sets the keyboard hints. With `element`, the
+     * field also joins its Form's field order, so its Enter key reads Next, or
+     * Done on the last field, and on a touch device Next moves to the next field.
+     */
+    keyboard?: {
+        type: () => string;
+        element?: () => HTMLElement | null | undefined;
+        active?: () => boolean;
+    };
 }): {
     controlAttrs: () => Record<string, unknown> & {
         id?: string;

package/dist/composables/phoneSurface.d.ts

@@ -0,0 +1,35 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+/** A menu with more actions than this becomes an action sheet on a phone. */
+export declare const PHONE_MENU_MAX_ACTIONS = 5;
+/** What a popup holds; any of these, on a phone, makes it a sheet. */
+export interface PhoneSurfaceContent {
+    list?: boolean;
+    search?: boolean;
+    form?: boolean;
+    /** The number of actions on the first level of a menu. */
+    actions?: number;
+    submenu?: boolean;
+}
+export type PhoneSurface = 'popover' | 'sheet';
+/** Whether this content needs a sheet once the app is phone-width. */
+export declare function needsSheet(content: PhoneSurfaceContent): boolean;
+type MenuEntryShape = {
+    key?: unknown;
+    type?: string;
+    children?: readonly unknown[];
+};
+/** The content of a menu: its first-level actions (separators don't count) and whether any of them opens a submenu. */
+export declare function menuContent(items: readonly MenuEntryShape[]): PhoneSurfaceContent;
+/**
+ * `sheet` while the enclosing app is phone-width (640px or narrower, the same
+ * signal that turns a Dialog into a BottomSheet) and the content needs one,
+ * else `popover`. A touch tablet keeps popovers. Call it in setup.
+ */
+export declare function usePhoneSurface(content: MaybeRefOrGetter<PhoneSurfaceContent>): ComputedRef<PhoneSurface>;
+/**
+ * The name a control is known by, to title the sheet it opens: its
+ * `aria-label`, else the text of the elements its `aria-labelledby` names
+ * (a form label).
+ */
+export declare function accessibleName(element: Element | null | undefined): string;
+export {};

package/dist/feedback/StatusSlot.vue.d.ts

@@ -14,9 +14,9 @@ declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRetry?: (() => any) | undefined;
 }>, {
+    message: string;
     height: string;
     width: string;
-    message: string;
     delay: number;
     state: "idle" | "pending" | "saved" | "error";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/grid/host/GridHost.vue.d.ts

@@ -104,8 +104,8 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, GridHostExp
 }>, {
     loading: boolean;
     readonly: boolean;
-    rowHeight: number;
     draggable: GridDraggable;
+    rowHeight: number;
     selectable: GridSelectable;
     editing: boolean;
     freezeColumnCount: number;