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

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

@@ -1,14 +1,39 @@
 import { JSX } from 'react';
 import { PickDeep } from 'type-fest';
-import { LassoToolsComponentProps, OptionsChildrenProps } from './types';
-export declare function LassoToolsUI({ enabled, values, actionProps, chipProps, labels, modes, modesMapping, modeSelected, PaperProps: { sx, ...PaperProps }, onActionToggle, onChipToggle, onDelete, onChangeMode, onAllChipToggle, onAllDelete, ChipsSlot, ActionSlot, SecondaryActionsSlot, OptionsSlot, }: LassoToolsComponentProps): JSX.Element;
+import { LassoToolsComponentProps, LassoToolsUIContextValue, OptionsChildrenProps } from './types.js';
+/**
+ * Floating interface for spatial selection and drawing — a shell that publishes
+ * wiring props on context. **Which blocks it has is the consumer's call** —
+ * list them as children. See `stories/modules/lasso/lasso-tools-toolbar.tsx`
+ * for the full CARTO design.
+ *
+ * @example
+ * ```tsx
+ * <LassoToolsUI {...props}>
+ *   <LassoToolsUI.Action />
+ *   <LassoToolsUI.OptionsMenu />
+ *   <LassoToolsUI.UndoRedo />
+ *   <LassoToolsUI.Chips />
+ *   <LassoToolsUI.SecondaryActions />
+ * </LassoToolsUI>
+ * ```
+ */
+export declare function LassoToolsUI({ enabled, values, actionProps, chipProps, labels, modes, modesMapping, modeSelected, interactionMode, PaperProps: { sx, ...PaperProps }, onActionToggle, onChipToggle, onDelete, onChangeMode, onChangeInteractionMode, interactionModeMaskDisabled, onAllChipToggle, onAllDelete, onLayerFilters, canUndo, canRedo, onUndo, onRedo, shortcuts, children, }: LassoToolsComponentProps): JSX.Element;
 export declare namespace LassoToolsUI {
-    var Action: ({ modes, modesMapping, modeSelected, actionProps, enabled, labels, onActionToggle, }: Partial<Omit<LassoToolsComponentProps, "ChipsSlot" | "ActionsSlot" | "OptionsSlot" | "SecondaryActionsSlot">> & {
-        labels?: PickDeep<LassoToolsComponentProps["labels"], "actions">["actions"];
-    }) => import("react/jsx-runtime").JSX.Element;
-    var Chips: ({ values, labels, chipProps, onDelete, onChipToggle, onActionToggle, }: Partial<Omit<LassoToolsComponentProps, "ChipsSlot" | "ActionsSlot" | "OptionsSlot" | "SecondaryActionsSlot">>) => false | import("react/jsx-runtime").JSX.Element;
-    var SecondaryActions: typeof SecondaryActionsWrapper;
-    var Options: ({ values, modes, modesMapping, modeSelected, labels, onChangeMode, ...props }: Partial<Omit<LassoToolsComponentProps, "ChipsSlot" | "ActionsSlot" | "OptionsSlot" | "SecondaryActionsSlot">> & OptionsChildrenProps) => import("react/jsx-runtime").JSX.Element;
+    var Action: (props: BlockProps) => JSX.Element;
+    var Chips: (props: Parameters<typeof ChipsWrapperBase>[0]) => JSX.Element;
+    var SecondaryActions: (props: Parameters<typeof SecondaryActionsWrapperBase>[0]) => JSX.Element;
+    var UndoRedo: (props: Parameters<typeof UndoRedoWrapperBase>[0]) => JSX.Element;
+    var Options: (props: Parameters<typeof OptionsWrapperBase>[0]) => JSX.Element;
+    var OptionsMenu: (props: Omit<Parameters<typeof OptionsWrapperBase>[0], keyof OptionsChildrenProps>) => JSX.Element;
 }
-declare function SecondaryActionsWrapper({ values, labels, onAllChipToggle, onAllDelete, }: Partial<Omit<LassoToolsComponentProps, 'ChipsSlot' | 'ActionsSlot' | 'OptionsSlot' | 'SecondaryActionsSlot'>>): import("react/jsx-runtime").JSX.Element | null;
+declare function SecondaryActionsWrapper({ values, labels, onAllChipToggle, onAllDelete, }: LassoToolsUIContextValue): JSX.Element | null;
+declare const ActionsWrapperBase: ({ modes, modesMapping, modeSelected, actionProps, enabled, labels, onActionToggle, }: LassoToolsUIContextValue & {
+    labels?: PickDeep<LassoToolsComponentProps["labels"], "actions">["actions"];
+}) => JSX.Element;
+declare const ChipsWrapperBase: ({ values, labels, chipProps, onDelete, onChipToggle, onActionToggle, }: LassoToolsUIContextValue) => false | JSX.Element;
+declare const SecondaryActionsWrapperBase: typeof SecondaryActionsWrapper;
+declare const UndoRedoWrapperBase: ({ enabled, labels, canUndo, canRedo, onUndo, onRedo, shortcuts, }: LassoToolsUIContextValue) => JSX.Element | null;
+declare const OptionsWrapperBase: ({ modes, modesMapping, modeSelected, interactionMode, interactionModeMaskDisabled, labels, onChangeMode, onChangeInteractionMode, ...props }: LassoToolsUIContextValue & OptionsChildrenProps) => JSX.Element;
+type BlockProps = Parameters<typeof ActionsWrapperBase>[0];
 export {};

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

@@ -0,0 +1,10 @@
+import { JSX } from 'react';
+import { LassoLayerFiltersUIProps } from './types.js';
+/**
+ * "Layer filters" dialog: choose which map layers the lasso mask clips. The
+ * selection is a draft committed on Apply (Cancel/close discards it). Wire it
+ * to the lasso store via `LassoTools.LayerFilters` in `@carto/ps-react-maps`,
+ * and open it from the drawing-tool menu's "Layer filters" item
+ * (`LassoToolsUI` `onLayerFilters`).
+ */
+export declare function LassoLayerFiltersUI({ open, onClose, layers, onApply, labels, DialogProps, }: LassoLayerFiltersUIProps): JSX.Element;

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

@@ -0,0 +1,7 @@
+import { LassoMessageUIProps } from './types.js';
+/**
+ * Presentational counterpart of `LassoTools.Message` (`@carto/ps-react-maps`),
+ * positioned by that render-props component. Auto-hides after 5 seconds via
+ * MUI `Snackbar` (calls `onDismiss`, which removes the message from the store).
+ */
+export declare function LassoMessageUI({ message, onDismiss, AlertProps, SnackbarProps, }: LassoMessageUIProps): import('react').JSX.Element;

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

@@ -0,0 +1,28 @@
+import { JSX } from 'react';
+import { LassoGeometryType } from './types.js';
+export interface InteractionModeSectionProps {
+    value: LassoGeometryType;
+    labels?: {
+        title?: string;
+        mask?: string;
+        draw?: string;
+    };
+    onChange: (mode: LassoGeometryType) => void;
+    /** When true, the Mask radio is disabled (e.g. while the text draw mode is active). */
+    maskDisabled?: boolean;
+}
+/**
+ * "Interaction mode" section (Mask/Draw) for the lasso options menu.
+ * Composable: rendered by `LassoToolsUI.Options` when
+ * `onChangeInteractionMode` is provided, and usable standalone in custom
+ * menus — it MUST live under an ancestor with `role="menu"`/`"menubar"`
+ * (`menuitemradio` is only valid inside one). Selecting an option does not
+ * close the menu.
+ *
+ * Rendered as `MenuItem`s with `role="menuitemradio"` — NOT a `RadioGroup`:
+ * MUI's `MenuList` skips non-MenuItem children in arrow-key navigation and
+ * closes the menu on Tab, so a radio group inside the menu would be
+ * unreachable by keyboard. The `Radio` glyph is purely decorative
+ * (`aria-hidden`); the checked state lives in `aria-checked`.
+ */
+export declare function InteractionModeSection({ value, labels, onChange, maskDisabled, }: InteractionModeSectionProps): JSX.Element;

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

@@ -1,4 +1,11 @@
-import { Theme } from '@mui/material';
+import { SxProps, Theme } from '@mui/material';
+type SxEntry = Exclude<NonNullable<SxProps<Theme>>, readonly unknown[] | boolean>;
+/**
+ * Merges a component's own `sx` with the caller's. Needed because `SxProps` is
+ * not always an object — a function or an array is silently dropped by an
+ * object spread — and MUI's array form rejects falsy entries.
+ */
+export declare function mergeSx(...values: (SxProps<Theme> | undefined)[]): SxEntry[];
 export declare const styles: {
     container: {
         display: "flex";
@@ -6,10 +13,16 @@ export declare const styles: {
         alignItems: "center";
         justifyContent: "flex-start";
         overflow: "hidden";
+        width: string;
         '&.inline': {
             flexDirection: "column";
             alignItems: "flex-start";
             gap: ({ spacing }: Theme) => string;
+            '& > * + *': {
+                borderTop: number;
+                borderColor: "divider";
+                paddingTop: ({ spacing }: Theme) => string;
+            };
         };
     };
     actions: {
@@ -23,8 +36,16 @@ export declare const styles: {
         };
     };
     options: {
+        paper: {
+            '&.MuiMenu-paper': {
+                maxHeight: string;
+            };
+        };
         menu: {
-            paddingTop: ({ spacing }: Theme) => string;
+            '&.MuiMenu-list': {
+                maxHeight: string;
+            };
+            paddingY: ({ spacing }: Theme) => string;
             '&.inline': {
                 boxShadow: "none";
                 backgroundColor: "transparent";
@@ -130,3 +151,4 @@ export declare const styles: {
         };
     };
 };
+export {};

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

@@ -0,0 +1,13 @@
+import { JSX } from 'react';
+export declare const ACCEPT_ACTION_LABELS: {
+    readonly accept: "Accept";
+};
+export interface AcceptActionProps {
+    disabled?: boolean;
+    label?: string;
+    /** Keyboard-shortcut hint appended to the tooltip, e.g. `"↵"`. */
+    shortcut?: string;
+    onAccept: () => void;
+}
+/** Confirms the in-progress operation (equivalent to Enter). */
+export declare function AcceptAction({ disabled, label, shortcut, onAccept, }: AcceptActionProps): JSX.Element;

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

@@ -0,0 +1,28 @@
+import { JSX, ReactNode } from 'react';
+export interface ActionMenuOption<V extends string> {
+    value: V;
+    label: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+    /**
+     * When set, called instead of `onChange` (e.g. open a native color picker).
+     * The menu still closes.
+     */
+    onSelect?: () => void;
+}
+export interface ActionMenuProps<V extends string> {
+    /** Tooltip and `aria-label` of the trigger button. */
+    label: string;
+    icon: ReactNode;
+    disabled?: boolean;
+    value: V;
+    options: ActionMenuOption<V>[];
+    onChange: (value: V) => void;
+    /**
+     * Keep the Menu in the same DOM tree as its trigger (needed when nested
+     * inside a Popover so picking a color doesn't dismiss the parent).
+     */
+    disablePortal?: boolean;
+}
+/** Internal: toolbar button that opens a single-select options menu. */
+export declare function ActionMenu<V extends string>({ label, icon, disabled, value, options, onChange, disablePortal, }: ActionMenuProps<V>): JSX.Element;

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

@@ -0,0 +1,13 @@
+import { JSX } from 'react';
+export declare const CANCEL_ACTION_LABELS: {
+    readonly cancel: "Cancel";
+};
+export interface CancelActionProps {
+    disabled?: boolean;
+    label?: string;
+    /** Keyboard-shortcut hint appended to the tooltip, e.g. `"Esc"`. */
+    shortcut?: string;
+    onCancel: () => void;
+}
+/** Discards the in-progress operation (equivalent to Escape). */
+export declare function CancelAction({ disabled, label, shortcut, onCancel, }: CancelActionProps): JSX.Element;

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

@@ -0,0 +1,44 @@
+import { JSX } from 'react';
+import { LassoDrawColor, LassoDrawColorPreset } from '../../types.js';
+/** Hex presets for `draw` colors (CARTO qualitative Pastel scheme, from Figma). */
+export declare const LASSO_DRAW_COLOR_HEX: Record<LassoDrawColorPreset, string>;
+export declare const COLOR_ACTION_LABELS: {
+    readonly tooltip: "Color";
+    readonly options: {
+        readonly yellow: "Yellow";
+        readonly orange: "Orange";
+        readonly purple: "Purple";
+        readonly pink: "Pink";
+        readonly green: "Green";
+        readonly brown: "Brown";
+        readonly black: "Black";
+        readonly white: "White";
+        readonly custom: "Custom";
+    };
+};
+/** True when `color` is a named preset (not a freeform hex). */
+export declare function isLassoDrawColorPreset(color: string): color is LassoDrawColorPreset;
+/**
+ * Canonical `#rrggbb` lowercase, or `undefined` if not a valid 3/6-digit hex.
+ */
+export declare function normalizeHex(raw: string): string | undefined;
+export interface ColorActionProps {
+    value: LassoDrawColor;
+    disabled?: boolean;
+    labels?: {
+        tooltip?: string;
+        options?: Partial<Record<LassoDrawColorPreset | 'custom', string>>;
+    };
+    onChange: (value: LassoDrawColor) => void;
+    /**
+     * Keep the color Menu inside its parent Popover (Label presentation row).
+     * @default false
+     */
+    disablePortal?: boolean;
+}
+export declare function ColorDot({ color, size, }: {
+    color: LassoDrawColor;
+    size?: number;
+}): JSX.Element;
+/** Color picker for `draw` geometries: dot of the current color + preset menu. */
+export declare function ColorAction({ value, disabled, labels, onChange, disablePortal, }: ColorActionProps): JSX.Element;

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

@@ -0,0 +1,11 @@
+import { JSX } from 'react';
+export declare const DELETE_ACTION_LABELS: {
+    readonly delete: "Delete";
+};
+export interface DeleteActionProps {
+    disabled?: boolean;
+    label?: string;
+    onDelete: () => void;
+}
+/** Destructive delete action (error color). */
+export declare function DeleteAction({ disabled, label, onDelete, }: DeleteActionProps): JSX.Element;

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

@@ -0,0 +1,11 @@
+import { JSX } from 'react';
+export declare const DUPLICATE_ACTION_LABELS: {
+    readonly duplicate: "Duplicate";
+};
+export interface DuplicateActionProps {
+    disabled?: boolean;
+    label?: string;
+    onDuplicate: () => void;
+}
+/** Duplicates the selected geometries (slightly offset copies). */
+export declare function DuplicateAction({ disabled, label, onDuplicate, }: DuplicateActionProps): JSX.Element;

package/dist/types/components/lasso-tool/toolbar/actions/edit-geometry-action.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from 'react';
+export declare const EDIT_GEOMETRY_ACTION_LABELS: {
+    readonly editGeometry: "Edit geometry";
+};
+export interface EditGeometryActionProps {
+    /** Highlight while an edit session is running. */
+    active?: boolean;
+    disabled?: boolean;
+    label?: string;
+    onEditGeometry: () => void;
+}
+/** Starts a geometry-edit session (vertices + translate) on the selection. */
+export declare function EditGeometryAction({ active, disabled, label, onEditGeometry, }: EditGeometryActionProps): JSX.Element;

package/dist/types/components/lasso-tool/toolbar/actions/edit-properties-action.d.ts

@@ -0,0 +1,60 @@
+import { JSX, RefObject } from 'react';
+/** Editable subset of full geometry properties for the KV editor. */
+export declare function getEditablePropertiesFromFull(properties: Record<string, unknown>): Record<string, unknown>;
+export declare const EDIT_PROPERTIES_ACTION_LABELS: {
+    readonly editProperties: "Edit properties";
+    readonly keyPlaceholder: "Key";
+    readonly valuePlaceholder: "Value";
+    readonly addRow: "Add property";
+    readonly removeRow: "Remove property";
+    readonly emptyKeyError: "Key is required";
+    readonly duplicateKeyError: "Duplicate key";
+    readonly systemKeyError: "Reserved key";
+};
+export interface EditPropertiesActionLabels {
+    editProperties?: string;
+    keyPlaceholder?: string;
+    valuePlaceholder?: string;
+    addRow?: string;
+    removeRow?: string;
+    emptyKeyError?: string;
+    duplicateKeyError?: string;
+    systemKeyError?: string;
+}
+export interface EditPropertiesActionProps {
+    /** Editable properties — the controller already excludes system keys. */
+    properties: Record<string, unknown>;
+    disabled?: boolean;
+    labels?: EditPropertiesActionLabels;
+    /** Commits a full replacement of the editable properties. */
+    onEditProperties: (draft: Record<string, unknown>) => void;
+    /**
+     * Element to anchor the popover to (e.g. the toolbar Paper, so it spans the
+     * full bar). Defaults to the action button itself.
+     */
+    anchorRef?: RefObject<HTMLElement | null>;
+    /**
+     * True while the mutually-exclusive Label popover is open — force-closes
+     * (discards) this one, per the "one popover at a time" rule.
+     */
+    forceClose?: boolean;
+    /** Notified on open/close, so a sibling popover can enforce mutual exclusion. */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Identity of the current selection (e.g. the selected ids, joined). A
+     * change while the popover is open always discards — by the time this is
+     * noticed, `onEditProperties` has already rebound to the new selection, so
+     * a "commit" would silently edit the wrong geometry.
+     */
+    selectionKey?: string;
+}
+/**
+ * Edit properties action: button + anchored popover (layout B) with a
+ * scrollable freeform key/value list. Map label / presentation live in
+ * LabelAction — not here.
+ *
+ * Close rules: outside click commits only a valid draft (an invalid one
+ * keeps the popover open with its errors); Escape always discards; Enter
+ * never closes it (it only moves focus or appends a row).
+ */
+export declare function EditPropertiesAction({ properties, disabled, labels, onEditProperties, anchorRef, forceClose, onOpenChange, selectionKey, }: EditPropertiesActionProps): JSX.Element;

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

@@ -0,0 +1,26 @@
+import { JSX } from 'react';
+import { LassoDrawFill } from '../../types.js';
+export declare const FILL_ACTION_LABELS: {
+    readonly tooltip: "Fill";
+    readonly options: {
+        readonly filled: "Filled";
+        readonly opacity: "Opacity";
+        readonly none: "None";
+    };
+};
+export interface FillActionProps {
+    value: LassoDrawFill;
+    disabled?: boolean;
+    /**
+     * Disables just the `none` option — set it when the stroke is already
+     * `none`, since the store refuses to make both invisible at once.
+     */
+    disableNone?: boolean;
+    labels?: {
+        tooltip?: string;
+        options?: Partial<Record<LassoDrawFill, string>>;
+    };
+    onChange: (value: LassoDrawFill) => void;
+}
+/** Fill picker for `draw` geometries: filled / opacity / none. */
+export declare function FillAction({ value, disabled, disableNone, labels, onChange, }: FillActionProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+import { JSX } from 'react';
+export declare const INTERSECT_ACTION_LABELS: {
+    readonly intersect: "Intersect geometries";
+};
+export interface IntersectActionProps {
+    disabled?: boolean;
+    label?: string;
+    onIntersect: () => void;
+}
+/**
+ * Replaces the selection with its common area. Only meaningful with 2+
+ * overlapping geometries selected.
+ */
+export declare function IntersectAction({ disabled, label, onIntersect, }: IntersectActionProps): JSX.Element;

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

@@ -0,0 +1,69 @@
+import { JSX, RefObject } from 'react';
+import { LassoDrawColor } from '../../types.js';
+export declare const LABEL_ACTION_LABELS: {
+    readonly label: "Label";
+    readonly name: "Name";
+    readonly showOnMap: "Show on map";
+    readonly bold: "Bold";
+    readonly italic: "Italic";
+};
+/** Partial map-label presentation — applied live (one undo each). */
+export interface LassoTextPresentation {
+    textVisible?: boolean;
+    textColor?: LassoDrawColor;
+    textBold?: boolean;
+    textItalic?: boolean;
+}
+export interface LabelActionProps {
+    /** Current geometry name (`label`), shown prefilled in the Name field. */
+    label: string;
+    /** Whether the map TextLayer is enabled for this geometry. */
+    textVisible?: boolean;
+    /** Effective text color (persisted or basemap default). */
+    textColor?: LassoDrawColor;
+    textBold?: boolean;
+    textItalic?: boolean;
+    /**
+     * When true, hides the "Show on map" checkbox and treats the label as
+     * always visible (Point text annotations).
+     */
+    forceTextVisible?: boolean;
+    disabled?: boolean;
+    labels?: {
+        /** Tooltip/aria-label for the Label button. */
+        label?: string;
+        /** TextField label for the name input. */
+        name?: string;
+        showOnMap?: string;
+        bold?: string;
+        italic?: string;
+    };
+    /** Commits a new name on Enter/blur/close (no-op on empty or unchanged). */
+    onRename: (label: string) => void;
+    /** Applies presentation changes live while the popover is open. */
+    onSetTextPresentation: (partial: LassoTextPresentation) => void;
+    /**
+     * Element to anchor the popover to (e.g. the toolbar Paper, so the
+     * popover spans the full bar). Defaults to the action button itself.
+     */
+    anchorRef?: RefObject<HTMLElement | null>;
+    /**
+     * True while the mutually-exclusive Edit properties popover is open —
+     * closes (commits name) this one, per the "one popover at a time" rule.
+     */
+    forceClose?: boolean;
+    /** Notified on open/close, so a sibling popover can enforce mutual exclusion. */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Identity of the current selection (e.g. the selected ids, joined). A
+     * change while the popover is open closes (discards name) it — same as
+     * any other discard.
+     */
+    selectionKey?: string;
+}
+/**
+ * Label action: button + anchored popover with Name, Show on map, and a
+ * Color + Bold/Italic row. Presentation applies live; name commits on
+ * Enter/blur/close. Escape discards an in-progress name edit.
+ */
+export declare function LabelAction({ label, textVisible, forceTextVisible, textColor, textBold, textItalic, disabled, labels, onRename, onSetTextPresentation, anchorRef, forceClose, onOpenChange, selectionKey, }: LabelActionProps): JSX.Element;

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

@@ -0,0 +1,17 @@
+import { JSX } from 'react';
+export declare const LOCK_ACTION_LABELS: {
+    readonly lock: "Lock";
+    readonly unlock: "Unlock";
+};
+export interface LockActionProps {
+    locked: boolean;
+    disabled?: boolean;
+    labels?: {
+        lock?: string;
+        unlock?: string;
+    };
+    /** Called with the opposite locked state. */
+    onToggleLock: (locked: boolean) => void;
+}
+/** Lock toggle: active tint + `aria-pressed` while the geometry is locked. */
+export declare function LockAction({ locked, disabled, labels, onToggleLock, }: LockActionProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+import { JSX } from 'react';
+export declare const REDO_ACTION_LABELS: {
+    readonly redo: "Redo";
+};
+export interface RedoActionProps {
+    /** Usually `!canRedo`. */
+    disabled?: boolean;
+    label?: string;
+    /** Keyboard-shortcut hint appended to the tooltip, e.g. `"⌘⇧Z"`. */
+    shortcut?: string;
+    onRedo: () => void;
+}
+/** Re-apply the last undone lasso modification. */
+export declare function RedoAction({ disabled, label, shortcut, onRedo, }: RedoActionProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+import { JSX } from 'react';
+export declare const SPLIT_ACTION_LABELS: {
+    readonly split: "Split geometry";
+};
+export interface SplitActionProps {
+    disabled?: boolean;
+    label?: string;
+    onSplit: () => void;
+}
+/**
+ * Splits a MultiPolygon into its parts (the inverse of the merge action on
+ * disjoint inputs). Only meaningful with a single MultiPolygon selected.
+ */
+export declare function SplitAction({ disabled, label, onSplit, }: SplitActionProps): JSX.Element;

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

@@ -0,0 +1,27 @@
+import { JSX } from 'react';
+import { LassoDrawStroke } from '../../types.js';
+export declare const STROKE_ACTION_LABELS: {
+    readonly tooltip: "Stroke";
+    readonly options: {
+        readonly thick: "Thick";
+        readonly default: "Default";
+        readonly thin: "Thin";
+        readonly none: "None";
+    };
+};
+export interface StrokeActionProps {
+    value: LassoDrawStroke;
+    disabled?: boolean;
+    /**
+     * Disables just the `none` option — set it when the fill is already
+     * `none`, since the store refuses to make both invisible at once.
+     */
+    disableNone?: boolean;
+    labels?: {
+        tooltip?: string;
+        options?: Partial<Record<LassoDrawStroke, string>>;
+    };
+    onChange: (value: LassoDrawStroke) => void;
+}
+/** Stroke-width picker for `draw` geometries: thick / default / thin / none. */
+export declare function StrokeAction({ value, disabled, disableNone, labels, onChange, }: StrokeActionProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+import { JSX } from 'react';
+export declare const SUBTRACT_ACTION_LABELS: {
+    readonly subtract: "Subtract geometries";
+};
+export interface SubtractActionProps {
+    disabled?: boolean;
+    label?: string;
+    onSubtract: () => void;
+}
+/**
+ * Subtracts every other selected geometry from the first one (a contained
+ * geometry carves a hole). Only meaningful with 2+ geometries selected.
+ */
+export declare function SubtractAction({ disabled, label, onSubtract, }: SubtractActionProps): JSX.Element;

package/dist/types/components/lasso-tool/toolbar/actions/toggle-type-action.d.ts

@@ -0,0 +1,19 @@
+import { JSX } from 'react';
+import { LassoGeometryType } from '../../types.js';
+export declare const TOGGLE_TYPE_ACTION_LABELS: {
+    readonly mask: "Switch to mask";
+    readonly draw: "Switch to drawing";
+};
+export interface ToggleTypeActionProps {
+    /** Current geometry type; the button is active/pressed when `mask`. */
+    type: LassoGeometryType;
+    disabled?: boolean;
+    labels?: {
+        mask?: string;
+        draw?: string;
+    };
+    /** Called with the opposite type. */
+    onToggleType: (type: LassoGeometryType) => void;
+}
+/** Mask/draw toggle: fixed mask glyph, active tint while the geometry masks. */
+export declare function ToggleTypeAction({ type, disabled, labels, onToggleType, }: ToggleTypeActionProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+import { JSX } from 'react';
+export declare const UNDO_ACTION_LABELS: {
+    readonly undo: "Undo";
+};
+export interface UndoActionProps {
+    /** Usually `!canUndo`. */
+    disabled?: boolean;
+    label?: string;
+    /** Keyboard-shortcut hint appended to the tooltip, e.g. `"⌘Z"`. */
+    shortcut?: string;
+    onUndo: () => void;
+}
+/** Undo the last committed lasso modification. */
+export declare function UndoAction({ disabled, label, shortcut, onUndo, }: UndoActionProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+import { JSX } from 'react';
+export declare const UNION_ACTION_LABELS: {
+    readonly union: "Merge geometries";
+};
+export interface UnionActionProps {
+    disabled?: boolean;
+    label?: string;
+    onUnion: () => void;
+}
+/**
+ * Merges the selected geometries into one: a single polygon when they overlap,
+ * a MultiPolygon otherwise. Only meaningful with 2+ geometries selected.
+ */
+export declare function UnionAction({ disabled, label, onUnion, }: UnionActionProps): JSX.Element;

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

@@ -0,0 +1,24 @@
+import { MouseEvent, ReactNode } from 'react';
+export interface LassoToolbarButtonUIProps {
+    /** Tooltip and `aria-label` of the button. */
+    label: string;
+    /** Keyboard-shortcut hint appended to the tooltip, e.g. `"⌘Z"`. */
+    shortcut?: string;
+    icon: ReactNode;
+    /** Highlights the button with the primary tint. */
+    active?: boolean;
+    /** When set, exposes `aria-pressed` so the button reads as a toggle. */
+    pressed?: boolean;
+    disabled?: boolean;
+    color?: 'error';
+    /** For triggers that open a menu (`ActionMenu`). */
+    'aria-haspopup'?: 'menu';
+    'aria-expanded'?: boolean;
+    onClick: (event: MouseEvent<HTMLButtonElement>) => void;
+}
+/**
+ * Icon button for lasso toolbars: CARTO `Tooltip`, accessible labeling and the
+ * active/pressed toggle treatment. The `span` wrapper keeps the tooltip firing
+ * while the button is disabled.
+ */
+export declare function LassoToolbarButtonUI({ label, shortcut, icon, active, pressed, disabled, color, 'aria-haspopup': ariaHasPopup, 'aria-expanded': ariaExpanded, onClick, }: LassoToolbarButtonUIProps): ReactNode;