@carto/ps-react-ui 5.0.0-widgets.9 → 5.0.0

package/dist/types/components/lasso-tool/toolbar/connected.d.ts

@@ -0,0 +1,55 @@
+import { JSX } from 'react';
+import { ColorActionProps } from './actions/color-action.js';
+import { DeleteActionProps } from './actions/delete-action.js';
+import { EditGeometryActionProps } from './actions/edit-geometry-action.js';
+import { FillActionProps } from './actions/fill-action.js';
+import { LockActionProps } from './actions/lock-action.js';
+import { LabelActionProps } from './actions/label-action.js';
+import { StrokeActionProps } from './actions/stroke-action.js';
+import { ToggleTypeActionProps } from './actions/toggle-type-action.js';
+import { UnionActionProps } from './actions/union-action.js';
+import { SplitActionProps } from './actions/split-action.js';
+import { SubtractActionProps } from './actions/subtract-action.js';
+import { IntersectActionProps } from './actions/intersect-action.js';
+import { DuplicateActionProps } from './actions/duplicate-action.js';
+import { EditPropertiesActionProps } from './actions/edit-properties-action.js';
+/** Color picker. Hidden unless the whole selection is `draw` with a style. */
+export declare function ConnectedColorAction({ disabled, labels, }?: Pick<ColorActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Fill picker. Hidden unless the whole selection is `draw` with a style. */
+export declare function ConnectedFillAction({ disabled, labels, }?: Pick<FillActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Stroke picker. Hidden unless the whole selection is `draw` with a style. */
+export declare function ConnectedStrokeAction({ disabled, labels, }?: Pick<StrokeActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Starts the geometry-edit session. Single-target: off on a multi-selection. */
+export declare function ConnectedEditGeometryAction({ disabled, label, }?: Pick<EditGeometryActionProps, 'disabled' | 'label'>): JSX.Element | null;
+/** Label popover (name + map text presentation), anchored to the toolbar. Single-target. */
+export declare function ConnectedLabelAction({ disabled, labels, }?: Pick<LabelActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Edit properties popover (freeform KV), anchored to the toolbar. Single-target. */
+export declare function ConnectedEditPropertiesAction({ disabled, labels, }?: Pick<EditPropertiesActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Mask/draw toggle, active while the selection is a mask. */
+export declare function ConnectedToggleTypeAction({ disabled, labels, }?: Pick<ToggleTypeActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Merge. Needs two or more unlocked geometries selected. */
+export declare function ConnectedUnionAction({ disabled, label, }?: Pick<UnionActionProps, 'disabled' | 'label'>): JSX.Element | null;
+/**
+ * Split. Needs a single unlocked MultiPolygon selected (`splittable`) — the
+ * inverse of the merge action on disjoint inputs.
+ */
+export declare function ConnectedSplitAction({ disabled, label, }?: Pick<SplitActionProps, 'disabled' | 'label'>): JSX.Element | null;
+/** Subtract (first minus the rest). Needs 2+ unlocked geometries selected. */
+export declare function ConnectedSubtractAction({ disabled, label, }?: Pick<SubtractActionProps, 'disabled' | 'label'>): JSX.Element | null;
+/** Intersect (common area). Needs 2+ unlocked geometries selected. */
+export declare function ConnectedIntersectAction({ disabled, label, }?: Pick<IntersectActionProps, 'disabled' | 'label'>): JSX.Element | null;
+/** Duplicates the whole selection (offset copies). */
+export declare function ConnectedDuplicateAction({ disabled, label, }?: Pick<DuplicateActionProps, 'disabled' | 'label'>): JSX.Element | null;
+/**
+ * Lock toggle. Deliberately never disabled by the lock itself: it is the only
+ * way out of it.
+ *
+ * Driven by `locked` (ALL selected locked), not `anyLocked`, on purpose — the
+ * standard mixed-state convention: a partially locked selection shows an
+ * unpressed "Lock" and clicking it locks the WHOLE selection to a uniform
+ * state (then a second click unlocks everything). Tested in
+ * `geometry-toolbar.test.tsx` ("disables batch actions when anyLocked…").
+ */
+export declare function ConnectedLockAction({ disabled, labels, }?: Pick<LockActionProps, 'disabled' | 'labels'>): JSX.Element | null;
+/** Deletes the whole selection. */
+export declare function ConnectedDeleteAction({ disabled, label, }?: Pick<DeleteActionProps, 'disabled' | 'label'>): JSX.Element | null;

package/dist/types/components/lasso-tool/toolbar/context.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode, RefObject } from 'react';
+import { LassoGeometryToolbarUIProps } from '../types.js';
+/**
+ * Everything the connected actions need, derived once by
+ * `LassoGeometryToolbarUI` from the props it gets from the controller. Mirrors
+ * the widgets-v2 contract: an action reads its state from here instead of
+ * having it threaded through the call site.
+ */
+export interface LassoGeometryToolbarContextValue extends Omit<LassoGeometryToolbarUIProps, 'children' | 'PaperProps'> {
+    /** `anyLocked ?? locked` — a locked geometry makes the batch read-only. */
+    disabled: boolean;
+    /** `disabled` or a multi-selection: blocks the single-target actions. */
+    singleOnly: boolean;
+    /** Style pickers only apply to `draw` geometries with a style handler. */
+    showStyle: boolean;
+    /** The toolbar's Paper, so popovers anchor to it instead of their button. */
+    anchorRef?: RefObject<HTMLElement | null>;
+    /** Which single-instance popover (Label/Edit properties) is open — mutual exclusion. */
+    openPopoverId?: 'label' | 'editProperties' | null;
+    /** Compare-and-swap: only clears `openPopoverId` when it still matches `id`. */
+    onOpenPopoverChange?: (id: 'label' | 'editProperties', open: boolean) => void;
+}
+export declare function LassoGeometryToolbarProvider({ value, children, }: {
+    value: LassoGeometryToolbarContextValue;
+    children: ReactNode;
+}): import('react').JSX.Element;
+/**
+ * State for a connected action. Throws outside the toolbar: the alternative is
+ * a button that silently does nothing.
+ */
+export declare function useLassoGeometryToolbarAction(): LassoGeometryToolbarContextValue;

package/dist/types/components/lasso-tool/toolbar/index.d.ts

@@ -0,0 +1,41 @@
+export type { LassoToolbarUIProps } from './toolbar.js';
+export type { LassoToolbarButtonUIProps } from './button.js';
+export type { ToggleTypeActionProps } from './actions/toggle-type-action.js';
+export type { LabelActionProps, LassoTextPresentation, } from './actions/label-action.js';
+export type { EditPropertiesActionProps } from './actions/edit-properties-action.js';
+export type { LockActionProps } from './actions/lock-action.js';
+export type { DeleteActionProps } from './actions/delete-action.js';
+export type { ColorActionProps } from './actions/color-action.js';
+export type { FillActionProps } from './actions/fill-action.js';
+export type { StrokeActionProps } from './actions/stroke-action.js';
+export type { UndoActionProps } from './actions/undo-action.js';
+export type { RedoActionProps } from './actions/redo-action.js';
+export type { EditGeometryActionProps } from './actions/edit-geometry-action.js';
+export type { UnionActionProps } from './actions/union-action.js';
+export type { SplitActionProps } from './actions/split-action.js';
+export type { SubtractActionProps } from './actions/subtract-action.js';
+export type { IntersectActionProps } from './actions/intersect-action.js';
+export type { DuplicateActionProps } from './actions/duplicate-action.js';
+export type { AcceptActionProps } from './actions/accept-action.js';
+export type { CancelActionProps } from './actions/cancel-action.js';
+export { LassoToolbarUI } from './toolbar.js';
+export { LassoToolbarButtonUI } from './button.js';
+export { ToggleTypeAction, TOGGLE_TYPE_ACTION_LABELS, } from './actions/toggle-type-action.js';
+export { LabelAction, LABEL_ACTION_LABELS } from './actions/label-action.js';
+export { EditPropertiesAction, EDIT_PROPERTIES_ACTION_LABELS, } from './actions/edit-properties-action.js';
+export { LockAction, LOCK_ACTION_LABELS } from './actions/lock-action.js';
+export { DeleteAction, DELETE_ACTION_LABELS } from './actions/delete-action.js';
+export { ColorAction, ColorDot, COLOR_ACTION_LABELS, LASSO_DRAW_COLOR_HEX, isLassoDrawColorPreset, normalizeHex, } from './actions/color-action.js';
+export { FillAction, FILL_ACTION_LABELS } from './actions/fill-action.js';
+export { StrokeAction, STROKE_ACTION_LABELS } from './actions/stroke-action.js';
+export { UndoAction, UNDO_ACTION_LABELS } from './actions/undo-action.js';
+export { RedoAction, REDO_ACTION_LABELS } from './actions/redo-action.js';
+export { EditGeometryAction, EDIT_GEOMETRY_ACTION_LABELS, } from './actions/edit-geometry-action.js';
+export { UnionAction, UNION_ACTION_LABELS } from './actions/union-action.js';
+export { SplitAction, SPLIT_ACTION_LABELS } from './actions/split-action.js';
+export { SubtractAction, SUBTRACT_ACTION_LABELS, } from './actions/subtract-action.js';
+export { IntersectAction, INTERSECT_ACTION_LABELS, } from './actions/intersect-action.js';
+export { DuplicateAction, DUPLICATE_ACTION_LABELS, } from './actions/duplicate-action.js';
+export { AcceptAction, ACCEPT_ACTION_LABELS } from './actions/accept-action.js';
+export { CancelAction, CANCEL_ACTION_LABELS } from './actions/cancel-action.js';
+export { ICON_SIZE } from './styles.js';

package/dist/types/components/lasso-tool/toolbar/styles.d.ts

@@ -0,0 +1,26 @@
+import { SxProps, Theme } from '@mui/material';
+/** Icon font-size shared by every toolbar action. */
+export declare const ICON_SIZE = 18;
+export declare const styles: {
+    container: {
+        display: "flex";
+        flexDirection: "row";
+        alignItems: "center";
+        width: string;
+        gap: ({ spacing }: Theme) => string;
+        p: ({ spacing }: Theme) => string;
+        borderRadius: ({ spacing }: Theme) => string;
+        backgroundColor: ({ palette }: Theme) => string;
+    };
+    baseButton: {
+        p: ({ spacing }: Theme) => string;
+        borderRadius: ({ spacing }: Theme) => string;
+        '.MuiTouchRipple-ripple .MuiTouchRipple-child': {
+            borderRadius: ({ spacing }: Theme) => string;
+        };
+        '&.Mui-disabled': {
+            opacity: ({ palette }: Theme) => number;
+        };
+    };
+    toggleButton: (active: boolean) => SxProps<Theme>;
+};

package/dist/types/components/lasso-tool/toolbar/toolbar.d.ts

@@ -0,0 +1,30 @@
+import { Paper } from '@mui/material';
+import { ComponentProps, JSX, PropsWithChildren, Ref } from 'react';
+export interface LassoToolbarUIProps extends PropsWithChildren {
+    /**
+     * `ref` excluded: in React 19 it travels as a regular prop inside
+     * `ComponentProps`, and the spread below would silently replace the
+     * toolbar-controlled `ref` (which e.g. anchors the rename popover in
+     * `LassoGeometryToolbarUI`). Use the toolbar's own `ref` prop instead.
+     */
+    PaperProps?: Omit<ComponentProps<typeof Paper>, 'ref'>;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Generic floating toolbar for lasso actions: a `Paper` row hosting
+ * self-contained action buttons (see `toolbar/actions`). Compose any mix of
+ * actions and dividers:
+ *
+ * @example
+ * ```tsx
+ * <LassoToolbarUI>
+ *   <LabelAction label={label} onRename={onRename} onSetTextPresentation={...} />
+ *   <LassoToolbarUI.Divider />
+ *   <DeleteAction onDelete={onDelete} />
+ * </LassoToolbarUI>
+ * ```
+ */
+export declare function LassoToolbarUI({ children, PaperProps: { sx, ...PaperProps }, ref, }: LassoToolbarUIProps): JSX.Element;
+export declare namespace LassoToolbarUI {
+    var Divider: () => JSX.Element;
+}

package/dist/types/components/lasso-tool/tools-context.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { LassoToolsUIContextValue } from './types.js';
+export declare function LassoToolsUIProvider({ value, children, }: {
+    value: LassoToolsUIContextValue;
+    children: ReactNode;
+}): import('react').JSX.Element;
+/**
+ * Merges a block's own props over the toolbar's context, so the blocks work
+ * both ways: with explicit props, or written bare as children
+ * (`<LassoToolsUI.Chips />`). Explicit props always win.
+ */
+export declare function useLassoToolsUIArgs<T extends LassoToolsUIContextValue>(props: T): T & LassoToolsUIContextValue;

package/dist/types/components/lasso-tool/types.d.ts

@@ -1,15 +1,36 @@
-import { Box, ChipProps, Paper, TooltipProps } from '@mui/material';
-import { ComponentProps, ComponentType } from 'react';
-import { LassoToolsMode, LassoToolsModes, LassoToolOptionsMode, LassoToolsModesMapping } from '../types';
+import { AlertColor, AlertProps, Box, ChipProps, DialogProps, Paper, SnackbarProps, TooltipProps } from '@mui/material';
+import { ComponentProps, ReactNode } from 'react';
+import { LassoToolsMode, LassoToolsModes, LassoToolOptionsMode, LassoToolsModesMapping } from '../types.js';
 export interface LassoToolsData {
     id: string;
     label: string;
     visible?: boolean;
+    /** When locked, the chip shows a padlock icon instead of the mask glyph. */
+    locked?: boolean;
+    /** `mask` (default) shows the mask glyph; `draw` chips have no icon unless locked. */
+    type?: LassoGeometryType;
+}
+export type LassoGeometryType = 'mask' | 'draw';
+/** Preset color names for `draw` geometries (CARTO qualitative Pastel scheme). */
+export type LassoDrawColorPreset = 'yellow' | 'orange' | 'purple' | 'pink' | 'green' | 'brown' | 'black' | 'white';
+/**
+ * Draw / map-label color: a named preset, or a freeform hex string (`#rrggbb`)
+ * from the Custom color picker. `string & {}` keeps presets visible to
+ * IntelliSense without collapsing the union to plain `string`.
+ */
+export type LassoDrawColor = LassoDrawColorPreset | (string & {});
+export type LassoDrawFill = 'filled' | 'opacity' | 'none';
+export type LassoDrawStroke = 'thick' | 'default' | 'thin' | 'none';
+/** Visual style of a `draw` geometry. */
+export interface LassoDrawStyle {
+    color: LassoDrawColor;
+    fill: LassoDrawFill;
+    stroke: LassoDrawStroke;
 }
 interface LassoToolsComponentBaseProps<M extends string = LassoToolsMode> {
     enabled: boolean;
     modes: Partial<LassoToolsModes<M>>;
-    modesMapping: LassoToolsModesMapping<M>;
+    modesMapping: Partial<LassoToolsModesMapping<M>>;
     values: LassoToolsData[];
     labels?: {
         action?: {
@@ -29,6 +50,17 @@ interface LassoToolsComponentBaseProps<M extends string = LassoToolsMode> {
                 title?: string;
                 options?: LassoToolOptionsMode<LassoToolsMode>;
             };
+            interactionMode?: {
+                title?: string;
+                mask?: string;
+                draw?: string;
+            };
+            selection?: {
+                /** Heading of the "Selection tools" menu section. */
+                title?: string;
+            };
+            /** Label for the optional "Layer filters" menu item. */
+            layerFilters?: string;
         };
         noData?: {
             title?: string;
@@ -40,34 +72,276 @@ interface LassoToolsComponentBaseProps<M extends string = LassoToolsMode> {
                 inactive?: string;
             };
             deleteAll?: string;
+            /** Accessible name of the secondary-actions "⋮" trigger. */
+            more?: string;
+        };
+        undoRedo?: {
+            undo?: string;
+            redo?: string;
         };
     };
     chipProps?: {
-        TooltipProps?: Omit<TooltipProps, 'title'>;
+        TooltipProps?: Partial<Omit<TooltipProps, 'title' | 'children'>>;
         ChipsProps?: Omit<ChipProps, 'label' | 'onDelete'>;
     };
     modeSelected?: M | null;
+    /**
+     * When provided together with `onChangeInteractionMode`, the options menu
+     * shows an "Interaction mode" radio section (Mask/Draw) at the top.
+     */
+    interactionMode?: LassoGeometryType;
+    onChangeInteractionMode?: (mode: LassoGeometryType) => void;
+    /** Disables the Mask radio while e.g. the text draw mode is active. */
+    interactionModeMaskDisabled?: boolean;
     onChangeMode: (mode: M) => void;
     onChipToggle: (id: LassoToolsData['id'], data: boolean) => void;
     onDelete: (id: LassoToolsData['id']) => void;
     onAllChipToggle: () => void;
     onAllDelete: () => void;
+    /**
+     * When provided, the drawing-tool menu shows a "Layer filters" item at the
+     * bottom that calls this (e.g. to open the {@link LassoLayerFiltersUI} dialog).
+     * The trigger lives in the menu; the dialog is a separate component.
+     */
+    onLayerFilters?: () => void;
+    /**
+     * Undo/redo block: rendered by `.UndoRedo` (while `enabled`) when both
+     * `onUndo` and `onRedo` are provided.
+     */
+    canUndo?: boolean;
+    canRedo?: boolean;
+    onUndo?: () => void;
+    onRedo?: () => void;
+    /** Keyboard-shortcut hints appended to the undo/redo tooltips. */
+    shortcuts?: {
+        undo?: string;
+        redo?: string;
+    };
 }
 export interface LassoToolsComponentProps<M extends string = LassoToolsMode> extends LassoToolsComponentBaseProps<M> {
+    /**
+     * The blocks this toolbar has, in render order (`LassoToolsUI.Action`,
+     * `.OptionsMenu`, `.UndoRedo`, `.Chips`, `.SecondaryActions`). Required —
+     * without `children` the shell renders empty chrome. See
+     * `stories/modules/lasso/lasso-tools-toolbar.tsx` for the full CARTO design.
+     */
+    children: ReactNode;
     actionProps?: {
-        TooltipProps?: Omit<TooltipProps, 'title'>;
+        TooltipProps?: Partial<Omit<TooltipProps, 'title' | 'children'>>;
     };
     PaperProps?: ComponentProps<typeof Paper>;
     onActionToggle: (data: boolean) => void;
-    ChipsSlot?: ComponentType<Partial<Omit<LassoToolsComponentProps, 'ChipsSlot' | 'ActionsSlot' | 'OptionsSlot' | 'SecondaryActionsSlot'>>> | null;
-    ActionSlot?: ComponentType<Partial<Omit<LassoToolsComponentProps, 'ChipsSlot' | 'ActionsSlot' | 'OptionsSlot' | 'SecondaryActionsSlot'>>> | null;
-    OptionsSlot?: ComponentType<Partial<Omit<LassoToolsComponentProps, 'ChipsSlot' | 'ActionsSlot' | 'OptionsSlot' | 'SecondaryActionsSlot'>> & OptionsChildrenProps> | null;
-    SecondaryActionsSlot?: ComponentType<Partial<Omit<LassoToolsComponentProps, 'ChipsSlot' | 'ActionsSlot' | 'OptionsSlot' | 'SecondaryActionsSlot'>>> | null;
 }
+/**
+ * Wiring props the shell publishes on context for compound blocks. Partial so
+ * blocks work when only a subset of handlers is present (they self-null).
+ */
+export type LassoToolsUIContextValue<M extends string = LassoToolsMode> = Partial<Omit<LassoToolsComponentProps<M>, 'children'>>;
 export interface LassoToolsInlineComponentProps<M extends string = LassoToolsMode> extends LassoToolsComponentBaseProps<M> {
+    /**
+     * The blocks this toolbar has, in render order (`LassoToolsInlineUI.Modes`,
+     * `.InteractionMode`, `.UndoRedo`, `.Chips`, `.Actions`). Required — without
+     * `children` the shell renders empty chrome. See
+     * `stories/modules/lasso/lasso-tools-inline-toolbar.tsx` for the full design.
+     */
+    children: ReactNode;
     BoxProps?: ComponentProps<typeof Box>;
 }
 export interface OptionsChildrenProps {
     onClose: () => void;
 }
+export interface LassoGeometryToolbarUIProps {
+    /**
+     * The actions this toolbar has, in render order — see
+     * {@link LassoGeometryToolbarUI}. Every state prop below is optional because
+     * the composition decides which ones matter: an action whose handler is
+     * missing renders nothing.
+     */
+    children: ReactNode;
+    /** Geometry type — `mask` clips layers, `draw` is annotation only. */
+    type?: LassoGeometryType;
+    /** Current geometry label, shown prefilled in the rename popover. */
+    label?: string;
+    /** When locked, every action but the unlock toggle is disabled. */
+    locked?: boolean;
+    /**
+     * Number of selected geometries. With more than one, the single-target
+     * actions (rename, edit geometry) are disabled and the rest apply to the
+     * whole selection.
+     * @default 1
+     */
+    selectionCount?: number;
+    /**
+     * True when ANY selected geometry is locked: disables every action but the
+     * lock toggle (which then locks/unlocks the whole selection). Defaults to
+     * `locked` for single-selection usage.
+     */
+    anyLocked?: boolean;
+    /**
+     * Current style of a `draw` geometry. Together with `onSetStyle`, shows the
+     * Color/Fill/Stroke pickers when `type === 'draw'`.
+     */
+    style?: LassoDrawStyle;
+    onToggleType?: (type: LassoGeometryType) => void;
+    onRename?: (label: string) => void;
+    /**
+     * Basemap-derived fallback for map-label color when `properties.textColor`
+     * is unset (`white` on dark basemaps, `black` otherwise). Connected Label
+     * derives presentation from {@link properties} + this.
+     */
+    defaultTextColor?: LassoDrawColor;
+    /** Applies map-label presentation live (one undo each). */
+    onSetTextPresentation?: (partial: {
+        textVisible?: boolean;
+        textColor?: LassoDrawColor;
+        textBold?: boolean;
+        textItalic?: boolean;
+    }) => void;
+    onToggleLock?: (locked: boolean) => void;
+    onDelete?: () => void;
+    /** Merges a partial style into the geometry (color/fill/stroke pickers). */
+    onSetStyle?: (style: Partial<LassoDrawStyle>) => void;
+    /** When provided, shows the "Edit geometry" action (left of label). */
+    onEditGeometry?: () => void;
+    /** Highlights the "Edit geometry" action while a session is running. */
+    editingGeometry?: boolean;
+    /**
+     * When provided, shows the merge action next to the mask/draw toggle. Only
+     * enabled with 2+ geometries selected and none locked.
+     */
+    onUnion?: () => void;
+    /**
+     * True when the selection is a single MultiPolygon — the only shape the
+     * Split action applies to. Gates the Split action's enabled state.
+     */
+    splittable?: boolean;
+    /**
+     * When provided, shows the split action (inverse of merge). Only enabled
+     * with a single MultiPolygon selected (`splittable`) and not locked.
+     */
+    onSplit?: () => void;
+    /**
+     * When provided, shows the subtract action (first selected minus the rest).
+     * Only enabled with 2+ geometries selected and none locked.
+     */
+    onSubtract?: () => void;
+    /**
+     * When provided, shows the intersect action (common area of the selection).
+     * Only enabled with 2+ geometries selected and none locked.
+     */
+    onIntersect?: () => void;
+    /**
+     * When provided, shows the duplicate action (copies the selection, slightly
+     * offset). Disabled while any selected geometry is locked.
+     */
+    onDuplicate?: () => void;
+    /**
+     * Ids of the selected geometries. Used to detect a selection change while a
+     * popover (Label/Edit properties) is open, so an in-flight edit never
+     * lands on the wrong geometry.
+     */
+    selectedIds?: string[];
+    /**
+     * Full properties of the first selected geometry — only meaningful for a
+     * single selection. Label presentation is derived from these; Edit
+     * properties filters system keys before showing the KV editor.
+     */
+    properties?: Record<string, unknown>;
+    /** Commits a full replacement of the editable properties (single-selection). */
+    onEditProperties?: (draft: Record<string, unknown>) => void;
+    /**
+     * When true (Point text annotations), the Label popover hides "Show on map"
+     * and presentation updates cannot turn `textVisible` off.
+     */
+    forceTextVisible?: boolean;
+    labels?: {
+        toggleType?: {
+            mask?: string;
+            draw?: string;
+        };
+        /** Tooltip/aria-label for the Label button. */
+        label?: string;
+        /** TextField label for the name input in the Label popover. */
+        labelName?: string;
+        showOnMap?: string;
+        textBold?: string;
+        textItalic?: string;
+        lock?: {
+            lock?: string;
+            unlock?: string;
+        };
+        delete?: string;
+        editGeometry?: string;
+        union?: string;
+        split?: string;
+        subtract?: string;
+        intersect?: string;
+        duplicate?: string;
+        /** Tooltip/aria-label and popover copy for the Edit properties action. */
+        editProperties?: {
+            editProperties?: string;
+            keyPlaceholder?: string;
+            valuePlaceholder?: string;
+            addRow?: string;
+            removeRow?: string;
+            emptyKeyError?: string;
+            duplicateKeyError?: string;
+            systemKeyError?: string;
+        };
+        color?: {
+            tooltip?: string;
+            /** Preset names plus UI-only `custom` (never persisted as a color value). */
+            options?: Partial<Record<LassoDrawColorPreset | 'custom', string>>;
+        };
+        fill?: {
+            tooltip?: string;
+            options?: Partial<Record<LassoDrawFill, string>>;
+        };
+        stroke?: {
+            tooltip?: string;
+            options?: Partial<Record<LassoDrawStroke, string>>;
+        };
+    };
+    /** Forwarded to `LassoToolbarUI`, which owns the Paper's `ref` (popover anchoring). */
+    PaperProps?: Omit<ComponentProps<typeof Paper>, 'ref'>;
+}
+export interface LassoMessageUIProps {
+    /** Message from the lasso tools store (`LassoToolsMessage` in `@carto/ps-react-maps`). */
+    message: {
+        id: string;
+        title: string;
+        /** Body rendered under the title. */
+        content?: ReactNode;
+        /** @default 'info' */
+        severity?: AlertColor;
+        action?: ReactNode;
+    };
+    onDismiss: () => void;
+    AlertProps?: Omit<AlertProps, 'severity' | 'onClose' | 'children' | 'action'>;
+    SnackbarProps?: Omit<SnackbarProps, 'open' | 'onClose' | 'children'>;
+}
+export interface LassoLayerFilterItem {
+    id: string;
+    label: string;
+    /** Whether the mask currently clips this layer. */
+    checked: boolean;
+}
+export interface LassoLayerFiltersUIProps {
+    open: boolean;
+    onClose: () => void;
+    /** Layers the mask can apply to, with their current checked state. */
+    layers: LassoLayerFilterItem[];
+    /** Commit the new selection (called on Apply). */
+    onApply: (selectedIds: string[]) => void;
+    labels?: {
+        title?: string;
+        description?: string;
+        search?: string;
+        allSelected?: string;
+        cancel?: string;
+        apply?: string;
+        empty?: string;
+    };
+    DialogProps?: Partial<Omit<DialogProps, 'open' | 'onClose'>>;
+}
 export {};

package/dist/types/components/lasso-tool/undo-redo.d.ts

@@ -0,0 +1,25 @@
+import { BoxProps } from '@mui/material';
+import { JSX } from 'react';
+export interface LassoUndoRedoUIProps {
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+    labels?: {
+        undo?: string;
+        redo?: string;
+    };
+    /** Keyboard-shortcut hints appended to each tooltip, e.g. `{ undo: '⌘Z' }`. */
+    shortcuts?: {
+        undo?: string;
+        redo?: string;
+    };
+    BoxProps?: BoxProps;
+}
+/**
+ * Self-contained undo/redo block (two icon buttons, disabled when their stack
+ * is empty). Composable: drop it in the lasso main toolbar (e.g.
+ * `LassoToolsUI.UndoRedo`), a `LassoToolbarUI`, or anywhere else, wired to
+ * `LassoTools.UndoRedo` from `@carto/ps-react-maps`.
+ */
+export declare function LassoUndoRedoUI({ canUndo, canRedo, onUndo, onRedo, labels, shortcuts, BoxProps: { sx, ...BoxProps }, }: LassoUndoRedoUIProps): JSX.Element;

package/dist/types/components/list-data/list-data-skeleton.d.ts

@@ -1,5 +1,5 @@
 interface ListDataSkeletonProps {
     length?: number;
 }
-export declare function ListDataSkeleton({ length }: ListDataSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export declare function ListDataSkeleton({ length }: ListDataSkeletonProps): import('react').JSX.Element;
 export {};

package/dist/types/components/list-data/list-data.d.ts

@@ -1,3 +1,19 @@
 import { JSX } from 'react';
-import { ListDataProps } from './types';
+import { ListDataProps } from './types.js';
+/**
+ * Displays structured data in an accessible list format with expandable views, interactive selection, tooltips, and loading states.
+ *
+ * @example
+ * ```tsx
+ * <ListDataUI
+ *   data={[
+ *     { id: '1', label: 'Population', value: '8.4M' },
+ *     { id: '2', label: 'Median Age', value: '32 years' },
+ *   ]}
+ *   maxItems={3}
+ *   onItemClick={(item) => setSelectedId(item.id)}
+ *   selectedItemId={selectedId}
+ * />
+ * ```
+ */
 export declare function ListDataUI({ data, isLoading, maxItems, labels, showDivider, selectedItemId, tooltipProps, onExpand, onItemClick, }: ListDataProps): JSX.Element;

package/dist/types/components/measurement-tools/const.d.ts

@@ -1,6 +1,6 @@
 import { RequiredDeep } from 'type-fest';
-import { MeasurementMode, MeasurementModesMapping, MeasurementUnitsMapping } from '../types';
-import { MeasurementToolsComponentProps } from './types';
+import { MeasurementMode, MeasurementModesMapping, MeasurementUnitsMapping } from '../types.js';
+import { MeasurementToolsComponentProps } from './types.js';
 export declare const DEFAULT_MEASUREMENT_TOOLS_LABELS: NonNullable<RequiredDeep<MeasurementToolsComponentProps['labels']>>;
 export declare const DEFAULT_MEASUREMENT_TOOLS_UNITS_MAPPING: MeasurementUnitsMapping;
 export declare const DEFAULT_MEASUREMENT_TOOLS_MODES_MAPPING: MeasurementModesMapping<MeasurementMode>;

package/dist/types/components/measurement-tools/icons.d.ts

@@ -1,4 +1,4 @@
 import { SVGProps } from 'react';
-export declare function RulerIcon(props: SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
-export declare function BufferIcon(props: SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
-export declare function AreaIcon(props: SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;
+export declare function RulerIcon(props: SVGProps<SVGSVGElement>): import('react').JSX.Element;
+export declare function BufferIcon(props: SVGProps<SVGSVGElement>): import('react').JSX.Element;
+export declare function AreaIcon(props: SVGProps<SVGSVGElement>): import('react').JSX.Element;

package/dist/types/components/measurement-tools/measurement-tools.d.ts

@@ -1,3 +1,23 @@
 import { JSX } from 'react';
-import { MeasurementToolsComponentProps } from './types';
+import { MeasurementToolsComponentProps } from './types.js';
+/**
+ * Provides a measurement interface for calculating distances, areas, and buffers on maps with support for metric and imperial unit systems and real-time unit conversion.
+ *
+ * @example
+ * ```tsx
+ * <MeasurementToolsUI
+ *   enabled={enabled}
+ *   value={measurementValue}
+ *   modes={DEFAULT_MEASUREMENT_TOOLS_MODES}
+ *   units={DEFAULT_MEASUREMENT_TOOLS_UNITS}
+ *   modesMapping={DEFAULT_MEASUREMENT_TOOLS_MODES_MAPPING}
+ *   unitsMapping={DEFAULT_MEASUREMENT_TOOLS_UNITS_MAPPING}
+ *   modeSelected={mode}
+ *   unitSelected={unit}
+ *   onActionToggle={setEnabled}
+ *   onChangeMode={setMode}
+ *   onChangeUnit={setUnit}
+ * />
+ * ```
+ */
 export declare function MeasurementToolsUI({ enabled, actionProps, labels, modes, modesMapping, unitsMapping, modeSelected, PaperProps: { sx, ...PaperProps }, units, unitSelected, onActionToggle, onChangeMode, onChangeUnit, }: MeasurementToolsComponentProps): JSX.Element;