igniteui-webcomponents 5.3.0-beta.0 → 5.3.0-beta.2

package/components/combo/types.d.ts

@@ -0,0 +1,45 @@
+import type { RenderItemFunction } from '@lit-labs/virtualizer/virtualize.js';
+import type { ReactiveControllerHost, TemplateResult } from 'lit';
+import type IgcComboComponent from './combo.js';
+export type Keys<T> = keyof T;
+export type Values<T> = T[keyof T];
+export type Item<T extends object> = T | Values<T>;
+export type ComboRecord<T extends object> = {
+    value: T;
+    header: boolean;
+    dataIndex: number;
+};
+export type ComboHost<T extends object> = ReactiveControllerHost & IgcComboComponent<T>;
+export type GroupingDirection = 'asc' | 'desc' | 'none';
+export type ComboChangeType = 'selection' | 'deselection' | 'addition';
+export type ComboRenderFunction<T extends object> = RenderItemFunction<ComboRecord<T>>;
+export type ComboValue<T> = T | Values<T>;
+export interface FilteringOptions<T extends object> {
+    filterKey: Keys<T> | undefined;
+    caseSensitive?: boolean;
+    matchDiacritics?: boolean;
+}
+export interface GroupingOptions<T extends object> {
+    groupKey?: Keys<T>;
+    valueKey?: Keys<T>;
+    displayKey?: Keys<T>;
+    direction: GroupingDirection;
+}
+export interface IgcComboChangeEventArgs<T extends object = any> {
+    newValue: ComboValue<T>[];
+    items: T[];
+    type: ComboChangeType;
+}
+export interface IgcComboComponentEventMap {
+    igcChange: CustomEvent<IgcComboChangeEventArgs>;
+    focus: FocusEvent;
+    blur: FocusEvent;
+    igcOpening: CustomEvent<void>;
+    igcOpened: CustomEvent<void>;
+    igcClosing: CustomEvent<void>;
+    igcClosed: CustomEvent<void>;
+}
+export type ComboItemTemplate<T extends object> = (props: ComboTemplateProps<T>) => TemplateResult;
+export interface ComboTemplateProps<T extends object> {
+    item: T;
+}

package/components/combo/validators.d.ts

@@ -0,0 +1,3 @@
+import type { Validator } from '../common/validators.js';
+import type IgcComboComponent from './combo.js';
+export declare const comboValidators: Validator<IgcComboComponent>[];

package/components/common/context.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'lit/directives/ref.js';
+import type IgcCarouselComponent from '../carousel/carousel.js';
+import type IgcTileManagerComponent from '../tile-manager/tile-manager.js';
+export type TileManagerContext = {
+    /** The igc-tile-manager instance. */
+    instance: IgcTileManagerComponent;
+    /** The internal CSS grid container of the igc-tile-manager. */
+    grid: Ref<HTMLElement>;
+};
+declare const carouselContext: {
+    __context__: IgcCarouselComponent;
+};
+declare const tileManagerContext: {
+    __context__: TileManagerContext;
+};
+export { carouselContext, tileManagerContext };

package/components/common/controllers/async-consumer.d.ts

@@ -0,0 +1,17 @@
+import { type Context, ContextConsumer, type ContextType } from '@lit/context';
+import type { LitElement, ReactiveController, ReactiveControllerHost } from 'lit';
+type AsyncContextOptions<T extends Context<unknown, unknown>> = {
+    context: T;
+    callback?: (value: ContextType<T>, dispose?: () => void) => void;
+    subscribe?: boolean;
+};
+export declare class AsyncContextConsumer<T extends Context<unknown, unknown>, Host extends ReactiveControllerHost & HTMLElement> implements ReactiveController {
+    protected _host: Host;
+    protected _options: AsyncContextOptions<T>;
+    protected _consumer?: ContextConsumer<T, Host>;
+    constructor(host: Host, options: AsyncContextOptions<T>);
+    get value(): ContextType<T> | undefined;
+    hostConnected(): Promise<void>;
+}
+export declare function createAsyncContext<T extends Context<unknown, unknown>, Host extends ReactiveControllerHost & LitElement>(host: Host, context: T, callback?: (value: ContextType<T>, dispose?: () => void) => void): AsyncContextConsumer<T, Host>;
+export {};

package/components/common/controllers/drag.d.ts

@@ -0,0 +1,143 @@
+import type { LitElement, ReactiveController, ReactiveControllerHost } from 'lit';
+import type { Ref } from 'lit/directives/ref.js';
+type DragEnterCallback = (target: Element) => unknown;
+type DragCallback = (parameters: DragCallbackParameters) => unknown;
+type DragCancelCallback = (state: DragState) => unknown;
+export type DragCallbackParameters = {
+    event: PointerEvent;
+    state: DragState;
+};
+type State = {
+    initial: DOMRect;
+    current: DOMRect;
+    position: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+};
+type DragState = State & {
+    ghost: HTMLElement | null;
+    element: Element | null;
+};
+type DragControllerConfiguration = {
+    /** Whether the drag feature is enabled for the current host. */
+    enabled?: boolean;
+    /**
+     * The mode of the drag operation.
+     *
+     * Deferred will create a ghost element and keep the original element
+     * at its place until the operation completes successfully.
+     */
+    mode?: 'immediate' | 'deferred';
+    /**
+     * Whether starting a drag operation should snap the dragged item's top left corner
+     * to the cursor position.
+     */
+    snapToCursor?: boolean;
+    /**
+     * Guard function invoked during the `start` callback.
+     * Returning a truthy value will stop the current drag operation.
+     */
+    skip?: (event: PointerEvent) => boolean;
+    matchTarget?: (target: Element) => boolean;
+    /**
+     *
+     */
+    trigger?: () => HTMLElement;
+    /**
+     * Contain drag operations to the scope of the passed DOM element.
+     */
+    container?: Ref<HTMLElement>;
+    /**
+     * The DOM element that will "host" the ghost drag element when the controller
+     * is set to **deferred**.
+     *
+     * @remarks
+     * In **immediate** mode, this property is ignored.
+     */
+    layer?: () => HTMLElement;
+    ghost?: () => HTMLElement;
+    /** Callback invoked at the beginning of a drag operation. */
+    start?: DragCallback;
+    /** Callback invoked while dragging the target element.  */
+    move?: DragCallback;
+    enter?: DragEnterCallback;
+    leave?: DragEnterCallback;
+    over?: DragEnterCallback;
+    /** Callback invoked during a drop operation. */
+    end?: DragCallback;
+    /** Callback invoked when a drag is cancelled */
+    cancel?: DragCancelCallback;
+};
+declare class DragController implements ReactiveController {
+    private _host;
+    private _options;
+    private _state;
+    private _matchedElement;
+    private _id;
+    private _hasPointerCapture;
+    private _ghost;
+    /** Whether `snapToCursor` is enabled for the controller. */
+    private get _hasSnapping();
+    /** Whether the current drag mode is deferred. */
+    private get _isDeferred();
+    /**
+     * The source element which will capture pointer events and initiate drag mode.
+     *
+     * @remarks
+     * By default that will be the host element itself, unless `trigger` is passed in.
+     */
+    private get _element();
+    /**
+     * The element being dragged.
+     *
+     * @remarks
+     * When in **deferred** mode this returns a reference to the drag ghost element,
+     * otherwise it is the host element.
+     */
+    private get _dragItem();
+    /**
+     * The DOM element that will "host" the ghost drag element when the controller
+     * is set to **deferred**.
+     *
+     * @remarks
+     * In **immediate** mode, this property is ignored.
+     */
+    private get _layer();
+    private get _stateParameters();
+    constructor(host: ReactiveControllerHost & LitElement, options?: DragControllerConfiguration);
+    /** Whether the drag controller is enabled. */
+    get enabled(): boolean;
+    /** Updates the drag controller configuration. */
+    set(options?: DragControllerConfiguration): void;
+    /** Stops any drag operation and cleans up state, additional event listeners and elements. */
+    dispose(): void;
+    /** @internal */
+    hostConnected(): void;
+    /** @internal */
+    hostDisconnected(): void;
+    /** @internal */
+    handleEvent(event: PointerEvent & KeyboardEvent): void;
+    private _handlePointerDown;
+    private _handlePointerMove;
+    private _handlePointerEnd;
+    private _handleCancel;
+    private _setDragCancelListener;
+    private _setInitialState;
+    private _setDragState;
+    private _updateMatcher;
+    private _updatePosition;
+    private _assignPosition;
+    private _createDragGhost;
+    private _removeGhost;
+    private _shouldSkip;
+}
+/**
+ * Adds a drag and drop controller to the given host
+ */
+export declare function addDragController(host: ReactiveControllerHost & LitElement, options?: DragControllerConfiguration): DragController;
+export {};

package/components/common/controllers/focus-ring.d.ts

@@ -0,0 +1,32 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * A controller class which determines whether a focus ring should be shown to indicate keyboard focus.
+ * Focus rings are visible only when the user is interacting with a keyboard, not with a mouse, touch, or other input methods.
+ *
+ * By default the class attaches a keyup event handler on the component host and will update its keyboard focus
+ * state based on it.
+ */
+export declare class KeyboardFocusRingController implements ReactiveController {
+    readonly host: ReactiveControllerHost & HTMLElement;
+    private readonly _host;
+    private _focused;
+    /**
+     * Gets whether the current focus state is activated through a keyboard interaction.
+     */
+    get focused(): boolean;
+    constructor(host: ReactiveControllerHost & HTMLElement);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    handleEvent(): void;
+    /**
+     * Resets the keyboard focus state.
+     *
+     * Usually called on blur of the component or when a pointer based interaction
+     * is executed.
+     */
+    reset: () => void;
+}
+/**
+ * Adds a {@link KeyboardFocusRingController} responsible for managing keyboard focus state.
+ */
+export declare function addKeyboardFocusRing(host: ReactiveControllerHost & HTMLElement): KeyboardFocusRingController;

package/components/common/controllers/fullscreen.d.ts

@@ -0,0 +1,41 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * Callback invoked when the host element is about to enter/leave fullscreen mode.
+ *
+ * The callback is passed the current fullscreen `state`.
+ * Returning a falsy value from the callback will stop the current fullscreen state change.
+ */
+type FullscreenControllerCallback = (state: boolean) => boolean;
+/** Configuration object for the fullscreen controller. */
+type FullscreenControllerConfiguration = {
+    /**
+     * Invoked when the host element is entering fullscreen mode.
+     * See the {@link FullscreenControllerCallback} for details.
+     */
+    enter?: FullscreenControllerCallback;
+    /**
+     * Invoked when the host element is leaving fullscreen mode.
+     * See the {@link FullscreenControllerCallback} for details.
+     */
+    exit?: FullscreenControllerCallback;
+};
+declare class FullscreenController implements ReactiveController {
+    private _host;
+    private _options;
+    private _fullscreen;
+    get fullscreen(): boolean;
+    constructor(host: ReactiveControllerHost & HTMLElement, options?: FullscreenControllerConfiguration);
+    /**
+     * Transitions the host element to/from fullscreen mode.
+     * This method **will invoke** enter/exit callbacks if present.
+     */
+    setState(fullscreen: boolean): void;
+    /** @internal */
+    handleEvent(): void;
+    /** @internal */
+    hostConnected(): void;
+    /** @internal */
+    hostDisconnected(): void;
+}
+export declare function addFullscreenController(host: ReactiveControllerHost & HTMLElement, options?: FullscreenControllerConfiguration): FullscreenController;
+export {};

package/components/common/controllers/gestures.d.ts

@@ -0,0 +1,76 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { Ref } from 'lit/directives/ref.js';
+/**
+ * Configuration object for a {@link GesturesController} instance.
+ */
+export interface GesturesOptions {
+    /**
+     * By default, the controller listens for pointer/touch events in the context of the host element.
+     * If you pass a `ref`, you can limit the observation to a certain DOM part of the host scope.
+     */
+    ref?: Ref<HTMLElement>;
+    /**
+     * The maximum amount of milliseconds between the start and end of a gesture combination
+     * before it is recognized as such.
+     */
+    thresholdTime?: number;
+    /**
+     * The minimum amount a "pointer" should travel in pixels, before being recognized as a
+     * gesture.
+     */
+    thresholdDistance?: number;
+    /**
+     * When enabled, the controller will skip events generated by a mouse device.
+     */
+    touchOnly?: boolean;
+}
+type GestureDirection = 'left' | 'up' | 'right' | 'down';
+type SwipeEvents = 'swipe' | 'swipe-left' | 'swipe-up' | 'swipe-right' | 'swipe-down';
+export type GestureData = {
+    direction: GestureDirection;
+    type: string;
+    xStart: number;
+    xEnd: number;
+    yStart: number;
+    yEnd: number;
+};
+export declare class SwipeEvent extends Event {
+    readonly data: GestureData;
+    readonly name: string;
+    constructor(name: string, data: GestureData, initOptions?: EventInit);
+}
+declare class GesturesController extends EventTarget implements ReactiveController {
+    private readonly _host;
+    private _ref?;
+    private _options;
+    private _pointerState;
+    protected get _element(): HTMLElement;
+    /** Get the current configuration object */
+    get options(): GesturesOptions;
+    constructor(host: ReactiveControllerHost & HTMLElement, options?: GesturesOptions);
+    /**
+     * Add an event listener for a given swipe event.
+     */
+    set(type: SwipeEvents, callback: (event: SwipeEvent) => void, options?: AddEventListenerOptions): this;
+    handleEvent(event: PointerEvent): void;
+    hostConnected(): Promise<void>;
+    hostDisconnected(): void;
+    /** Updates the configuration of the controller */
+    updateOptions(options: Omit<GesturesOptions, 'ref'>): void;
+    private _getGestureState;
+    private _setTouchActionState;
+    private _resetState;
+    private _setPointerCaptureState;
+    private _handlePointerDown;
+    private _handlePointerMove;
+    private _emit;
+    private _createEventArgs;
+    protected _recognize(): GestureDirection | false;
+    private _handleLostPointerCapture;
+}
+/**
+ * Adds a {@link GesturesController} responsible for managing gesture behaviors
+ * for the given host element.
+ */
+export declare function addGesturesController(host: ReactiveControllerHost & HTMLElement, options?: GesturesOptions): GesturesController;
+export {};

package/components/common/controllers/key-bindings.d.ts

@@ -0,0 +1,150 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { Ref } from 'lit/directives/ref.js';
+export declare const arrowLeft: "ArrowLeft";
+export declare const arrowRight: "ArrowRight";
+export declare const arrowUp: "ArrowUp";
+export declare const arrowDown: "ArrowDown";
+export declare const enterKey: "Enter";
+export declare const spaceBar: " ";
+export declare const escapeKey: "Escape";
+export declare const homeKey: "Home";
+export declare const endKey: "End";
+export declare const pageUpKey: "PageUp";
+export declare const pageDownKey: "PageDown";
+export declare const tabKey: "Tab";
+export declare const altKey: "Alt";
+export declare const ctrlKey: "Ctrl";
+export declare const metaKey: "Meta";
+export declare const shiftKey: "Shift";
+export type KeyBindingHandler = (event: KeyboardEvent) => void;
+export type KeyBindingObserverCleanup = {
+    unsubscribe: () => void;
+};
+/**
+ * Whether the current event should be ignored by the controller.
+ *
+ * @param node - The event target
+ * @param event - The event object
+ *
+ * When `true` is returned, the current event is ignored.
+ */
+export type KeyBindingSkipCallback = (node: Element, event: KeyboardEvent) => boolean;
+/**
+ * The event type which will trigger the bound handler.
+ *
+ * @remarks
+ * `keydownRepeat` is similar to `keydown` with the exception
+ * that after the handler is invoked the pressed state of the key is reset
+ * in the controller.
+ */
+export type KeyBindingTrigger = 'keydown' | 'keyup' | 'keydownRepeat';
+/**
+ * Configuration object for the controller.
+ * @ignore
+ */
+export interface KeyBindingControllerOptions {
+    /**
+     * By default, the controller listens for keypress events in the context of the host element.
+     * If you pass a `ref`, you can limit the observation to a certain DOM part of the host scope.
+     */
+    ref?: Ref;
+    /**
+     * Option to ignore key press events.
+     *
+     * If passed an array of CSS selectors, it will ignore key presses originating from elements in the event composed path
+     * that match one of the selectors.
+     * Otherwise you can pass a {@link KeyBindingSkipCallback} function.
+     *
+     * Defaults to `['input', 'textarea', 'select']`.
+     *
+     * @example
+     * ```ts
+     * {
+     *  // Skip events originating from elements with `readonly` attribute
+     *  skip: ['[readonly]']
+     * }
+     * ...
+     * {
+     * // Same as above but with a callback
+     *  skip: (node: Element) => node.hasAttribute('readonly')
+     * }
+     * ```
+     */
+    skip?: string[] | KeyBindingSkipCallback;
+    /**
+     * A set of KeyBindingOptions configuration which is applied to every handler
+     * that is added to the controller.
+     *
+     * Any additional KeyBindingOptions values passed when `set` is called
+     * will be merged with `bindingDefaults`.
+     */
+    bindingDefaults?: KeyBindingOptions;
+}
+/**
+ * Configuration object for customizing the behavior of
+ * the registered handler.
+ */
+export interface KeyBindingOptions {
+    /**
+     * The event type(s) on which the handler will be invoked.
+     *
+     * Defaults to `keydown` if not set.
+     */
+    triggers?: KeyBindingTrigger[];
+    /**
+     * Whether to call `preventDefault` on the target event before the handler is invoked.
+     */
+    preventDefault?: boolean;
+    /**
+     * Whether to call `stopPropagation` on the target event before the handler is invoked.
+     */
+    stopPropagation?: boolean;
+}
+export declare function parseKeys(keys: string | string[]): {
+    keys: string[];
+    modifiers: string[];
+};
+declare class KeyBindingController implements ReactiveController {
+    protected _host: ReactiveControllerHost & Element;
+    protected _ref?: Ref;
+    protected _observedElement?: Element;
+    protected _options?: KeyBindingControllerOptions;
+    private bindings;
+    private pressedKeys;
+    protected get _element(): Element | undefined;
+    /**
+     * Sets the controller to listen for keyboard events on an arbitrary `element` in the page context.
+     * All the configuration and event handlers are applied as well.
+     *
+     * Returns an object with an `unsubscribe` function which should be called when the observing of keyboard
+     * events on the `element` should cease.
+     */
+    observeElement(element: Element): KeyBindingObserverCleanup;
+    constructor(host: ReactiveControllerHost & Element, options?: KeyBindingControllerOptions);
+    /**
+     * Checks and executes any event modifiers that are present in the matched binding.
+     */
+    private eventModifiersMatch;
+    private bindingMatches;
+    private shouldSkip;
+    handleEvent(event: KeyboardEvent): void;
+    /**
+     * Registers a keybinding handler.
+     */
+    set(key: string | string[], handler: KeyBindingHandler, options?: KeyBindingOptions): this;
+    /**
+     * Register a handler function which is called when the target receives a key
+     * which "activates" it.
+     *
+     * In the browser context this is usually either an Enter and/or Space keypress.
+     */
+    setActivateHandler(handler: KeyBindingHandler, options?: KeyBindingOptions): this;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+/**
+ * Creates a keybinding controller and adds to it to the passed `element`
+ * with the provided `options`.
+ */
+export declare function addKeybindings(element: ReactiveControllerHost & Element, options?: KeyBindingControllerOptions): KeyBindingController;
+export {};

package/components/common/controllers/mutation-observer.d.ts

@@ -0,0 +1,74 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** @ignore */
+export interface MutationControllerConfig<T> {
+    /** The callback function to run when a mutation occurs. */
+    callback: MutationControllerCallback<T>;
+    /** The underlying mutation observer configuration parameters. */
+    config: MutationObserverInit;
+    /**
+     * The element to observe.
+     * If left out, the observer will listen on the host component itself.
+     */
+    target?: Element;
+    /**
+     * A filter configuration.
+     * See {@link MutationControllerFilter|this} for additional information.
+     */
+    filter?: MutationControllerFilter<T>;
+}
+type MutationControllerCallback<T> = (params: MutationControllerParams<T>) => unknown;
+/**
+ * Filter configuration to return elements that either match
+ * an array of selector strings or a predicate function.
+ */
+type MutationControllerFilter<T> = string[] | ((node: T) => boolean);
+type MutationDOMChange<T> = {
+    target: Element;
+    node: T;
+};
+type MutationChange<T> = {
+    /** Elements that have attribute(s) changes. */
+    attributes: T[];
+    /** Elements that have been added. */
+    added: MutationDOMChange<T>[];
+    /** Elements that have been removed. */
+    removed: MutationDOMChange<T>[];
+};
+export type MutationControllerParams<T> = {
+    /** The original mutation records from the underlying observer. */
+    records: MutationRecord[];
+    /** The aggregated changes. */
+    changes: MutationChange<T>;
+    /** The observer controller instance. */
+    observer: MutationController<T>;
+};
+declare class MutationController<T> implements ReactiveController {
+    private _host;
+    private _observer;
+    private _target;
+    private _config;
+    private _callback;
+    private _filter?;
+    constructor(host: ReactiveControllerHost & Element, options: MutationControllerConfig<T>);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private _process;
+    /**
+     * Begin receiving notifications of changes to the DOM based
+     * on the configured {@link MutationControllerConfig.target|target} and observer {@link MutationControllerConfig.config|options}.
+     */
+    observe(): void;
+    /** Stop watching for mutations. */
+    disconnect(): void;
+}
+/**
+ * Creates and attaches a mutation controller with `config` to the passed in `host`.
+ *
+ * Automatically starts/stops observing for mutation changes
+ * in the respective component connect/disconnect callbacks.
+ *
+ * The mutation observer is disconnected before invoking the passed in callback and re-attached
+ * after that in order to not loop itself in endless stream of changes.
+ */
+export declare function createMutationController<T>(host: ReactiveControllerHost & Element, config: MutationControllerConfig<T>): MutationController<T>;
+export {};

package/components/common/controllers/root-click.d.ts

@@ -0,0 +1,26 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+type RootClickControllerConfig = {
+    hideCallback?: () => void;
+    target?: HTMLElement;
+};
+interface RootClickControllerHost extends ReactiveControllerHost, HTMLElement {
+    open: boolean;
+    keepOpenOnOutsideClick?: boolean;
+    hide(): void;
+}
+export declare class RootClickController implements ReactiveController {
+    private readonly host;
+    private config?;
+    constructor(host: RootClickControllerHost, config?: RootClickControllerConfig | undefined);
+    private addEventListeners;
+    private removeEventListeners;
+    private configureListeners;
+    private shouldHide;
+    handleEvent(event: PointerEvent): void;
+    private hide;
+    update(config?: RootClickControllerConfig): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+export declare function addRootClickHandler(host: RootClickControllerHost, config?: RootClickControllerConfig): RootClickController;
+export {};

package/components/common/controllers/root-scroll.d.ts

@@ -0,0 +1,27 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+type RootScrollControllerConfig = {
+    hideCallback?: () => void;
+    resetListeners?: boolean;
+};
+type RootScrollControllerHost = ReactiveControllerHost & {
+    open: boolean;
+    hide(): void;
+    scrollStrategy?: 'scroll' | 'close' | 'block';
+};
+declare class RootScrollController implements ReactiveController {
+    private readonly host;
+    private config?;
+    private _cache;
+    constructor(host: RootScrollControllerHost, config?: RootScrollControllerConfig | undefined);
+    private configureListeners;
+    private hide;
+    private addEventListeners;
+    private removeEventListeners;
+    handleEvent(event: Event): void;
+    private _block;
+    update(config?: RootScrollControllerConfig): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+export declare function addRootScrollHandler(host: RootScrollControllerHost, config?: RootScrollControllerConfig): RootScrollController;
+export {};

package/components/common/decorators/blazorAdditionalDependencies.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Indicates additional dependencies that should be loaded by the module of a component, even if they don't appear to be dependencies.
+ * @param _additionalDependencies an alternate member name to use.
+ */
+export declare function blazorAdditionalDependencies(_additionalDependencies: string): (clazz: any) => any;

package/components/common/decorators/blazorDeepImport.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractConstructor, Constructor } from '../mixins/constructor.js';
+/**
+ * Indicates a class isn't imported at the root of the API, so needs to be referred to with a deep import in the wrappers.
+ */
+export declare function blazorDeepImport(_constructor: Constructor | AbstractConstructor): void;

package/components/common/decorators/blazorInclude.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Indicates a member should be included in the Blazor API even if non-public.
+ * @returns a function that does nothing, given that this decorator is for static analysis only.
+ */
+export declare function blazorInclude(): (_descriptor: any, _memberName: string) => any;