@pg-labs-incubator/cobweb 0.0.0-stage → 0.0.1

package/target/tsc/input/date-time.d.ts

@@ -0,0 +1,171 @@
+import type { JSX } from "solid-js";
+import type { DomComponent } from "..";
+import type { InputVariant } from "./base";
+import type { PairedInputChangeHandler, PairedInputProps } from "./paired-input";
+import type { TextFieldProps } from "./text-field";
+import { PairedInputController } from "./paired-input";
+import { TextField } from "./text-field";
+import "./date-range-input.css";
+/**
+ * {@link DateInput} component properties.
+ */
+export type DateInputProps = Omit<TextFieldProps, "revealPassword" | "secure" | "type"> & {
+    /**
+     * Native input type, which is always `date`.
+     */
+    type?: never;
+};
+/**
+ * {@link TimeInput} component properties.
+ */
+export type TimeInputProps = Omit<TextFieldProps, "revealPassword" | "secure" | "type"> & {
+    /**
+     * Native input type, which is always `time`.
+     */
+    type?: never;
+};
+/**
+ * Callback invoked after either date of a {@link DateRangeInput} changes.
+ */
+export type DateRangeChangeHandler = PairedInputChangeHandler<string>;
+/**
+ * {@link DateRangeInput} component properties.
+ *
+ * Values are ISO dates (`YYYY-MM-DD`); an empty string is an unset date.
+ */
+export type DateRangeInputProps = PairedInputProps<string> & {
+    /**
+     * Container variant.
+     *
+     * @defaultValue `"filled"`
+     */
+    variant?: InputVariant | undefined;
+    /**
+     * Earliest selectable ISO date of both inputs.
+     */
+    min?: string | undefined;
+    /**
+     * Latest selectable ISO date of both inputs.
+     */
+    max?: string | undefined;
+    /**
+     * Alias for {@link PairedInputProps.onValueChange}, invoked after it.
+     */
+    onDateRangeChange?: DateRangeChangeHandler | undefined;
+};
+/**
+ * Material 3 text field editing a date with a native `date` input.
+ *
+ * The browser supplies the date format, editing and, where available, its date chooser. Use a
+ * {@link ./picker-dialog#PickerDialog | picker dialog} with a
+ * {@link ./date-picker#DatePicker | date picker} for the Material calendar. All other properties,
+ * states and styles are those of the {@link ./text-field#TextField | text field}.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ */
+export declare function DateInput(props: DateInputProps & Pick<Parameters<typeof TextField>[0], "controllerRef">): JSX.Element;
+/**
+ * Material 3 text field editing a time with a native `time` input.
+ *
+ * The browser supplies the time format and editing. Use a
+ * {@link ./picker-dialog#PickerDialog | picker dialog} with a
+ * {@link ./time-picker#TimePicker | time picker} for the Material clock. All other properties,
+ * states and styles are those of the {@link ./text-field#TextField | text field}.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ */
+export declare function TimeInput(props: TimeInputProps & Pick<Parameters<typeof TextField>[0], "controllerRef">): JSX.Element;
+/**
+ * Client controller of a {@link DateRangeInput}.
+ *
+ * The start input is the function element. Pair semantics, labels, form participation and
+ * validity are shared with the range slider through {@link PairedInputController}; this
+ * controller adds the date bounds, the native read-only state and the container variant.
+ */
+export declare class DateRangeInputController extends PairedInputController<DateRangeInputProps, string> {
+    /**
+     * Construct a new `DateRangeInputController`.
+     *
+     * @param props - component properties
+     */
+    constructor(props: DateRangeInputProps);
+    /**
+     * Clamp a date to the bounds; an absent date is unset.
+     *
+     * @param value - resolved date
+     * @returns clamped ISO date, or an empty string
+     */
+    protected normalize(value: string | undefined): string;
+    /**
+     * Apply changed date bounds to both inputs.
+     *
+     * @param start - start input
+     * @param end - end input
+     * @returns `true` if, and only if, a bound changed
+     */
+    protected applyConstraints(start: HTMLInputElement, end: HTMLInputElement): boolean;
+    /**
+     * Apply the native read-only state to both date inputs.
+     *
+     * @param start - start input
+     * @param end - end input
+     * @param readOnly - the component is read-only
+     */
+    protected applyReadOnly(start: HTMLInputElement, end: HTMLInputElement, readOnly: boolean): void;
+    /**
+     * Value callbacks in invocation order.
+     *
+     * @returns `onValueChange`, `onDateRangeChange` and `onChange`
+     */
+    protected changeCallbacks(): readonly (DateRangeChangeHandler | undefined)[];
+    /**
+     * Apply local properties to component state and styling.
+     *
+     * @see {@link PairedInputController.applyComponentProps}
+     */
+    protected applyComponentProps(): void;
+    /**
+     * Render the component's element tree.
+     *
+     * Slots are inserted reactively right after their containers are created, in the order of
+     * the server renderer; all other state is applied by
+     * {@link DateRangeInputController.applyComponentProps}.
+     *
+     * @param children - nested component children, possibly an accessor
+     * @param funcRef - callback receiving the native function element
+     * @returns rendered component elements
+     * @see {@link ../dom/client#DomController.render}
+     */
+    protected render(children: JSX.Element, funcRef?: (elem: HTMLInputElement) => void): JSX.Element;
+}
+/**
+ * Material 3 text field editing a date range with two native `date` inputs.
+ *
+ * The browser supplies the date format, editing and, where available, its date chooser; the
+ * dates never cross. Use a {@link ./picker-dialog#PickerDialog | picker dialog} with a
+ * {@link ./date-picker#DateRangePicker | date range picker} for the Material calendar.
+ *
+ * # States
+ *
+ * `disabled`, `readOnly`, `required` and validity apply to both inputs. Both dates serialize in
+ * start, end order under `name`, or under `startName` and `endName`.
+ *
+ * # Design
+ *
+ * Date range input design is controlled through the
+ * [`cw-DateRangeInput`](./date-range-input.yaml) component design attribute, with the filled
+ * defaults and an `outlined` theme. The root receives `cw-DateRangeInput-disabled`,
+ * `cw-DateRangeInput-readOnly` and `cw-DateRangeInput-error`.
+ *
+ * # Elements
+ *
+ * The root `<fieldset>` is labelled by its `<legend>`; the inputs are labelled "Start date" and
+ * "End date" unless {@link PairedInputProps.startLabel} and {@link PairedInputProps.endLabel} are
+ * supplied, and are described by the supporting text.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ */
+export declare const DateRangeInput: DomComponent<DateRangeInputProps>;

package/target/tsc/input/index.css.d.ts

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MPL-2.0
+
+export {};

package/target/tsc/input/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Material 3 input controls.
+ *
+ * Input controls retain native HTML semantics and form behavior. Text fields, selects and
+ * autocomplete fields wrap native inputs and selects; date and time inputs use browser pickers;
+ * DatePicker, DateRangePicker, and TimePicker provide Material calendar and clock views. Range
+ * controls keep native keyboard and pointer interaction for each thumb.
+ *
+ * @packageDocumentation
+ */
+export type { AutocompleteProps } from "./autocomplete";
+export type { InputFieldSlots, InputOrientation, InputSlot, InputValueChangeHandler, InputVariant } from "./base";
+export type { DatePickerBaseProps, DatePickerLabels, DatePickerProps, DatePickerRange, DateRangePickerProps } from "./date-picker";
+export type { DateInputProps, DateRangeChangeHandler, DateRangeInputProps, TimeInputProps } from "./date-time";
+export type { PickerDialogProps } from "./picker-dialog";
+export type { SelectChangeHandler, SelectOption, SelectOptionGroup, SelectProps } from "./select";
+export type { RangeSliderChangeHandler, RangeSliderProps, RangeValue, SliderChangeHandler, SliderProps, SliderShape, SliderSize, SliderValueFormatter } from "./slider";
+export type { TextFieldChangeHandler, TextFieldProps, TextFieldType } from "./text-field";
+export type { TimePickerLabels, TimePickerProps } from "./time-picker";
+export { Autocomplete, AutocompleteController } from "./autocomplete";
+export { DatePicker, DateRangePicker } from "./date-picker";
+export { DateInput, DateRangeInput, DateRangeInputController, TimeInput } from "./date-time";
+export { PickerDialog } from "./picker-dialog";
+export { ExposedDropdownMenu, Select, SelectController } from "./select";
+export { RangeSlider, RangeSliderController, Slider, SliderController } from "./slider";
+export { FilledTextField, OutlinedTextField, PasswordField, SecureField, TextField, TextFieldController } from "./text-field";
+export { TimePicker } from "./time-picker";

package/target/tsc/input/paired-input.d.ts

@@ -0,0 +1,435 @@
+import type { Accessor, JSX } from "solid-js";
+import type { DomProps, FunctionElement, PickLocalDomProps } from "..";
+import type { InputFieldSlots, InputValueChangeHandler } from "./base";
+import { DomController } from "../dom/client";
+/**
+ * Ordered start and end values edited by two native inputs.
+ *
+ * @typeParam T - value of each native input
+ */
+export type InputPair<T> = readonly [start: T, end: T];
+/**
+ * Callback invoked after either input of a paired input is edited.
+ *
+ * @typeParam T - value of each native input
+ */
+export type PairedInputChangeHandler<T> = InputValueChangeHandler<InputPair<T>>;
+/**
+ * Properties shared by components that edit a range with two native inputs.
+ *
+ * The first input is the component's function element and receives `attr:` attributes, element
+ * properties and event handlers. The second input mirrors the native form owner (`attr:form`),
+ * validity, description and constraints of the first.
+ *
+ * @typeParam T - value of each native input
+ */
+export type PairedInputProps<T> = DomProps<HTMLInputElement, Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "disabled" | "max" | "min" | "name" | "required" | "type" | "value">> & InputFieldSlots & {
+    /**
+     * Current controlled start and end values.
+     *
+     * Supplying this property, including `undefined`, controls both endpoints from construction.
+     * Update it from {@link PairedInputProps.onValueChange} to accept an edit.
+     */
+    value?: InputPair<T> | undefined;
+    /**
+     * Initial start and end values of an uncontrolled range.
+     */
+    defaultValue?: InputPair<T> | undefined;
+    /**
+     * Current controlled start value.
+     *
+     * Supplying this property, including `undefined`, controls the start endpoint from
+     * construction while the end endpoint may remain uncontrolled.
+     */
+    startValue?: T | undefined;
+    /**
+     * Current controlled end value.
+     *
+     * Supplying this property, including `undefined`, controls the end endpoint from construction
+     * while the start endpoint may remain uncontrolled.
+     */
+    endValue?: T | undefined;
+    /**
+     * Initial uncontrolled start value, used when {@link PairedInputProps.defaultValue} is absent.
+     */
+    defaultStartValue?: T | undefined;
+    /**
+     * Initial uncontrolled end value, used when {@link PairedInputProps.defaultValue} is absent.
+     */
+    defaultEndValue?: T | undefined;
+    /**
+     * Accessible label of the start input.
+     *
+     * An authored `attr:aria-label` takes precedence on the start input.
+     */
+    startLabel?: string | undefined;
+    /**
+     * Accessible label of the end input.
+     */
+    endLabel?: string | undefined;
+    /**
+     * Disable both native inputs, their interaction and their form participation.
+     *
+     * @defaultValue `false`
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Keep both values in forms while preventing edits.
+     *
+     * @defaultValue `false`
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * Require both values at form submission.
+     *
+     * @defaultValue `false`
+     */
+    required?: boolean | undefined;
+    /**
+     * Form name shared by both inputs, which then serialize two entries in start, end order.
+     */
+    name?: string | undefined;
+    /**
+     * Id of the start input; `attr:id` is used when this is absent.
+     */
+    id?: string | undefined;
+    /**
+     * Form name of the start input, overriding {@link PairedInputProps.name}.
+     */
+    startName?: string | undefined;
+    /**
+     * Form name of the end input, overriding {@link PairedInputProps.name}.
+     */
+    endName?: string | undefined;
+    /**
+     * Id of the start input, overriding {@link PairedInputProps.id}.
+     */
+    startId?: string | undefined;
+    /**
+     * Id of the end input.
+     */
+    endId?: string | undefined;
+    /**
+     * Mark both inputs invalid without an error slot.
+     *
+     * @defaultValue `false`
+     */
+    invalid?: boolean | undefined;
+    /**
+     * Notify the parent after either input is edited.
+     *
+     * Edits never cross: an edited start value stops at the end value and vice versa. Aliases
+     * that refer to the same function run once. Controlled values are reasserted after the
+     * callbacks, so update the controlling property to accept an edit. Use `event:change` to
+     * observe committed edits.
+     *
+     * @param value - edited start and end values
+     * @param event - originating `input` event
+     */
+    onValueChange?: PairedInputChangeHandler<T> | undefined;
+    /**
+     * Alias for {@link PairedInputProps.onValueChange}.
+     */
+    onChange?: PairedInputChangeHandler<T> | undefined;
+};
+/**
+ * Value semantics of the native inputs managed by a {@link PairedInputController}.
+ *
+ * @typeParam T - value of each native input
+ */
+export interface PairedInputType<T> {
+    /**
+     * Read the value of a native input.
+     *
+     * @param input - native input
+     * @returns value of `input`
+     */
+    parse(input: HTMLInputElement): T;
+    /**
+     * Order two values.
+     *
+     * @param a - first value
+     * @param b - second value
+     * @returns a negative number, zero or a positive number when `a` precedes, equals or follows
+     * `b`, respectively; `undefined` when either value is unset and the values are unordered
+     */
+    compare(a: T, b: T): number | undefined;
+}
+/**
+ * Keys of the start and end aliases accepted by a paired input component.
+ *
+ * @typeParam P - component properties type
+ */
+export interface PairedInputAliases<P> {
+    /**
+     * Properties controlling the start value, in precedence order after `value`.
+     */
+    readonly start: readonly (keyof P & string)[];
+    /**
+     * Properties controlling the end value, in precedence order after `value`.
+     */
+    readonly end: readonly (keyof P & string)[];
+}
+/**
+ * Supporting content of a field, resolved once per change of its slots.
+ */
+export interface SupportingContent {
+    /**
+     * The field shows an error: an error slot supplies the content, or `error` is `true`.
+     */
+    readonly error: boolean;
+    /**
+     * Displayed error, supporting or helper content, or `undefined` when no slot is supplied.
+     */
+    readonly content: JSX.Element | undefined;
+}
+/**
+ * Server element properties of a field, split between its container and native input.
+ */
+export interface FieldPropsSplit {
+    /**
+     * Styling properties of the container: `class`, `classList` and `style`.
+     */
+    readonly container: Record<string, unknown>;
+    /**
+     * Every other element property, including `attr:` attributes, of the native input.
+     */
+    readonly input: Record<string, unknown>;
+}
+/**
+ * Validity and description changes implied by new supporting content.
+ */
+export interface SupportingChanges {
+    /**
+     * New error state, or `undefined` while it is unchanged.
+     */
+    readonly error: boolean | undefined;
+    /**
+     * Whether supporting content now describes the field, or `undefined` while it is unchanged.
+     */
+    readonly described: boolean | undefined;
+}
+/**
+ * Native attributes of both inputs of a server-rendered paired input.
+ */
+export interface PairedInputAttributes {
+    /**
+     * Attributes of the start input, including the component's element properties.
+     */
+    readonly start: Record<string, unknown>;
+    /**
+     * Attributes of the end input.
+     */
+    readonly end: Record<string, unknown>;
+}
+/**
+ * Supporting content of a field before its slots are resolved.
+ */
+export declare const NO_SUPPORTING_CONTENT: SupportingContent;
+/**
+ * Resolve the supporting content of a field on the client.
+ *
+ * Each slot is read once per change, in the order the server renderer reads them through
+ * {@link ./base#supportingSlot} (`errorText`, `error`, `supportingText`, `helperText`). Create
+ * this right after the element receiving the content, so slot elements are created in the order
+ * hydration expects, and read the error state from it rather than from the slot properties.
+ *
+ * An `error` of `true` marks the field invalid without text, as the server renderer tests through
+ * {@link ./base#hasInputError}; the supporting text then remains displayed.
+ *
+ * @param props - field properties
+ * @returns memoized supporting content
+ */
+export declare function createSupportingContent(props: InputFieldSlots): Accessor<SupportingContent>;
+/**
+ * Compare supporting contents of a field.
+ *
+ * @param prev - previously applied content, or `undefined` before the first application
+ * @param next - current content
+ * @param invalid - the field is marked invalid without an error slot
+ * @param invalidChanged - `invalid` changed since the previous application
+ * @returns validity and description changes
+ */
+export declare function supportingChangesOf(prev: SupportingContent | undefined, next: SupportingContent, invalid: boolean, invalidChanged: boolean): SupportingChanges;
+/**
+ * Split server element properties of a field between its container and native input.
+ *
+ * Unlike destructuring, this never reads `children`, so the renderer can read the children
+ * where they are nested, after creating their parent element.
+ *
+ * @param elemProps - lazily evaluated server element properties
+ * @returns container styling properties and native input properties
+ */
+export declare function splitFieldProps(elemProps: object): FieldPropsSplit;
+/**
+ * Resolve the start and end values of a paired input from its properties.
+ *
+ * `value` takes precedence over the endpoint aliases, which take precedence over the initial
+ * values when `initial` is `true`. An absent endpoint uses `fallback`. A crossing pair keeps a
+ * controlled endpoint fixed and moves the uncontrolled endpoint onto it; when both or neither
+ * endpoint is controlled, the values are swapped.
+ *
+ * @typeParam T - value of each native input
+ * @typeParam P - component properties type
+ * @param props - component properties
+ * @param aliases - endpoint alias keys
+ * @param initial - `true` to fall back to the initial values of uncontrolled endpoints
+ * @param fallback - values of uncontrolled endpoints without an initial value
+ * @param normalize - clamp a resolved value, or replace an unset value, for endpoint `index`
+ * @param compare - order two normalized values
+ * @returns normalized, ordered pair
+ */
+export declare function resolveInputPair<T, P extends PairedInputProps<T>>(props: P, aliases: PairedInputAliases<P>, initial: boolean, fallback: InputPair<T | undefined>, normalize: (value: T | undefined, index: 0 | 1) => T, compare: PairedInputType<T>["compare"]): InputPair<T>;
+/**
+ * Compute the server-rendered attributes of both inputs of a paired input.
+ *
+ * Authored `aria-label`, `aria-describedby`, `aria-invalid` and `aria-readonly` attributes apply
+ * to the start input only, matching the client controller. Unset boolean attributes are
+ * `undefined`, so spreading them renders no attribute. This reads the supporting slots, so call it
+ * after rendering the supporting text element.
+ *
+ * @typeParam T - value of each native input
+ * @param elementProps - element properties of the start input, including `attr:` attributes
+ * @param localProps - component properties
+ * @param labels - default accessible labels of the start and end inputs
+ * @param supportingId - id of the supporting text element
+ * @returns attributes of the start and end inputs
+ */
+export declare function pairedInputAttributes<T>(elementProps: Record<string, unknown>, localProps: PickLocalDomProps<PairedInputProps<T>>, labels: InputPair<string>, supportingId: string): PairedInputAttributes;
+/**
+ * Client controller of a component that edits a range with two native inputs.
+ *
+ * The start input is the function element; the end input is registered with
+ * {@link PairedInputController.setEndInput} from the subclass's `render()`. This controller keeps
+ * both inputs synchronized with the shared properties, prevents edits from crossing, invokes the
+ * value callbacks, reasserts controlled values and restores both inputs after a native form reset.
+ * Subclasses apply their constraints and visual state through the protected hooks.
+ *
+ * | Property                                   | Start input           | End input              |
+ * | ------------------------------------------ | --------------------- | ---------------------- |
+ * | `startLabel` / `endLabel`                  | `aria-label`          | `aria-label`           |
+ * | `startName`, `endName`, `name`             | `name`                | `name`                 |
+ * | `startId`, `id`, `attr:id` / `endId`       | `id`                  | `id`                   |
+ * | `attr:form`                                | `form`                | `form` (mirrored)      |
+ * | `disabled`, `required`                     | native property       | native property        |
+ * | `readOnly`                                 | `aria-readonly`       | `aria-readonly`        |
+ * | `invalid`, `error`, `errorText`            | `aria-invalid`        | `aria-invalid`         |
+ * | supporting text                            | `aria-describedby`    | `aria-describedby`     |
+ *
+ * Authored `attr:aria-label`, `attr:aria-describedby`, `attr:aria-invalid` and
+ * `attr:aria-readonly` attributes take precedence on the start input.
+ *
+ * @typeParam P - component properties type
+ * @typeParam T - value of each native input
+ */
+export declare abstract class PairedInputController<P extends PairedInputProps<T>, T> extends DomController<P> {
+    #private;
+    /**
+     * Construct a new `PairedInputController`.
+     *
+     * @param props - component properties
+     * @param className - public CSS class of the component
+     * @param labels - default accessible labels of the start and end inputs
+     * @param aliases - endpoint alias keys
+     * @param type - value semantics of the native inputs
+     * @param pair - pair applied before the inputs are rendered
+     */
+    constructor(props: P, className: string, labels: InputPair<string>, aliases: PairedInputAliases<P>, type: PairedInputType<T>, pair: InputPair<T>);
+    /**
+     * Current start and end values of the native inputs.
+     *
+     * @remarks
+     * This is **not** reactive.
+     */
+    get values(): InputPair<T>;
+    /**
+     * Id of the element describing both inputs.
+     */
+    protected get supportingId(): string;
+    /**
+     * End input, or `null` before it is rendered.
+     */
+    protected get endInput(): HTMLInputElement | null;
+    /**
+     * Register the rendered end input.
+     *
+     * @param input - end input
+     */
+    protected setEndInput(input: HTMLInputElement): void;
+    /**
+     * Resolve the supporting content and insert it into the supporting text element.
+     *
+     * Subclasses invoke this from `render()` right after creating `element`, where the server
+     * renderer reads the supporting slots.
+     *
+     * @param element - supporting text element
+     */
+    protected insertSupporting(element: HTMLElement): void;
+    /**
+     * Resolve a value of endpoint `index`, clamping it to the component's bounds.
+     *
+     * @param value - resolved value, or `undefined` when no property supplies one
+     * @param index - `0` for the start endpoint, `1` for the end endpoint
+     * @returns normalized value
+     */
+    protected abstract normalize(value: T | undefined, index: 0 | 1): T;
+    /**
+     * Apply changed constraint properties, such as bounds and steps, to both inputs.
+     *
+     * This is invoked in the tracking context of `applyComponentProps()` *before* values are
+     * applied, so native value sanitization uses the new constraints.
+     *
+     * @param start - start input
+     * @param end - end input
+     * @returns `true` if, and only if, a constraint changed and values must be normalized again
+     */
+    protected abstract applyConstraints(start: HTMLInputElement, end: HTMLInputElement): boolean;
+    /**
+     * Value callbacks invoked after an edit, in invocation order.
+     *
+     * @returns callbacks, possibly containing aliases of the same function
+     */
+    protected abstract changeCallbacks(): readonly (PairedInputChangeHandler<T> | undefined)[];
+    /**
+     * Handle a pair applied to both native inputs.
+     *
+     * Subclasses update their visual and accessible state here.
+     *
+     * @param pair - native start and end values
+     */
+    protected onPairApplied(pair: InputPair<T>): void;
+    /**
+     * Apply the read-only state to the native inputs.
+     *
+     * Inputs whose type supports the native `readonly` attribute set it here; read-only edits are
+     * reverted either way.
+     *
+     * @param start - start input
+     * @param end - end input
+     * @param readOnly - the component is read-only
+     */
+    protected applyReadOnly(start: HTMLInputElement, end: HTMLInputElement, readOnly: boolean): void;
+    /**
+     * Apply a pair to both native inputs.
+     *
+     * @param pair - start and end values
+     */
+    protected applyPair(pair: InputPair<T>): void;
+    /**
+     * Apply local properties to component state and styling.
+     *
+     * Subclasses must invoke this before applying their own properties.
+     *
+     * @see {@link ../dom/client#DomController.applyComponentProps}
+     */
+    protected applyComponentProps(): void;
+    /**
+     * Handle function element replacement before the controller reference is updated.
+     *
+     * The function-element getter still exposes the previous element during this hook.
+     *
+     * @param curr - new function element, or `null` when absent
+     * @see {@link ../dom/client#DomController.onFunctionElementChanged}
+     */
+    protected onFunctionElementChanged(curr: FunctionElement<P> | null): void;
+}

package/target/tsc/input/picker-dialog.css.d.ts

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MPL-2.0
+
+export {};