@webx-ui/core 0.10.0 → 0.11.0

package/dist/components/Descriptions/types.d.ts

@@ -27,4 +27,6 @@ export interface DescriptionsContext {
     bordered: boolean;
     layout: DescriptionsLayout;
     labelWidth: string | undefined;
+    /** How many columns the list has — a pair may not span more than there are. */
+    columns: number;
 }

package/dist/components/SelectionArea/SelectionArea.d.ts

@@ -1,5 +1,6 @@
 import { SelectionAreaProps, SelectionAreaSlotProps, SelectionValue } from './types';
 type __VLS_Props = SelectionAreaProps;
+/** Everything there is. Nothing at all where only one may be held. */
 declare function selectAll(): void;
 declare function clear(): void;
 type __VLS_PublicProps = {
@@ -30,6 +31,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     onEnd?: ((value: SelectionValue[]) => any) | undefined;
     "onUpdate:modelValue"?: ((value: SelectionValue[]) => any) | undefined;
 }>, {
+    multiple: boolean;
     disabled: boolean;
     match: import('./types').SelectionMatch;
     threshold: number;

package/dist/components/SelectionArea/types.d.ts

@@ -1,13 +1,22 @@
 export type SelectionValue = string | number;
 export type SelectionMatch = 'intersect' | 'contain';
 export interface SelectionAreaProps {
+    /**
+     * Whether more than one item may be held at once. Off, the model never holds more than
+     * a single value: there is no box, no run and no toggle, and a click or a tap picks the
+     * item under it. A gallery wants several; a file picker wants one.
+     */
+    multiple?: boolean;
     /** Whether the box has to cover an item or merely touch it. */
     match?: SelectionMatch;
     /** How far the pointer travels before it is a drag rather than a click, in pixels. */
     threshold?: number;
     /** A click picks one item; a click on the background clears the selection. */
     clickSelect?: boolean;
-    /** Drag with a finger too. Off, because on a touch screen a drag scrolls. */
+    /**
+     * Draw the box with a finger too, at the cost of the area scrolling with one. Off,
+     * because on a touch screen a drag means scroll — a tap still picks either way.
+     */
     touch?: boolean;
     /** How near the scroller's edge the pointer scrolls it, in pixels. `0` never does. */
     edgeScroll?: number;

package/dist/components/Steps/Steps.d.ts

@@ -6,7 +6,9 @@ declare function __VLS_template(): {
     }> & {
         default?: () => unknown;
     };
-    refs: {};
+    refs: {
+        list: HTMLOListElement;
+    };
     rootEl: HTMLOListElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
@@ -21,7 +23,10 @@ declare const __VLS_component: import('vue').DefineComponent<StepsProps, {}, {},
     current: number;
     direction: import('./types').StepsDirection;
     clickable: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLOListElement>;
+    minStepWidth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    list: HTMLOListElement;
+}, HTMLOListElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/components/Steps/types.d.ts

@@ -15,6 +15,11 @@ export interface StepsProps {
      * offered: the steps ahead are the ones that have not been filled in.
      */
     clickable?: boolean;
+    /**
+     * How narrow a step may get before a horizontal sequence turns down the page, in
+     * pixels. `0` never folds, and a sequence that is already vertical ignores it.
+     */
+    minStepWidth?: number;
     /** Accessible name of the sequence. */
     ariaLabel?: string;
 }

package/dist/components/Tree/types.d.ts

@@ -61,6 +61,12 @@ export interface TreeProps<T = TreeNode> {
     allowDrag?: (node: T) => boolean;
     /** Vetoes a landing spot — say, to keep a page out of the root. */
     allowDrop?: (drag: T, drop: T, zone: TreeDropZone) => boolean;
+    /**
+     * How long a node dragged over a closed branch waits before that branch opens.
+     * Dropping into a branch you cannot see the inside of is a guess; this turns the
+     * guess into a look. Zero switches it off.
+     */
+    springDelay?: number;
     /** Children are fetched when a branch first opens. Requires `load`. */
     lazy?: boolean;
     /** Fetches the children of one node. */