@trackunit/react-map 0.0.4-alpha-9d327375fc1.0

package/src/controls/Controls.d.ts

@@ -0,0 +1,15 @@
+import type { MapApi } from "../core/types";
+import type { ControlsConfig } from "./types";
+type ControlsProps = Readonly<{
+    /** The map API object from useMap */
+    api: MapApi;
+    /** Additional CSS classes for the controls container */
+    className?: string;
+    /**
+     * Custom controls configuration to override the default.
+     * If provided, this will be used instead of building from api.options.
+     */
+    controlsConfig?: ControlsConfig;
+}>;
+export declare const Controls: import("react").MemoExoticComponent<({ api, className, controlsConfig: controlsConfigProp }: ControlsProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/src/controls/annotationButtonClasses.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base CSS classes for button elements used in map annotation overlays —
+ * `AnnotationRenderer` (simple-pill button) and `ShapeAnnotationLabel` (custom pill button).
+ *
+ * Resets native button appearance while preserving font inheritance and keyboard
+ * focus accessibility. Matches the focus ring pattern in InteractiveDecoration.tsx
+ * so all interactive map overlay buttons behave consistently for keyboard users.
+ *
+ * Compose additional appearance classes on top via `twMerge`.
+ *
+ * @internal
+ */
+export declare const ANNOTATION_BUTTON_RESET_CLASSES = "appearance-none m-0 cursor-pointer border-0 font-inherit focus:outline-none focus-visible:ring-2 focus-visible:ring-offset-1";

package/src/controls/collapseControls.d.ts

@@ -0,0 +1,37 @@
+import type { CategoryKey, ControlConfig, ControlsConfig, IconName, MenuItemConfig, ResponsiveMode } from "./types";
+/** Icon + label for a single category (or the "all controls" fallback) */
+type CategoryMeta = Readonly<{
+    icon: IconName;
+    label: string;
+}>;
+/** Metadata for every category, plus the "all controls" collapsed-mode entry */
+export type CategoryMetadata = Readonly<Record<CategoryKey, CategoryMeta> & {
+    /** Metadata for the single collapsed-mode menu button */
+    allControls: CategoryMeta;
+}>;
+/**
+ * Converts a top-level `ControlConfig` into one or more `MenuItemConfig` items.
+ *
+ * Most control types pass through unchanged (they're already valid menu items).
+ * One special case:
+ * - **Menu** → flattens its items into the parent (menus cannot nest)
+ *
+ * When `section` is provided, it is set on each output item (except separators
+ * which don't support sections).
+ */
+export declare const controlToMenuItems: (control: ControlConfig, section?: string) => ReadonlyArray<MenuItemConfig>;
+/**
+ * Pure config transform that restructures `ControlsConfig` based on how much
+ * space is available.
+ *
+ * - `"full"` -- pass through unchanged
+ * - `"categorized"` -- group controls within each category into a per-category
+ *   menu (only when >1 control in that category)
+ * - `"collapsed"` -- merge all controls into a single menu with named sections
+ *
+ * This operates at the config level, before controls enter the middleware
+ * rendering pipeline. Existing renderers handle the resulting menus with no
+ * changes needed.
+ */
+export declare const collapseControls: (config: ControlsConfig, mode: ResponsiveMode, metadata: CategoryMetadata) => ControlsConfig;
+export {};

package/src/controls/defineControlStack.d.ts

@@ -0,0 +1,10 @@
+import type { ControlConfig } from "./types";
+export type ControlStackItem = ControlConfig | undefined;
+/**
+ * Builds an ordered control stack from explicit control handles.
+ *
+ * The array order is the rendered order. Optional controls can be passed as
+ * `undefined`; duplicate ids are rejected because they would produce unstable
+ * React keys and ambiguous control identity.
+ */
+export declare const defineControlStack: (controls: ReadonlyArray<ControlStackItem>) => ReadonlyArray<ControlConfig>;

package/src/controls/deriveResponsiveMode.d.ts

@@ -0,0 +1,19 @@
+import type { ResponsiveMode } from "./types";
+/**
+ * Height thresholds for bumping the responsive mode toward more collapsed.
+ * Compared against the container's **border-box** height so the measurement
+ * is independent of padding changes (which depend on availableSpace).
+ */
+export declare const HEIGHT_COLLAPSED_THRESHOLD = 230;
+export declare const HEIGHT_CATEGORIZED_THRESHOLD = 380;
+/**
+ * Height threshold for switching from "comfortable" to "constrained" available space.
+ * Compared against the container's **border-box** height.
+ */
+export declare const HEIGHT_COMFORTABLE_THRESHOLD = 380;
+/**
+ * Derive responsive mode from container breakpoints and height.
+ * Width breakpoints set the base mode; low height bumps it toward more collapsed.
+ * Narrowest first: collapsed -> categorized -> full.
+ */
+export declare const deriveResponsiveMode: (isSm: boolean, isMd: boolean, containerHeight: number) => ResponsiveMode;

package/src/controls/longitudeToGlobeIcon.d.ts

@@ -0,0 +1,3 @@
+import type { IconName } from "./types";
+/** Pick the globe icon whose projection center is closest to the given longitude. */
+export declare const longitudeToGlobeIcon: (longitude: number) => IconName;

package/src/controls/renderers/boolean/BooleanButton.d.ts

@@ -0,0 +1,16 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { BooleanControlConfig } from "../../types";
+type BooleanButtonProps = Readonly<{
+    config: BooleanControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Shared standalone renderer for boolean controls (toggle and checkbox).
+ * Both render identically as an IconButton with tooltip in standalone mode.
+ * Tooltip shows "Toggle: [label]".
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const BooleanButton: ({ config, resolved }: BooleanButtonProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/controls/renderers/boolean/MenuBooleanItem.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../../types";
+type MenuBooleanItemProps = Readonly<{
+    children: ReactNode;
+    className?: string;
+    "data-testid"?: string;
+    icon?: IconName;
+    label: string;
+}>;
+/**
+ * Shared menu layout for boolean controls (toggle and checkbox).
+ * Renders: [label] [icon] ...space... [children]
+ *
+ * The caller provides the specific input control (ToggleSwitch or Checkbox)
+ * as children.
+ *
+ * @internal
+ */
+export declare const MenuBooleanItem: ({ children, className, "data-testid": dataTestId, icon, label, }: MenuBooleanItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/boolean/MenuCheckbox.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { CheckboxControlConfig } from "../../types";
+type MenuCheckboxProps = Readonly<{
+    config: CheckboxControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a checkbox control within a menu context.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const MenuCheckbox: ({ config, resolved }: MenuCheckboxProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/boolean/MenuToggle.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { ToggleControlConfig } from "../../types";
+type MenuToggleProps = Readonly<{
+    config: ToggleControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a toggle control within a menu context.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const MenuToggle: ({ config, resolved }: MenuToggleProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/button/Button.d.ts

@@ -0,0 +1,14 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { ButtonControlConfig } from "../../types";
+type ButtonProps = Readonly<{
+    config: ButtonControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a simple icon button control (standalone mode).
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const Button: ({ config, resolved }: ButtonProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/controls/renderers/button/MenuButton.d.ts

@@ -0,0 +1,16 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { ButtonControlConfig } from "../../types";
+type MenuButtonProps = Readonly<{
+    config: ButtonControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a button control within a menu context.
+ * Layout: label on the left, icon on the right (consistent with other menu items).
+ * The entire row is clickable.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const MenuButton: ({ config, resolved }: MenuButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/custom/Custom.d.ts

@@ -0,0 +1,22 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { CustomControlConfig, Placement } from "../../types";
+type CustomProps = Readonly<{
+    config: CustomControlConfig;
+    resolved: ResolvedControlProps;
+    placement: Placement;
+}>;
+/**
+ * Renders a custom control by delegating to the user-provided `render` function.
+ *
+ * This is an **escape hatch** -- prefer built-in control types (button, toggle,
+ * stepper, select, menu) which handle compactness, placement, tooltips, and
+ * accessibility automatically.
+ *
+ * The custom render function receives the full environment context so it can
+ * adapt to compactness and placement. Unless `autoTooltip` is `"none"`,
+ * standalone placement wraps the output in `Tooltip` using `label`.
+ *
+ * @internal
+ */
+export declare const Custom: ({ config, resolved, placement }: CustomProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/controls/renderers/menu/Menu.d.ts

@@ -0,0 +1,23 @@
+import { type ComponentRef, type RefObject } from "react";
+import { type AvailableSpace, type ResolvedControlProps } from "../../renderingRules";
+import type { MenuControlConfig, MenuPresentation } from "../../types";
+type MenuProps = Readonly<{
+    availableSpace: AvailableSpace;
+    config: MenuControlConfig;
+    /** Ref to the controls overlay container, used to compute popover placement */
+    containerRef: RefObject<ComponentRef<"div"> | null>;
+    customPortalId?: string;
+    menuPresentation: MenuPresentation;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a menu control as either a popover or a modal,
+ * depending on the `menuPresentation` prop derived from container size.
+ *
+ * Delegates to `MenuPopover` or `MenuModal` so each path
+ * only runs the hooks it needs.
+ *
+ * @internal
+ */
+export declare const Menu: ({ availableSpace, config, containerRef, customPortalId, menuPresentation, resolved, }: MenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/menu/Modal.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { MenuControlConfig } from "../../types";
+type ModalProps = Readonly<{
+    config: MenuControlConfig;
+    resolved: ResolvedControlProps;
+    /** The menu content (grouped sections and items) to render inside the modal body */
+    children: ReactNode;
+}>;
+/**
+ * Renders a menu control as a modal instead of a popover.
+ * Used on narrow containers where popovers would be clipped or awkward.
+ *
+ * The trigger is the same IconButton used by the popover path.
+ * The content is rendered inside a Modal with ModalHeader (label + close)
+ * and ModalBody (scrollable menu items).
+ *
+ * @internal
+ */
+export declare const Modal: ({ config, resolved, children }: ModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/menu/SectionHeader.d.ts

@@ -0,0 +1,14 @@
+type SectionHeaderProps = Readonly<{
+    /** Section title to display */
+    title: string;
+    /** Additional CSS classes */
+    className?: string;
+}>;
+/**
+ * Renders a section header within a menu.
+ * Non-interactive, purely visual grouping element.
+ *
+ * @internal
+ */
+export declare const SectionHeader: ({ title, className }: SectionHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/menu/Separator.d.ts

@@ -0,0 +1,11 @@
+type SeparatorProps = Readonly<{
+    /** Additional CSS classes */
+    className?: string;
+}>;
+/**
+ * Renders a horizontal separator line within a menu.
+ *
+ * @internal
+ */
+export declare const Separator: ({ className }: SeparatorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/radio-group/MenuRadioGroup.d.ts

@@ -0,0 +1,15 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { RadioGroupControlConfig } from "../../types";
+type MenuRadioGroupProps = Readonly<{
+    config: RadioGroupControlConfig;
+    /** Carried for the same signature as other menu renderers; the menu radio has no use for resolved (no icon on the field). */
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a radio group within a menu context.
+ * `data-testid` (when set) is on the menu-item wrapper only — not duplicated on the inner `RadioGroupField`.
+ *
+ * @internal
+ */
+export declare const MenuRadioGroup: ({ config, resolved: _resolved }: MenuRadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/radio-group/RadioGroup.d.ts

@@ -0,0 +1,19 @@
+import { type ComponentRef, type RefObject } from "react";
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { RadioGroupControlConfig } from "../../types";
+type RadioGroupProps = Readonly<{
+    config: RadioGroupControlConfig;
+    containerRef: RefObject<ComponentRef<"div"> | null>;
+    customPortalId?: string;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Standalone radio group: icon button opens a popover (`MoreMenu`).
+ * Panel styling matches the menu popover card look: bordered white surface with
+ * `rounded-lg border border-neutral-300 bg-white px-3 py-2 shadow` (aligned with menu content styling).
+ * The same `RadioGroupField` tree is used as {@link MenuRadioGroup} in a menu list.
+ *
+ * @internal
+ */
+export declare const RadioGroup: ({ config, containerRef, customPortalId, resolved }: RadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/radio-group/RadioGroupField.d.ts

@@ -0,0 +1,17 @@
+import type { ReactElement } from "react";
+import type { RadioGroupControlConfig } from "../../types";
+type RadioGroupFieldProps = Readonly<{
+    config: Pick<RadioGroupControlConfig, "className" | "id" | "onChange" | "options" | "value"> & {
+        /** Omitted in menu context so the menu-item wrapper keeps a single `data-testid`. */
+        "data-testid"?: string;
+        /** Passed through to the design-system `RadioGroup` field label (optional at the field layer). */
+        label?: string;
+    };
+}>;
+/**
+ * Shared RadioGroup + RadioItem tree for menu and standalone placements.
+ *
+ * @internal
+ */
+export declare const RadioGroupField: ({ config }: RadioGroupFieldProps) => ReactElement;
+export {};

package/src/controls/renderers/search/MenuSearch.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { SearchControlConfig } from "../../types";
+type MenuSearchProps = Readonly<{
+    config: SearchControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a search control within a menu context.
+ * Uses FormGroup to match label styling with SelectField and other form components.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const MenuSearch: ({ config, resolved: _resolved }: MenuSearchProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/search/Search.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { SearchControlConfig } from "../../types";
+type SearchProps = Readonly<{
+    config: SearchControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a search control for search/filter.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const Search: ({ config, resolved }: SearchProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/select/MenuSelect.d.ts

@@ -0,0 +1,15 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { SelectControlConfig } from "../../types";
+type MenuSelectProps = Readonly<{
+    config: SelectControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a select control within a menu context.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ * `data-testid` (when set) is on the menu-item wrapper only — not duplicated on the inner `SelectField`.
+ *
+ * @internal
+ */
+export declare const MenuSelect: ({ config, resolved: _resolved }: MenuSelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/select/Select.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { SelectControlConfig } from "../../types";
+type SelectProps = Readonly<{
+    config: SelectControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a select dropdown control.
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const Select: ({ config, resolved }: SelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/stepper/MenuStepper.d.ts

@@ -0,0 +1,17 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { StepperControlConfig } from "../../types";
+type MenuStepperProps = Readonly<{
+    config: StepperControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders a stepper control within a menu context.
+ * Shows label on the left and horizontal decrement/increment buttons on the right.
+ * Always uses Minus/Plus icons with translated "Decrease"/"Increase" labels.
+ *
+ * Layout: [Label]  ...space...  [-] [+]
+ *
+ * @internal
+ */
+export declare const MenuStepper: ({ config, resolved }: MenuStepperProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/stepper/Stepper.d.ts

@@ -0,0 +1,18 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { StepperControlConfig } from "../../types";
+type StepperProps = Readonly<{
+    config: StepperControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Renders two connected buttons for increment/decrement actions.
+ * Always uses Plus/Minus icons with translated "Increase"/"Decrease" labels.
+ * Tooltip shows "label, Increase" or "label, Decrease" depending on which
+ * button is hovered, falling back to just "label".
+ *
+ * Purely presentational -- all rendering decisions come from resolved props.
+ *
+ * @internal
+ */
+export declare const Stepper: ({ config, resolved }: StepperProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/toggle-group/MenuToggleGroup.d.ts

@@ -0,0 +1,17 @@
+import { type ResolvedControlProps } from "../../renderingRules";
+import type { ToggleGroupControlConfig } from "../../types";
+type MenuToggleGroupProps = Readonly<{
+    config: ToggleGroupControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Toggle group within a menu — text and icons (not icon-only). Segment `size` comes from resolved props
+ * (same sizing rules as other menu controls via {@link resolveControl}).
+ * The wrapper exposes `role="group"` and `aria-label={config.label}` so the segment row has an accessible name
+ * (there is no separate visible field label like {@link MenuRadioGroup}).
+ * `data-testid` (when set) is on the menu-item wrapper only — not duplicated on the inner `ToggleGroup`.
+ *
+ * @internal
+ */
+export declare const MenuToggleGroup: ({ config, resolved }: MenuToggleGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/toggle-group/ToggleGroup.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedControlProps } from "../../renderingRules";
+import type { ToggleGroupControlConfig } from "../../types";
+type ToggleGroupProps = Readonly<{
+    config: ToggleGroupControlConfig;
+    resolved: ResolvedControlProps;
+}>;
+/**
+ * Standalone segmented toggle group (design-system `ToggleGroup`).
+ * Uses icon-only segments with tooltips; the group is named via `config.label` on the wrapper (`aria-label`).
+ * Border contrast uses a wrapper `::after` (inset ring above the DS fill — same idea as a trailing overlay, without an extra DOM node).
+ *
+ * @internal
+ */
+export declare const ToggleGroup: ({ config, resolved }: ToggleGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/controls/renderers/toggle-group/ToggleGroupField.d.ts

@@ -0,0 +1,19 @@
+import { ToggleGroup as ToggleGroupPrimitive } from "@trackunit/react-components";
+import type { ComponentProps, ReactElement } from "react";
+import type { ToggleGroupControlConfig } from "../../types";
+type ToggleGroupFieldProps = Readonly<{
+    config: Pick<ToggleGroupControlConfig, "disabled" | "onChange" | "options" | "value"> & {
+        className?: string;
+        /** Omitted when the outer wrapper owns `data-testid` (e.g. menu row). */
+        "data-testid"?: string;
+    };
+    isIconOnly: boolean;
+    size: ComponentProps<typeof ToggleGroupPrimitive>["size"];
+}>;
+/**
+ * Shared design-system `ToggleGroup` wiring for standalone and menu placements.
+ *
+ * @internal
+ */
+export declare const ToggleGroupField: ({ config, isIconOnly, size }: ToggleGroupFieldProps) => ReactElement;
+export {};

package/src/controls/renderingRules.d.ts

@@ -0,0 +1,26 @@
+import type { AvailableSpace, Compactness, ControlConfig, MenuItemConfig, Placement, RenderContext, ResolvedControlProps, ResolvedControlPropsBase } from "./types";
+export type { AvailableSpace, Compactness, Placement, RenderContext, ResolvedControlProps, ResolvedControlPropsBase };
+/** Shared padding for interactive menu items (button, toggle, stepper, select, radioGroup). */
+export declare const cvaControlMenuItemBase: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/** Context available to all middleware and resolvers */
+export type MiddlewareContext = Readonly<{
+    renderContext: RenderContext;
+    config: ControlConfig | MenuItemConfig;
+}>;
+/**
+ * A middleware function: receives current state, returns modified state.
+ *
+ * Exported for advanced use cases such as providing a custom middleware
+ * stack to `resolveControl`. Most consumers should not need this.
+ */
+export type ControlMiddleware = (state: ResolvedControlPropsBase, ctx: MiddlewareContext) => ResolvedControlPropsBase;
+/**
+ * Runs the full pipeline: initial state -> middleware -> type resolver.
+ * Pure function, no side effects, easily testable.
+ *
+ * Inspired by Floating UI's middleware pattern:
+ * - Cross-cutting middleware (sizing) handles concerns for all control types
+ * - Type-specific resolvers handle logic unique to each control type
+ * - Type resolvers run after middleware and can override any field
+ */
+export declare const resolveControl: (config: ControlConfig | MenuItemConfig, renderContext: RenderContext, middleware?: ReadonlyArray<ControlMiddleware>) => ResolvedControlProps;