@flux-ui/components 3.0.0-next.25 → 3.0.0-next.28

package/dist/component/primitive/SelectBase.vue.d.ts

@@ -0,0 +1,326 @@
+import { FluxFormSelectOption, FluxFormSelectOptions, FluxDirection, FluxAutoCompleteType, FluxIconName, FluxInputMask, FluxInputType, FluxTo, FluxPressableType, FluxButtonProps } from '@flux-ui/types';
+import { ComponentPublicInstance, nextTick, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentOptionsBase, GlobalComponents, GlobalDirectives, DebuggerEvent, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, CreateComponentPublicInstanceWithMixins } from 'vue';
+import { OnCleanup } from '@vue/reactivity';
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly isLoading?: boolean;
+    readonly isMultiple?: boolean;
+    readonly isSearchable?: boolean;
+    readonly options: FluxFormSelectOptions[];
+    readonly placeholder?: string;
+    readonly selected: FluxFormSelectOption[];
+};
+type __VLS_PublicProps = {
+    'searchQuery'?: string;
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    search: (args_0: string) => any;
+    select: (args_0: string | number) => any;
+    open: () => any;
+    "update:searchQuery": (value: string) => any;
+    keyDown: (args_0: KeyboardEvent) => any;
+    deselect: (args_0: string | number) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: () => any;
+    onSearch?: (args_0: string) => any;
+    onSelect?: (args_0: string | number) => any;
+    onOpen?: () => any;
+    "onUpdate:searchQuery"?: (value: string) => any;
+    onKeyDown?: (args_0: KeyboardEvent) => any;
+    onDeselect?: (args_0: string | number) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    anchor: {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly tagName: keyof HTMLElementTagNameMap;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any>;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<{
+            readonly tagName: keyof HTMLElementTagNameMap;
+        }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{
+        readonly tagName: keyof HTMLElementTagNameMap;
+    }> & Readonly<{}>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            default(): any;
+        }> & {
+            default(): any;
+        };
+    };
+    anchorPopup: {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{
+            readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+            readonly direction?: FluxDirection;
+            readonly margin?: number;
+            readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right";
+            readonly useAnchorWidth?: boolean;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            popup: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any>;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: ComponentOptionsBase<Readonly<{
+            readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+            readonly direction?: FluxDirection;
+            readonly margin?: number;
+            readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right";
+            readonly useAnchorWidth?: boolean;
+        }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{
+        readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+        readonly direction?: FluxDirection;
+        readonly margin?: number;
+        readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right";
+        readonly useAnchorWidth?: boolean;
+    }> & Readonly<{}>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            default(): any;
+        }> & {
+            default(): any;
+        };
+    };
+    searchInputElement: CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: object | string | number | null;
+    } & {
+        readonly autoComplete?: FluxAutoCompleteType;
+        readonly autoFocus?: boolean;
+        readonly iconLeading?: FluxIconName;
+        readonly iconTrailing?: FluxIconName;
+        readonly disabled?: boolean;
+        readonly isCondensed?: boolean;
+        readonly isLoading?: boolean;
+        readonly isReadonly?: boolean;
+        readonly isSecondary?: boolean;
+        readonly max?: string | number;
+        readonly maxLength?: number;
+        readonly min?: string | number;
+        readonly pattern?: FluxInputMask;
+        readonly placeholder?: string;
+        readonly step?: number;
+        readonly type?: FluxInputType;
+    }> & Readonly<{
+        onBlur?: () => any;
+        onFocus?: () => any;
+        onShowPicker?: () => any;
+        "onUpdate:modelValue"?: (value: string | number | object) => any;
+    }>, {
+        blur: () => void;
+        focus: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        blur: () => any;
+        focus: () => any;
+        showPicker: () => any;
+        "update:modelValue": (value: string | number | object) => any;
+    }, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        input: HTMLInputElement;
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: object | string | number | null;
+    } & {
+        readonly autoComplete?: FluxAutoCompleteType;
+        readonly autoFocus?: boolean;
+        readonly iconLeading?: FluxIconName;
+        readonly iconTrailing?: FluxIconName;
+        readonly disabled?: boolean;
+        readonly isCondensed?: boolean;
+        readonly isLoading?: boolean;
+        readonly isReadonly?: boolean;
+        readonly isSecondary?: boolean;
+        readonly max?: string | number;
+        readonly maxLength?: number;
+        readonly min?: string | number;
+        readonly pattern?: FluxInputMask;
+        readonly placeholder?: string;
+        readonly step?: number;
+        readonly type?: FluxInputType;
+    }> & Readonly<{
+        onBlur?: () => any;
+        onFocus?: () => any;
+        onShowPicker?: () => any;
+        "onUpdate:modelValue"?: (value: string | number | object) => any;
+    }>, {
+        blur: () => void;
+        focus: () => void;
+    }, {}, {}, {}, {}>;
+    optionElements: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{
+            readonly label?: string;
+            readonly disabled?: boolean;
+            readonly to?: FluxTo;
+            readonly tabindex?: string | number;
+            readonly type?: FluxPressableType;
+            readonly isLoading?: boolean;
+            readonly href?: string;
+            readonly rel?: string;
+            readonly target?: string;
+            readonly iconLeading?: FluxIconName | null;
+            readonly iconTrailing?: FluxIconName | null;
+            readonly command?: string;
+            readonly commandIcon?: FluxIconName;
+            readonly commandLoading?: boolean;
+            readonly imageAlt?: string;
+            readonly imageSrc?: string;
+            readonly isActive?: boolean;
+            readonly isDestructive?: boolean;
+            readonly isHighlighted?: boolean;
+            readonly isIndented?: boolean;
+            readonly isSelectable?: boolean;
+            readonly isSelected?: boolean;
+            readonly onClick?: (args_0: MouseEvent) => any;
+            readonly onMouseenter?: (args_0: MouseEvent) => any;
+            readonly onMouseleave?: (args_0: MouseEvent) => any;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any>;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "click", args_0: MouseEvent) => void) & ((event: "mouseenter", args_0: MouseEvent) => void) & ((event: "mouseleave", args_0: MouseEvent) => void);
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<Omit< FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
+            readonly command?: string;
+            readonly commandIcon?: FluxIconName;
+            readonly commandLoading?: boolean;
+            readonly imageAlt?: string;
+            readonly imageSrc?: string;
+            readonly isActive?: boolean;
+            readonly isDestructive?: boolean;
+            readonly isHighlighted?: boolean;
+            readonly isIndented?: boolean;
+            readonly isSelectable?: boolean;
+            readonly isSelected?: boolean;
+        }> & Readonly<{
+            onClick?: (args_0: MouseEvent) => any;
+            onMouseenter?: (args_0: MouseEvent) => any;
+            onMouseleave?: (args_0: MouseEvent) => any;
+        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            click: (args_0: MouseEvent) => any;
+            mouseenter: (args_0: MouseEvent) => any;
+            mouseleave: (args_0: MouseEvent) => any;
+        }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<Omit< FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
+        readonly command?: string;
+        readonly commandIcon?: FluxIconName;
+        readonly commandLoading?: boolean;
+        readonly imageAlt?: string;
+        readonly imageSrc?: string;
+        readonly isActive?: boolean;
+        readonly isDestructive?: boolean;
+        readonly isHighlighted?: boolean;
+        readonly isIndented?: boolean;
+        readonly isSelectable?: boolean;
+        readonly isSelected?: boolean;
+    }> & Readonly<{
+        onClick?: (args_0: MouseEvent) => any;
+        onMouseenter?: (args_0: MouseEvent) => any;
+        onMouseleave?: (args_0: MouseEvent) => any;
+    }>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            after(): any;
+        }> & {
+            after(): any;
+        };
+    })[];
+}, any>;
+export default _default;

package/dist/component/primitive/SliderBase.vue.d.ts

@@ -0,0 +1,36 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly isDragging?: boolean;
+    readonly isTicksVisible?: boolean;
+    readonly max: number;
+    readonly min: number;
+    readonly step: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        root: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    dragging: (args_0: boolean) => any;
+    update: (args_0: number) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDragging?: (args_0: boolean) => any;
+    onUpdate?: (args_0: number) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/primitive/{SliderThumb.d.ts → SliderThumb.vue.d.ts}

@@ -4,7 +4,7 @@ type __VLS_Props = {
     readonly isDragging?: boolean;
     readonly position: number;
 };
-declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     decrement: () => any;
     grab: (args_0: PointerEvent) => any;
     increment: () => any;
@@ -12,6 +12,5 @@ declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, Compone
     onDecrement?: () => any;
     onGrab?: (args_0: PointerEvent) => any;
     onIncrement?: () => any;
-}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
 export default _default;

package/dist/component/primitive/SliderTrack.vue.d.ts

@@ -0,0 +1,22 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly percentageLower: number;
+    readonly percentageUpper: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/primitive/index.d.ts

@@ -1,9 +1,9 @@
-export { default as Anchor } from './Anchor';
-export { default as AnchorPopup } from './AnchorPopup';
-export { default as FilterOptionBase } from './FilterOptionBase';
-export { default as SelectBase } from './SelectBase';
-export { default as SliderBase } from './SliderBase';
-export { default as SliderThumb } from './SliderThumb';
-export { default as SliderTrack } from './SliderTrack';
+export { default as Anchor } from './Anchor.vue';
+export { default as AnchorPopup } from './AnchorPopup.vue';
+export { default as FilterOptionBase } from './FilterOptionBase.vue';
+export { default as SelectBase } from './SelectBase.vue';
+export { default as SliderBase } from './SliderBase.vue';
+export { default as SliderThumb } from './SliderThumb.vue';
+export { default as SliderTrack } from './SliderTrack.vue';
 export { FilterMenuRenderer } from './FilterMenuRenderer';
 export { VNodeRenderer } from './VNodeRenderer';

package/dist/composable/private/index.d.ts

@@ -1,3 +1,2 @@
 export { default as useFormSelect } from './useFormSelect';
-export { default as useLoaded } from './useLoaded';
 export { default as useTranslate } from './useTranslate';

package/dist/index.css

@@ -59,7 +59,7 @@
     --background: var(--gray-50);
     --foreground: var(--gray-700);
     --foreground-prominent: var(--gray-900);
-    --foreground-secondary: var(--gray-400);
+    --foreground-secondary: var(--gray-500);
     --surface: var(--gray-25);
     --surface-loader: rgb(from var(--gray-25) r g b / .75);
     --surface-stroke: var(--gray-200);
@@ -281,7 +281,7 @@
     color: var(--primary-600);
     text-decoration: underline;
     text-decoration-thickness: 1px;
-    text-underline-offset: 4px;
+    text-underline-offset: 3px;
   }
   a:not([class]):hover, a[class=""]:hover {
     text-decoration: none;
@@ -289,6 +289,9 @@
   p {
     line-height: 1.6;
   }
+  small {
+    font-size: 14px;
+  }
   blockquote {
     position: relative;
     margin: 0 0 0 30px;
@@ -551,17 +554,6 @@
   display: inline-block;
 }
 
-.material-symbol-icon {
-  display: inline-flex;
-  color: currentColor;
-  font-family: "Material Symbols Outlined", sans-serif;
-  font-weight: 400;
-  font-style: normal;
-  user-select: none;
-  -webkit-font-feature-settings: "liga";
-  -webkit-font-smoothing: antialiased;
-}
-
 .icon-boxed {
   display: flex;
   height: 1em;
@@ -574,9 +566,6 @@
 .icon-boxed .icon {
   font-size: 0.45em;
 }
-.icon-boxed .material-symbol-icon {
-  font-size: 0.5em;
-}
 
 .icon-boxed-default {
   box-shadow: var(--shadow-sm);
@@ -1097,12 +1086,21 @@
   --surface: var(--background);
 }
 
+:is(.pane-default, .pane-flat, .pane-well):is(button) {
+  padding: 0;
+}
+
 :is(.pane-default, .pane-flat, .pane-well):is(a, button) {
-  transition: box-shadow 210ms var(--swift-out);
+  cursor: pointer;
+  transition: 210ms var(--swift-out);
+  transition-property: background, box-shadow;
 }
 :is(.pane-default, .pane-flat, .pane-well):is(a, button):hover {
   box-shadow: var(--shadow-lg);
 }
+:is(.pane-default, .pane-flat, .pane-well):is(a, button):active {
+  box-shadow: var(--shadow-xs);
+}
 
 .pane-header {
   display: flex;
@@ -1861,7 +1859,7 @@
 }
 
 .badge-gray {
-  --color: var(--gray-700);
+  --color: var(--foreground);
 }
 .badge-gray .badge-label {
   color: var(--foreground-prominent);
@@ -4006,7 +4004,7 @@ tfoot .table-cell {
 }
 
 .table-actions {
-  margin: -3px 0 -3px -3px;
+  margin: -4px 0 -4px -3px;
 }
 
 .table-fill {
@@ -4634,6 +4632,7 @@ tfoot .table-cell {
   display: flex;
   flex-flow: row nowrap;
   gap: 21px;
+  text-align: left;
 }
 
 .item-actions {
@@ -4643,22 +4642,24 @@ tfoot .table-cell {
 .item-content {
   display: flex;
   flex-flow: column;
+  flex-grow: 1;
   gap: 3px;
 }
 
 .item-media {
+  --size: 48px;
   flex-shrink: 0;
 }
 
 .item-media > img {
-  height: 48px;
-  width: 48px;
+  height: var(--size);
+  width: var(--size);
   object-fit: cover;
   object-position: center;
 }
 
 .item-media > .avatar {
-  font-size: 48px;
+  font-size: var(--size);
 }
 
 .item-media > .icon {
@@ -4666,7 +4667,13 @@ tfoot .table-cell {
 }
 
 .item-media > .icon-boxed {
-  font-size: 48px;
+  font-size: var(--size);
+}
+
+.item-actions.is-center,
+.item-content.is-center,
+.item-media.is-center {
+  align-self: center;
 }
 
 .item-stack {
@@ -4685,6 +4692,10 @@ tfoot .table-cell {
 
 .base-pane-structure > .item-stack > .item {
   margin: 0;
+}
+
+.base-pane-structure:is(a, button):hover:has(> .item) {
+  background-color: color-mix(in srgb, rgb(from var(--surface-hover) r g b/0.125), var(--surface));
 }.legend-horizontal {
   gap: 12px 21px;
 }
@@ -5726,6 +5737,11 @@ tfoot .table-cell {
     border-color: var(--foreground);
   }
 }
+.tab-bar-item:disabled, .tab-bar-item[aria-disabled=true] {
+  box-shadow: none;
+  opacity: 0.5;
+  pointer-events: none;
+}
 
 .tab-bar-item-active {
   border-color: var(--primary-600);