@databricks/design-system 2.0.9 → 2.0.10

package/dist-types/design-system/Input/group/Group.d.ts

@@ -0,0 +1,28 @@
+import type { CSSProperties, FocusEventHandler, MouseEventHandler, ReactNode } from "react";
+import type { DangerousGeneralProps, DangerouslySetAntdProps, HTMLDataAttributes } from "../../types";
+import type { InputForceModeProps } from "../force-mode";
+import type { AntdPassthroughProps } from "../input-props";
+export interface InputGroupProps extends HTMLDataAttributes, DangerouslySetAntdProps<AntdPassthroughProps>, DangerousGeneralProps, InputForceModeProps {
+	/**
+	* Button position relative to the input. This affects which inner corners are
+	* squared off to form a seamless join. Defaults to `'right'`.
+	*/
+	buttonSide?: "left" | "right";
+	children?: ReactNode;
+	className?: string;
+	/** Collapses the spacing and shared border between the input and the adjacent button. Defaults to true. */
+	compact?: boolean;
+	onBlur?: FocusEventHandler<HTMLSpanElement>;
+	onFocus?: FocusEventHandler<HTMLSpanElement>;
+	onMouseEnter?: MouseEventHandler<HTMLSpanElement>;
+	onMouseLeave?: MouseEventHandler<HTMLSpanElement>;
+	/** CSS class-name prefix for the rendered markup. */
+	prefixCls?: string;
+	style?: CSSProperties;
+}
+/**
+* The Du Bois input group, which joins an Input to an adjacent control (typically a Button) into a
+* single seamless control. Renders the native (non-AntD) or AntD-backed implementation per
+* `forceMode`, which defaults to the `databricks.fe.designsystem.useNativeInput` SAFE flag.
+*/
+export declare const Group: ({ forceMode, ...props }: InputGroupProps) => JSX.Element;

package/dist-types/design-system/Input/group/NativeGroup.d.ts

@@ -0,0 +1,2 @@
+import type { InputGroupProps } from "./Group";
+export declare const NativeGroup: ({ dangerouslySetAntdProps, dangerouslyAppendEmotionCSS, prefixCls, buttonSide, compact, className, style, children, ...props }: InputGroupProps) => JSX.Element;

package/dist-types/design-system/Input/index-defs.d.ts

@@ -1,7 +1,7 @@
-import { Group } from "./Group";
 import { Input as OriginalInput } from "./Input";
-import { Password } from "./Password";
-import { TextArea } from "./TextArea";
+import { Group } from "./group/Group";
+import { Password } from "./password/Password";
+import { TextArea } from "./textarea/TextArea";
 export declare const Input: typeof OriginalInput & {
 	TextArea: typeof TextArea;
 	Password: typeof Password;

package/dist-types/design-system/Input/index.d.ts

@@ -1,4 +1,9 @@
-import { getInputStyles } from "./Input";
-export * from "./common";
+import { getInputStyles } from "./AntDInput";
+export * from "./input-props";
+export * from "./input-refs";
 export { getInputStyles };
 export { Input } from "./index-defs";
+export type { InputFocusOptions } from "./input-focus";
+export type { InputGroupProps } from "./group/Group";
+export type { PasswordProps } from "./password/Password";
+export type { TextAreaProps } from "./textarea/TextArea";

package/dist-types/design-system/Input/input-container-styling.d.ts

@@ -0,0 +1,13 @@
+import type { ValidationState } from "../types";
+interface InputContainerClassNameOptions {
+	size?: "middle" | "small";
+	locked?: boolean;
+	validationState?: ValidationState;
+}
+/**
+* Builds the class name for the shared `.db-input` container (see `mortar/input.css`) plus its size,
+* locked, and validation-state modifiers. Shared by the native input and password so the root class
+* and its modifier names live in one place.
+*/
+export declare function getInputContainerClassName({ size, locked, validationState }: InputContainerClassNameOptions): string;
+export {};

package/dist-types/design-system/Input/input-focus.d.ts

@@ -0,0 +1,8 @@
+/** Options accepted by {@link InputRef.focus}: the DOM `FocusOptions` plus a cursor-placement hint. */
+export interface InputFocusOptions extends FocusOptions {
+	cursor?: "start" | "end" | "all";
+}
+type TextField = HTMLInputElement | HTMLTextAreaElement;
+/** Focuses the field (input or textarea) and sets the cursor location and text selection state. */
+export declare function focusWithCursor(field: TextField, options?: InputFocusOptions): void;
+export {};

package/dist-types/design-system/Input/input-props.d.ts

@@ -0,0 +1,37 @@
+import type { CSSProperties, HTMLInputTypeAttribute, InputHTMLAttributes, KeyboardEventHandler, ReactNode } from "react";
+import type { InputForceModeProps } from "./force-mode";
+import type { DesignSystemEventProviderAnalyticsEventTypes } from "../DesignSystemEventProvider";
+import type { AnalyticsEventProps, DangerousGeneralProps, DangerouslySetAntdProps, FormElementValidationState, HTMLDataAttributes } from "../types";
+/** Auto-resize bounds for a textarea's `autoSize` prop. */
+export interface TextAreaAutoSize {
+	minRows?: number;
+	maxRows?: number;
+}
+/**
+* Value type for `dangerouslySetAntdProps`, the emergency antd-props passthrough. Antd-specific
+* props stay untyped via the index signature, but `style` keeps its concrete type so callers can
+* read and spread the common styling escape hatch (e.g. `...dangerouslySetAntdProps.style`).
+*/
+export type AntdPassthroughProps = Record<string, unknown> & {
+	style?: CSSProperties;
+};
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "prefix" | "type">, FormElementValidationState, HTMLDataAttributes, DangerouslySetAntdProps<AntdPassthroughProps>, DangerousGeneralProps, InputForceModeProps, AnalyticsEventProps<DesignSystemEventProviderAnalyticsEventTypes.OnValueChange | DesignSystemEventProviderAnalyticsEventTypes.OnView> {
+	type?: HTMLInputTypeAttribute;
+	/** Called when the Enter key is pressed while the input is focused. */
+	onPressEnter?: KeyboardEventHandler<HTMLInputElement>;
+	/** Content rendered before the input, outside its border (e.g. a label or adjacent select). */
+	addonBefore?: ReactNode;
+	/** Content rendered inside the input, before the value (e.g. a leading icon). */
+	prefix?: ReactNode;
+	/** Content rendered inside the input, after the value (e.g. a trailing icon). */
+	suffix?: ReactNode;
+	/** Shows a clear (X) button that empties the input when clicked. */
+	allowClear?: boolean;
+	/** Called when the input is cleared via the clear (X) button. */
+	onClear?: () => void;
+	/** When true, pressing Enter does not submit the surrounding form. Defaults to false. */
+	shouldPreventFormSubmission?: boolean;
+	/** Renders the input read-only with a lock icon, keeping the value legible (unlike `disabled`). */
+	locked?: boolean;
+	size?: "middle" | "small";
+}

package/dist-types/design-system/Input/input-refs.d.ts

@@ -0,0 +1,22 @@
+import type { InputFocusOptions } from "./input-focus";
+/** Imperative handle exposed by an Input's `ref`. */
+export interface InputRef {
+	focus: (options?: InputFocusOptions) => void;
+	blur: () => void;
+	setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none") => void;
+	select: () => void;
+	input: HTMLInputElement;
+	state: {
+		value: string;
+	};
+	setValue: (value: string, callback?: () => void) => void;
+}
+/** Imperative handle exposed by a TextArea's `ref`. */
+export interface TextAreaRef {
+	focus: (options?: InputFocusOptions) => void;
+	blur: () => void;
+	resizableTextArea?: {
+		textArea: HTMLTextAreaElement;
+		resizeTextarea: () => void;
+	};
+}

package/dist-types/design-system/Input/password/AntDPassword.d.ts

@@ -0,0 +1,4 @@
+import type { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } from "react";
+import type { PasswordProps } from "./Password";
+import type { InputRef } from "../input-refs";
+export declare const AntDPassword: ForwardRefExoticComponent<PropsWithoutRef<PasswordProps> & RefAttributes<InputRef>>;

package/dist-types/design-system/Input/password/NativePassword.d.ts

@@ -0,0 +1,4 @@
+import type { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } from "react";
+import type { PasswordProps } from "./Password";
+import type { InputRef } from "../input-refs";
+export declare const NativePassword: ForwardRefExoticComponent<PropsWithoutRef<PasswordProps> & RefAttributes<InputRef>>;

package/dist-types/design-system/Input/password/Password.d.ts

@@ -0,0 +1,15 @@
+import type { ForwardRefExoticComponent, InputHTMLAttributes, PropsWithoutRef, RefAttributes } from "react";
+import type { DangerousGeneralProps, DangerouslySetAntdProps, FormElementValidationState, HTMLDataAttributes } from "../../types";
+import type { InputForceModeProps } from "../force-mode";
+import type { AntdPassthroughProps } from "../input-props";
+import type { InputRef } from "../input-refs";
+/** Props for the single-line password input. */
+export interface PasswordProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "prefix" | "type">, FormElementValidationState, HTMLDataAttributes, DangerouslySetAntdProps<AntdPassthroughProps>, DangerousGeneralProps, InputForceModeProps {
+	/** Shows a button that toggles the value between masked and visible. Defaults to false. */
+	visibilityToggle?: boolean;
+}
+/**
+* The Du Bois password input. Renders the native (non-AntD) or AntD-backed implementation per
+* `forceMode`, which defaults to the `databricks.fe.designsystem.useNativeInput` SAFE flag.
+*/
+export declare const Password: ForwardRefExoticComponent<PropsWithoutRef<PasswordProps> & RefAttributes<InputRef>>;

package/dist-types/design-system/Input/testing/keyboard-input.d.ts

@@ -0,0 +1,9 @@
+/**
+* This is a copy of `@databricks/web-shared/test-utils` `slowlyTypeEachKey`, shared across the
+* Input-family test suites. design-system sits below web-shared in the dependency graph, so importing
+* from it would invert the layering. Input tests need genuine per-keystroke dispatch (per-keystroke
+* onChange counts, `{Enter}`/`{Control>}{Enter}`), which `userEvent.paste` can't provide, so
+* `userEvent.type` is unavoidable — this wrapper isolates the single required `no-userevent-type`
+* suppression so no call site needs its own.
+*/
+export declare function slowlyTypeEachKey(element: Element, text: string): Promise<void>;

package/dist-types/design-system/Input/textarea/AntDTextArea.d.ts

@@ -0,0 +1,4 @@
+import type { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } from "react";
+import type { TextAreaProps } from "./TextArea";
+import type { TextAreaRef } from "../input-refs";
+export declare const AntDTextArea: ForwardRefExoticComponent<PropsWithoutRef<TextAreaProps> & RefAttributes<TextAreaRef>>;

package/dist-types/design-system/Input/textarea/NativeTextArea.d.ts

@@ -0,0 +1,4 @@
+import type { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } from "react";
+import type { TextAreaProps } from "./TextArea";
+import type { TextAreaRef } from "../input-refs";
+export declare const NativeTextArea: ForwardRefExoticComponent<PropsWithoutRef<TextAreaProps> & RefAttributes<TextAreaRef>>;

package/dist-types/design-system/Input/textarea/TextArea.d.ts

@@ -0,0 +1,27 @@
+import type { ForwardRefExoticComponent, KeyboardEventHandler, PropsWithoutRef, RefAttributes, TextareaHTMLAttributes } from "react";
+import type { DesignSystemEventProviderAnalyticsEventTypes } from "../../DesignSystemEventProvider";
+import type { AnalyticsEventProps, DangerousGeneralProps, DangerouslySetAntdProps, FormElementValidationState, HTMLDataAttributes } from "../../types";
+import type { InputForceModeProps } from "../force-mode";
+import type { AntdPassthroughProps, TextAreaAutoSize } from "../input-props";
+import type { TextAreaRef } from "../input-refs";
+export interface TextAreaProps extends TextareaHTMLAttributes<HTMLTextAreaElement>, FormElementValidationState, HTMLDataAttributes, DangerouslySetAntdProps<AntdPassthroughProps>, DangerousGeneralProps, AnalyticsEventProps<DesignSystemEventProviderAnalyticsEventTypes.OnValueChange | DesignSystemEventProviderAnalyticsEventTypes.OnView>, InputForceModeProps {
+	/** When true, a plain Enter submits the surrounding form; platform Enter always does. Defaults to false. */
+	allowFormSubmitOnEnter?: boolean;
+	/** Shows a clear (X) button that empties the textarea when clicked. Honored only by the AntD-backed
+	* implementation today; the native textarea does not yet render a clear button. */
+	allowClear?: boolean;
+	/** Auto-grows the textarea to fit its content; pass bounds to cap the row count. */
+	autoSize?: boolean | TextAreaAutoSize;
+	/** Called when the Enter key is pressed while the textarea is focused. */
+	onPressEnter?: KeyboardEventHandler<HTMLTextAreaElement>;
+	/** Called when the textarea's rendered size changes (e.g. from auto-sizing). */
+	onResize?: (size: {
+		width: number;
+		height: number;
+	}) => void;
+}
+/**
+* The Du Bois multi-line text input. Renders the native (non-AntD) or AntD-backed implementation per
+* `forceMode`, which defaults to the `databricks.fe.designsystem.useNativeInput` SAFE flag.
+*/
+export declare const TextArea: ForwardRefExoticComponent<PropsWithoutRef<TextAreaProps> & RefAttributes<TextAreaRef>>;

package/dist-types/design-system/Input/textarea/useTextAreaAutoSize.d.ts

@@ -0,0 +1,22 @@
+import type { RefObject } from "react";
+import type { TextAreaAutoSize } from "../input-props";
+interface UseTextAreaAutoSizeParams {
+	textAreaRef: RefObject<HTMLTextAreaElement>;
+	autoSize: boolean | TextAreaAutoSize | undefined;
+	/** Re-measures whenever the controlled value changes (JS fallback path). */
+	value: string | number | readonly string[] | undefined;
+	onResize?: (size: {
+		width: number;
+		height: number;
+	}) => void;
+}
+/**
+* Drives the textarea's auto-grow. When the browser supports `field-sizing: content` the CSS owns
+* the height and this is inert; otherwise it measures the content and sets the height directly. Also
+* reports size changes through `onResize`. Returns `resizeTextarea`, the imperative re-measure the
+* component exposes on the ref.
+*/
+export declare function useTextAreaAutoSize({ textAreaRef, autoSize, value, onResize }: UseTextAreaAutoSizeParams): {
+	resizeTextarea: () => void;
+};
+export {};

package/dist-types/design-system/Input/useInputClearHandler.d.ts

@@ -0,0 +1,20 @@
+import type { ChangeEventHandler, MouseEvent, RefObject } from "react";
+interface UseInputClearHandlerParams {
+	/** Ref to the input the clear button empties. */
+	inputRef: RefObject<HTMLInputElement>;
+	/** Whether the value is controlled; an uncontrolled input has its tracked state reset on clear. */
+	isControlled: boolean;
+	/** Resets the tracked "has a value" state of an uncontrolled input. */
+	setUncontrolledHasValue: (hasValue: boolean) => void;
+	/** Records the clear as a value change for analytics (the caller throttles it to once per focus). */
+	reportValueChange: () => void;
+	onClear?: () => void;
+	onChange?: ChangeEventHandler<HTMLInputElement>;
+}
+/**
+* Produces the clear button's click handler: it empties the input, keeps focus on it, and reports
+* the change through `onClear` — or through `onChange` with the emptied value when no `onClear` is
+* given, matching the AntD-backed input.
+*/
+export declare function useInputClearHandler({ inputRef, isControlled, setUncontrolledHasValue, reportValueChange, onClear, onChange }: UseInputClearHandlerParams): (e: MouseEvent<HTMLButtonElement>) => void;
+export {};

package/dist-types/design-system/Input/useTextFieldAnalytics.d.ts

@@ -0,0 +1,23 @@
+import type { MutableRefObject } from "react";
+import type { DataComponentProps, DesignSystemEventProviderComponentTypes } from "../DesignSystemEventProvider";
+import { DesignSystemEventProviderAnalyticsEventTypes } from "../DesignSystemEventProvider";
+interface UseTextFieldAnalyticsParams {
+	componentType: DesignSystemEventProviderComponentTypes;
+	componentId: string | undefined;
+	/** Overrides the reported events; defaults to reporting value changes only. */
+	analyticsEvents?: ReadonlyArray<DesignSystemEventProviderAnalyticsEventTypes>;
+}
+/**
+* Owns the observability wiring shared by the native Input and TextArea: the default analytics-event
+* set, the component event context, first-view reporting, and once-per-focus value-change reporting.
+* The component merges {@link elementRef} into its field ref, spreads {@link dataComponentProps} onto
+* the element, calls {@link reportValueChange} from its change handler, and re-arms it on focus via
+* {@link resetOnFocus} (which {@link useTextFieldFocusHandler} composes into the focus handler).
+*/
+export declare function useTextFieldAnalytics<T extends HTMLElement>({ componentType, componentId, analyticsEvents }: UseTextFieldAnalyticsParams): {
+	elementRef: MutableRefObject<T | null>;
+	dataComponentProps: DataComponentProps;
+	reportValueChange: () => void;
+	resetOnFocus: () => void;
+};
+export {};

package/dist-types/design-system/Input/useTextFieldFocusHandler.d.ts

@@ -0,0 +1,9 @@
+import type { FocusEventHandler } from "react";
+type TextField = HTMLInputElement | HTMLTextAreaElement;
+/**
+* Composes the text field's focus handler shared by the native Input and TextArea: re-arm the
+* once-per-focus value-change reporter (`resetOnFocus`, from {@link useTextFieldAnalytics}), then
+* forward the consumer's `onFocus`.
+*/
+export declare function useTextFieldFocusHandler<T extends TextField>(onFocus: FocusEventHandler<T> | undefined, resetOnFocus: () => void): FocusEventHandler<T>;
+export {};

package/dist-types/design-system/Input/useTextFieldKeyHandlers.d.ts

@@ -0,0 +1,31 @@
+import type { CompositionEventHandler, KeyboardEventHandler, MutableRefObject } from "react";
+type TextField = HTMLInputElement | HTMLTextAreaElement;
+interface UseTextFieldKeyHandlersParams<T extends TextField> {
+	/** The surrounding form's ref (from `useFormContext`); a valid Enter press calls `requestSubmit` on it. */
+	formRef: MutableRefObject<HTMLFormElement | null> | undefined;
+	/** Whether a plain Enter (no modifier) submits the form. */
+	allowBasicEnter: boolean;
+	/** Whether a platform Enter (Cmd on Mac, Ctrl elsewhere) submits the form. */
+	allowPlatformEnter: boolean;
+	/**
+	* Whether submitting the form halts the rest of the keydown chain (`onPressEnter` and the consumer's
+	* `onKeyDown`). The single-line input runs them regardless; the textarea stops after it submits.
+	*/
+	stopKeyDownAfterSubmit: boolean;
+	onPressEnter?: KeyboardEventHandler<T>;
+	onKeyDown?: KeyboardEventHandler<T>;
+	onCompositionStart?: CompositionEventHandler<T>;
+	onCompositionEnd?: CompositionEventHandler<T>;
+}
+/**
+* Wires the key behaviour shared by the native Input and TextArea: submit-the-form-on-Enter (IME-safe,
+* via {@link useCallbackOnEnter}), the `onPressEnter` callback, and chaining of the consumer's own key
+* and composition handlers. The composition handlers travel with the keydown handler because the
+* submit-on-Enter logic relies on their composition tracking to avoid firing mid-IME-composition.
+*/
+export declare function useTextFieldKeyHandlers<T extends TextField>({ formRef, allowBasicEnter, allowPlatformEnter, stopKeyDownAfterSubmit, onPressEnter, onKeyDown, onCompositionStart, onCompositionEnd }: UseTextFieldKeyHandlersParams<T>): {
+	onKeyDown: KeyboardEventHandler<T>;
+	onCompositionStart: CompositionEventHandler<T>;
+	onCompositionEnd: CompositionEventHandler<T>;
+};
+export {};

package/dist-types/design-system/Skeleton/GenericSkeleton.d.ts

@@ -1,6 +1,6 @@
 import type { CSSProperties } from "react";
 import type { WithLoadingState } from "../LoadingState/LoadingState";
-interface GenericSkeletonProps extends WithLoadingState {
+export interface GenericSkeletonProps extends WithLoadingState {
 	/** Label for screen readers */
 	label?: React.ReactNode;
 	/** fps for animation. Default is 60 fps. A lower number will use less resources. */
@@ -11,4 +11,3 @@ interface GenericSkeletonProps extends WithLoadingState {
 	className?: string;
 }
 export declare const GenericSkeleton: ({ label, frameRate, style, loading, loadingDescription, ...restProps }: GenericSkeletonProps) => JSX.Element;
-export {};

package/dist-types/design-system/SplitButton/SplitButton.d.ts

@@ -9,7 +9,7 @@ export interface SplitButtonMenuInfo {
 }
 export type SplitButtonProps = Omit<DropdownButtonProps, "overlay" | "type" | "size" | "trigger"> & HTMLDataAttributes & DangerouslySetAntdProps<Partial<DropdownButtonProps>> & {
 	/**
-	* @deprecated Please migrate to the DuBois DropdownMenu component and use the `menu` prop.
+	* @deprecated Please migrate to the dbui DropdownMenu component and use the `menu` prop.
 	*/
 	deprecatedMenu?: DropdownButtonProps["overlay"];
 	/**

package/dist-types/design-system/TypeaheadComboboxV2/hooks/useComboboxState.d.ts

@@ -20,6 +20,12 @@ interface BaseComboboxStateProps<T> extends AnalyticsEventValueChangeNoPiiFlagPr
 	* filter only once the user types. Multi-select clears the input on select, so it is unaffected.
 	*/
 	showAllOptionsOnOpen?: boolean;
+	/**
+	* Keep the menu open even when the filtered collection is empty (react-aria's
+	* `allowsEmptyCollection`), so the empty state and footer stay visible — e.g. a "start empty, add
+	* via the footer" combobox. Default false: an empty list closes the popover.
+	*/
+	allowsEmptyCollection?: boolean;
 	initialInputValue?: string;
 	initialSelectedItem?: T;
 	formValue?: T;
@@ -62,16 +68,27 @@ export interface ComboboxStateValue<T> {
 	isSelected: (item: T) => boolean;
 	/** Fire the consumer's `formOnBlur` on a genuine input blur (wired onto the input by `Root`). */
 	onInputBlur: () => void;
+	/**
+	* Commits the user's typed text on Enter, but only when `allowNewValue` is set and no option is
+	* currently highlighted. Single-select commits the value to the form; multi-select appends it as a
+	* new tag. Returns true when it committed, so the input's keydown handler knows to suppress
+	* react-aria's own Enter handling.
+	*/
+	onEnterKeypress: () => boolean;
 	componentId: string;
 	analyticsEvents?: DesignSystemEventProviderAnalyticsEventTypes[];
 	valueHasNoPii?: boolean;
 	onView: (value: any) => void;
 	firstOnViewValue?: string;
+	/** True when the combobox is in multi-select (tag) mode. */
 	multiSelect: boolean;
+	/** Single-select only: whether the full option list is shown on open until the user types. */
 	showAllOptionsOnOpen: boolean;
+	/** Whether the user may commit a typed value that is not in the option list. */
+	allowNewValue: boolean;
 }
 /**
-* Backs the Du Bois TypeaheadCombobox (react-aria variant) by wrapping react-aria's
+* Backs the dbui TypeaheadCombobox (react-aria variant) by wrapping react-aria's
 * `useComboBoxState`. Handles single- and multi-select modes, item↔key mapping, filtering
 * (default substring match or a custom `matcher`), selection helpers (`removeItem`,
 * `clearSelection`, `isSelected`), form `onChange`/`onBlur` bridging, and analytics wiring.

package/dist-types/design-system/TypeaheadComboboxV2/hooks/useComboboxStateProps.d.ts

@@ -7,6 +7,7 @@ interface UseComboboxStatePropsParams<T> {
 	matcher?: (item: T, lowerCasedInputValue: string) => boolean;
 	isItemDisabled?: (item: T) => boolean;
 	allowNewValue: boolean;
+	allowsEmptyCollection: boolean;
 	initialInputValue?: string;
 	initialSelectedItem?: T;
 	formValue?: T;
@@ -32,5 +33,5 @@ interface UseComboboxStatePropsParams<T> {
 * input-reset). Kept separate from `useComboboxState` so the wiring into react-aria is isolated
 * from the selection helpers the hook derives afterward.
 */
-export declare function useComboboxStateProps<T>({ items, multiSelect, matcher, isItemDisabled, allowNewValue, initialInputValue, initialSelectedItem, formValue, formOnChange, onStateChange, onIsOpenChange, externalSelectedItems, externalSetSelectedItems, stateRef, onValueChange }: UseComboboxStatePropsParams<T>): ComboBoxStateOptions<WrappedItem<T>, SelectionMode>;
+export declare function useComboboxStateProps<T>({ items, multiSelect, matcher, isItemDisabled, allowNewValue, allowsEmptyCollection, initialInputValue, initialSelectedItem, formValue, formOnChange, onStateChange, onIsOpenChange, externalSelectedItems, externalSetSelectedItems, stateRef, onValueChange }: UseComboboxStatePropsParams<T>): ComboBoxStateOptions<WrappedItem<T>, SelectionMode>;
 export {};

package/dist-types/design-system/TypeaheadComboboxV2/providers/TypeaheadComboboxContext.d.ts

@@ -11,6 +11,8 @@ export interface TypeaheadComboboxV2ContextType extends AnalyticsEventProps<Desi
 	multiSelect: boolean;
 	/** Single-select only: whether the menu opens showing all options (filtering begins on type). */
 	showAllOptionsOnOpen: boolean;
+	/** Whether typed free text is accepted as a value (drives the input's Enter/Tab commit handling). */
+	allowNewValue: boolean;
 	/** Null outside of a Root. */
 	comboBoxState: ComboBoxState<WrappedItem<unknown>, SelectionMode> | null;
 	inputProps: InputHTMLAttributes<HTMLInputElement>;
@@ -37,6 +39,8 @@ export interface TypeaheadComboboxV2ContextType extends AnalyticsEventProps<Desi
 	itemToString: (item: unknown) => string;
 	removeByKey: (key: Key) => void;
 	clearSelection: () => void;
+	/** allowNewValue: commit the typed custom value on Enter (single-select → form, multi → new tag); returns true when it did. */
+	onEnterKeypress: () => boolean;
 }
 export declare const TypeaheadComboboxV2Context: React.Context<TypeaheadComboboxV2ContextType>;
 interface ProviderProps {

package/dist-types/design-system/utils/security/url-safety.d.ts

@@ -10,11 +10,8 @@
 export declare function isSafeUrl(url: string): boolean;
 /**
 * Returns true if the URL is a safe relative path. Rejects anything containing
-* protocol handlers (javascript:, data:, etc.), protocol-relative URLs (//),
-* or paths that don't start with '/'.
-*
-* This mirrors the validation in webapp LoginUtils.redirectWithHash() and the
-* backend CreateSessionHandler.validateNextUrl().
+* protocol handlers (javascript:, data:, etc.), protocol-relative URLs (// or
+* its backslash equivalents), or paths that don't start with '/'.
 */
 export declare function isSafeRelativeUrl(url: string): boolean;
 /**

package/dist-types/maybe-mitigate-expensive-selectors/mitigateExpensiveSelectorsMonacoPkgrPlugins.d.ts

@@ -3,7 +3,7 @@ export interface MitigateExpensiveSelectorsMonacoPkgrPluginsOptions {
 	/**
 	* When true, emit the MITIGATED build: strip every expensive AntD-generated rule and append its
 	* Monaco-safe rewrite. When false (or omitted), emit the PRISTINE build: no plugins, so every rule
-	* stays at its natural source position and the output is byte-identical to a plain du-bois build. This
+	* stays at its natural source position and the output is byte-identical to a plain dbui build. This
 	* is the flag-OFF stylesheet and is a provable no-op relative to today.
 	*/
 	mitigate: boolean;

package/dist-types/mcp/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(packageRoot: string): McpServer;
+export declare function startServer(packageRoot: string): Promise<void>;

package/dist-types/test-utils/rtl/switch.d.ts

@@ -1,5 +1,5 @@
 /**
-* Reads the checked state of a Du Bois Switch regardless of the rendering engine.
+* Reads the checked state of a dbui Switch regardless of the rendering engine.
 *
 * The AntD implementation renders the toggle as a `<button role="switch" aria-checked>`, so the
 * checked state lives in the `aria-checked` attribute. The native implementation renders an

package/dist-types/test-utils/rtl/table.d.ts

@@ -14,7 +14,7 @@ import type { GetTableRowByCellTextOptions, RowIdentifier, TableRows } from "../
 */
 export declare function getTableRowByCellText(tableElement: HTMLElement, cellText: string, { columnHeaderName }?: GetTableRowByCellTextOptions): HTMLElement;
 /**
-* Converts a Du Bois table to a markdown table string. This means that each cell
+* Converts a dbui table to a markdown table string. This means that each cell
 * is separated by a pipe (including the edges), the header row is on its own line
 * at the top, each data row is on its own line below, and the header row is separated
 * by a row of dashes from the data rows. This is useful for checking table contents

package/dist-types/theme/_generated/ValidSemanticColors.d.ts

@@ -62,6 +62,7 @@ export declare enum ValidSemanticColors {
 	BorderAccessible = "borderAccessible",
 	BorderDanger = "borderDanger",
 	BorderWarning = "borderWarning",
+	Certified = "certified",
 	CodeBackground = "codeBackground",
 	ComposerBackground = "composerBackground",
 	IconTrending = "iconTrending",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@databricks/design-system",
-  "version": "2.0.9",
-  "description": "DuBois Design System",
+  "version": "2.0.10",
+  "description": "dbui Design System",
   "keywords": [],
   "license": "ISC",
   "author": "",
@@ -55,7 +55,8 @@
   "files": [
     "/AGENTS.md",
     "/CHANGELOG.md",
-    "/setup.mjs",
+    "/processes",
+    "/scaffold_tool",
     "/scaffold-agents.md",
     "dist",
     "dist-types",
@@ -65,10 +66,25 @@
   "scripts": {
     "prepublish": "./scripts/prepublish",
     "postpublish": "./scripts/postpublish",
+    "stage-npm-release": "swc-node ./npm_publishing/publish_tool/src/index.ts",
+    "publish-tool:test": "databricks-jest --config npm_publishing/publish_tool/jest.config.ts",
+    "publish-tool:type-check": "tsc --noEmit --project npm_publishing/publish_tool/tsconfig.json",
+    "publish-tool:lint": "databricks-lint --no-cycles npm_publishing/processes npm_publishing/publish_tool",
+    "publish-tool:lint:fix": "yarn publish-tool:lint --fix",
+    "publish-tool:format": "databricks-webfmt --write npm_publishing/processes npm_publishing/publish_tool",
+    "publish-tool:format:check": "databricks-webfmt --check npm_publishing/processes npm_publishing/publish_tool",
+    "scaffold-tool:build": "bash ./scripts/build_scaffold_tool",
+    "npx-setup:run": "bash ./npm_publishing/scaffold_tool/run",
+    "scaffold-tool:test": "yarn scaffold-tool:build && databricks-jest --config npm_publishing/scaffold_tool/jest.config.ts",
+    "scaffold-tool:type-check": "tsc --noEmit --project npm_publishing/scaffold_tool/tsconfig.json",
+    "scaffold-tool:lint": "databricks-lint --no-cycles npm_publishing/processes npm_publishing/scaffold_tool",
+    "scaffold-tool:lint:fix": "yarn scaffold-tool:lint --fix",
+    "scaffold-tool:format": "databricks-webfmt --write npm_publishing/processes npm_publishing/scaffold_tool",
+    "scaffold-tool:format:check": "databricks-webfmt --check npm_publishing/processes npm_publishing/scaffold_tool",
     "generate": "npm-run-all generate:icons generate:graphics",
     "generate:icons": "rm -rf src/design-system/Icon/__generated/icons && svgr -d src/design-system/Icon/__generated/icons --typescript --icon --template src/design-system/Icon/generator/iconTemplate.js src/assets/icons && TURBO_HASH=1 yarn lint:fix && yarn workspace @databricks/du-bois-storybook generate && yarn workspace @databricks/du-bois-storybook format && swc-node ./scripts/generate_icon_catalog.ts",
     "generate:graphics": "rm -rf src/design-system/Graphic/__generated/graphics && node src/design-system/Graphic/generator/generateGraphics.js && TURBO_HASH=1 yarn lint:fix",
-    "clean": "rm -rf dist dist-types '*.tsbuildinfo'",
+    "clean": "rm -rf dist dist-types '*.tsbuildinfo' processes scaffold_tool scaffold-agents.md",
     "build": "DATABRICKS_DESIGN_SYSTEM_BUILD_SOURCES=false yarn databricks-pkgr build --no-emit-types && yarn build:less-colors",
     "build:dist": "DATABRICKS_DESIGN_SYSTEM_BUILD_SOURCES=true yarn databricks-pkgr build --no-emit-types && yarn build:less-colors",
     "emit-types": "databricks-pkgr emit-types --emit-types-dir dist-types --transformer oxc",
@@ -147,6 +163,7 @@
     "@emotion/unitless": "^0.8.1",
     "@floating-ui/dom": "^1.6.12",
     "@floating-ui/react": "^0.26.25",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@radix-ui/react-accordion": "^1.2.12",
     "@radix-ui/react-context-menu": "2.1.5",
     "@radix-ui/react-dialog": "1.0.5",
@@ -163,6 +180,7 @@
     "@radix-ui/react-toggle": "1.0.3",
     "@radix-ui/react-toolbar": "1.0.4",
     "@radix-ui/react-tooltip-patch": "npm:@radix-ui/react-tooltip@^1.0.7",
+    "@react-aria/breadcrumbs": "^3.5.31",
     "@react-aria/button": "^3.13.4",
     "@react-aria/combobox": "^3.14.0",
     "@react-aria/focus": "^3.21.4",
@@ -181,12 +199,14 @@
     "date-fns": "^3.6.0",
     "dom-accessibility-api": "^0.7.0",
     "downshift": "^6.1.9",
+    "listr2": "7.0.2",
     "lodash": "^4.17.21",
     "react-day-picker": "^8.10.1",
     "react-hook-form": "7.36.0",
     "react-resizable": "^3.0.4",
     "tabbable": "^6.4.0",
-    "tslib": "^2.8.1"
+    "tslib": "^2.8.1",
+    "zod": "^3.25.0"
   },
-  "bin": "./setup.mjs"
+  "bin": "./scaffold_tool/src/main.js"
 }

package/processes/process-runner.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeProcess = describeProcess;
+exports.runSuccessfulProcess = runSuccessfulProcess;
+function describeProcess(request) {
+    return [request.binary, ...request.args].join(' ');
+}
+async function runSuccessfulProcess(processRunner, request) {
+    const outcome = await processRunner.run(request);
+    if (outcome.timedOut) {
+        throw new Error(`${describeProcess(request)} timed out.`);
+    }
+    if (outcome.exitCode !== 0) {
+        const details = [outcome.stdout.trim(), outcome.stderr.trim()].filter(Boolean).join('\n');
+        const suffix = details ? `\n${details}` : '';
+        throw new Error(`${describeProcess(request)} failed with exit code ${outcome.exitCode}.${suffix}`);
+    }
+    return outcome;
+}