swing-ui 0.1.25 → 1.0.3

package/types/classes/Arc.d.ts

@@ -0,0 +1,111 @@
+/**
+ * An `Arc` shape that extends the {@link Shape} class.
+ *
+ * An Arc is a portion of a circle defined by its center coordinates, width (horizontal diameter), height (vertical diameter), starting angle, and extent (the angular span of the arc) in degrees.
+ *
+ * @class
+ * @global
+ * @see Shape
+ */
+export class Arc extends Shape {
+    /**
+     * Enum for arc drawing types: Pie and Chord.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} Chord - Draws the arc as a straight chord between the start and end points.
+     * @property {number} Pie - Draws the arc as a pie shape (arc connected to the center).
+     * @example
+     * Arc.Type.Pie
+     */
+    static readonly Type: Readonly<{
+        Chord: 1;
+        Pie: 2;
+    }>;
+    /**
+     * Creates an instance of Arc shape.
+     *
+     * @param {Stroke} [stroke] - A border of the shape.
+     * @param {string} [background] - Color, gradient, or image background, similar to CSS. Use an empty string to remove the background.
+     * @param {number} [opacity] - Opacity of the shape (0 to 1).
+     * @param {number} [x] - Horizontal position from the left edge.
+     * @param {number} [y] - Vertical position from the top edge.
+     * @param {number} [width] - Width of the arc (horizontal diameter).
+     * @param {number} [height] - Height of the arc (vertical diameter). If omitted, height will be same as width.
+     * @param {number} [startAngle] - Starting angle of the arc (0 to 360 degrees).
+     * @param {number} [sweepAngle] - How much the arc is open (0 to 360 degrees).
+     * @param {Arc.Type} [type] = Arc type. One of: `Arc.Type.Chord`, `Arc.Type.Pie`.
+     */
+    constructor(stroke?: Stroke, background?: string, opacity?: number, x?: number, y?: number, width?: number, height?: number, startAngle?: number, sweepAngle?: number, type?: Readonly<{
+        Chord: 1;
+        Pie: 2;
+    }>);
+    _size: {
+        width: number;
+        height: number;
+    };
+    _hole_size: {
+        width: number;
+        height: number;
+    };
+    _start_angle: number;
+    _extent: number;
+    _arc_type: 1;
+    /**
+     * Sets or gets the size of the arc (horizontal and vertical diameter).
+     *
+     * @param {number|{width:number, height:number}} width - Width of the arc (horizontal diameter), or a size object (e.g., {width:300,height:300}).
+     * @param {number} [height] - Height of the arc (vertical diameter).
+     * @returns {{width:number, height:number}|Arc} If called without parameters, current size is returned; otherwise this Arc object is returned.
+     */
+    size(...args: any[]): {
+        width: number;
+        height: number;
+    } | Arc;
+    /**
+     * Sets or gets the size of the hollow space inside the arc. The hole make it look more like a donut.
+     *
+     * @param {number|{width:number, height:number}} width - Width of the hole (horizontal diameter), or a size object (e.g., {width:50,height:50}).
+     * @param {number} [height] - Height of the hole (vertical diameter).
+     * @returns {{width:number, height:number}|Arc} If called without parameters, current hole size is returned; otherwise this Arc object is returned.
+     */
+    holeSize(...args: any[]): {
+        width: number;
+        height: number;
+    } | Arc;
+    /**
+     * Sets or gets the type of the arc to Arc.Type.Chord or Arc.Type.Pie
+     *
+     * @param {Arc.Type} [type] - One of the type values: Arc.Type.Pie, Arc.Type.Chord
+     * @returns {Arc.Type|Arc} If called without parameters, current type is returned; otherwise this Arc object is returned.
+     */
+    type(...args: any[]): Readonly<{
+        Chord: 1;
+        Pie: 2;
+    }> | Arc;
+    /**
+     * Gets or sets the starting angle of the arc.
+     *
+     * The starting angle defines where the arc begins, measured in degrees
+     * from the positive x-axis in a clockwise direction.
+     *
+     * @param {number} [angle] - Sets the start angle (0 to 360 degrees).
+     * @returns {number|Arc} Returns the current start angle if no parameter is given, otherwise returns the Arc instance for chaining.
+     */
+    startAngle(...args: any[]): number | Arc;
+    /**
+     * Sets or gets how much the arc is open in degrees, between 0 and 360.
+     *
+     * @param {number} [sweepAngle] - Sweep angle of the opening starting from the start angle (0 and 360).
+     * @returns {number|Arc} If called without parameters, current value is returned; otherwise this Arc object is returned.
+     */
+    sweepAngle(...args: any[]): number | Arc;
+    /**
+     * Returns a JSON object that contains this shape properties. It may be converted back to this shape.
+     *
+     * @param {string} [include="all"] - Specified what to include. "all" is default. Valid values are: "all", "stroke", "background", "points", "basic".
+     * @return {object} Returns an object containing this shape's properties.
+     */
+    toObject(include?: string): object;
+}
+import { Shape } from "./Shape.js";

package/types/classes/Button.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Button UI component that extends UIComponent class.
+ * For more methods for this component check UIComponent class.
+ * @class
+ * @global
+ */
+export class Button extends UIComponent {
+    /**
+     * Button constructor.
+     *
+     * @param {string} [text] - Button text
+     * @example
+     * this.button1 = new Button().text("Click Me");
+     * this.button2 = new Button("Click Me");
+     */
+    constructor(...args: any[]);
+    /**
+     * Sets or gets an action command. This command is specified in event object for onAction(e => {alert(e.command);}) event handler.
+     * Default value of action command for a Button is it's initial text.
+     *
+     * @param {string} [command] (Optional)
+     * @return {string|Button} If called without arguments, returns `number` value, otherwise returns `this` Button instance.
+     * @example
+     * const button = new Button("Activate").addTo(window).center();
+     * button.command("Activate Motor 1");
+     * button.onAction(e => {
+     *    alert(e.command); // shows a dialog window with a message "Activate Motor 1" when button is clicked.
+     * });
+     */
+    command(...args: any[]): string | Button;
+    /**
+     * Returns current size of an icon, or `null` when no icon has been set or icon failed to load.
+     * @readonly
+     * @type {Size|null}
+     */
+    readonly get iconSize(): Size | null;
+}
+import { UIComponent } from "./UIComponent.js";

package/types/classes/CheckBox.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Check box UI component that extends UIComponent class.
+ * For more methods for this component check UIComponent class.
+ * @class
+ * @global
+ */
+export class CheckBox extends UIComponent {
+    /**
+     * CheckBox constructor.
+     *
+     * @param {string} [text] - Text displayed next to the checkbox
+     */
+    constructor(...args: any[]);
+    /**
+     * Sets or gets the selection state of the checkbox.
+     *
+     * @param {boolean} [selected] - `true` to select, `false` to deselect the checkbox.
+     * @return {boolean|CheckBox} If called without arguments, returns `boolean` value, otherwise returns `this` CheckBox instance.
+     */
+    selected(...args: any[]): boolean | CheckBox;
+}
+import { UIComponent } from "./UIComponent.js";

package/types/classes/CheckBoxMenuItem.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Check box menu item UI component that extends MenuItem class.
+ * For more methods for this component check MenuItem and UIComponent class.
+ * @class
+ * @global
+ * @see MenuItem
+ * @extends MenuItem
+ */
+export class CheckBoxMenuItem extends MenuItem {
+    /**
+     * Sets or gets boolean indicating whether this component is be selected.
+     *
+     * @param {boolean} selected - `true` to select, `false` to deselect.
+     * @return {CheckBoxMenuItem|boolean} Returns `this` CheckBoxMenuItem instance if argument is provided, otherwise returns `boolean` value.
+     */
+    selected(...args: any[]): CheckBoxMenuItem | boolean;
+}
+import { MenuItem } from "./MenuItem.js";

package/types/classes/ComboBox.d.ts

@@ -0,0 +1,172 @@
+/**
+ * ComboBox UI component that extends UIComponent class.
+ * Check examples below and become familiar with a {@link ListItem} object format.
+ * @class
+ * @global
+ * @see ListItem
+ * @example
+ *
+ * // ListItem object format:
+ * ListItem {
+ *     text: string,         // Item text (required only for a new item).
+ *     id: string|number,    // Value that can be used by software logic to identify this item
+ *     value: string|number, // Additional value to be stored in the item for later use.
+ *     icon: string,         // Absolute or relative path to icon image, base64 encoded image string, or `null` to remove icon.
+ *     color: string,        // Item text color as a 6 character hex encoded color string (e.g. #665500)
+ *     background: string,   // Item background color as a 6 character hex encoded color string (e.g. #665500)
+ *     tooltip: string,      // Tooltip text to show when pointer hover the item. (in List and Tree components only)
+ *     font: Font            // Object{name: string, size: number, bold: boolean, ...}. See complete list of font properties in example of font() method.
+ * }
+ */
+export class ComboBox extends TextComponent {
+    /**
+     * Adds a list item at the end of the list, or inserts the item at specified index.
+     *
+     * @param {string|number|ListItem} item - List item as a string, number or a {@link ListItem} formatted object.
+     * @param {number} [index=undefined] - Integer position at which to add the item.
+     * @returns {number} Returns an index of the added item, or -1 if the item was not added.
+     * @see ListItem
+     * @example
+     * const i = combo1.add({text: "New Item", ...more optional properties}); // Adding item as object
+     * const i = combo1.add("New Item"); // Adding item as string
+     * const i = combo1.add(45); // Adding item as number
+     */
+    add(item: string | number | ListItem, index?: number): number;
+    /**
+     * If index argument is specified, N amount of items starting form specified index will be removed.
+     * If called without parameters, this component will be removed from it's parent. See examples below.
+     *
+     * @param {number} [index=undefined] - Index of the item to remove. If not provided, the component will be removed from its parent.
+     * @returns {ComboBox} Returns `this` ComboBox instance for method chaining.
+     * @example
+     * combo.remove(); // removes the component from it's parent container
+     * combo1.remove(4); // removes list item at index 4
+     */
+    remove(...args: any[]): ComboBox;
+    /**
+     * Gets the amount of items in the list.
+     * @readonly
+     * @type {number}
+     */
+    readonly get length(): number;
+    /**
+     * Gets, sets or updates an item at a specified index. Check usage examples below.
+     *
+     * @param {number} index - Index of the list item
+     * @param {ListItem} [item] - ListItem formatted object. See {@link ListItem} documentation.
+     * @param {boolean} [update=false] - `true` to update specified item properties with provided item properties, `false` to replace the item with new one. Default is `false`.
+     * @returns {ComboBox|ListItem} If item argument is passed, then `this` ComboBox instance is returned, otherwise item at specified index is returned. If index is out of range, `undefined` is returned.
+     * @see ListItem
+     * @example
+     * const item = combo1.item(3); // gets the item at index 3
+     * combo1.item(3, {text: "New text", value:"new value"}); // replaces item at index 3
+     * combo1.item(3, {background: "#FF7777"}, true); // changes item's background color at index 3
+     */
+    item(index: number, ...args: any[]): ComboBox | ListItem;
+    /**
+     * Gets a selected item. Returns a selected item as a ListItem formatted object, or `null` if no item is selected.
+     *
+     * @readonly
+     * @type {ListItem|null}
+     */
+    readonly get selectedItem(): ListItem | null;
+    /**
+     * Sets or gets an index of a selected item. Can be used to make an item at certain index to be selected.
+     *
+     * @param {number} [index] - Index of an item to select. Set -1 to make no item be selected.
+     * @returns {ComboBox|number} If index is specified, then `this` component instance is returned, otherwise currently selected index is returned.
+     */
+    selectedIndex(...args: any[]): ComboBox | number;
+    /**
+     * Selects and item that has a specified value, or gets a value of currently selected item.
+     *
+     * @param {string|number|null} [value] - Value of an item to be selected. Set `null` to make no item selected.
+     * @returns {ComboBox|number|string|null} If a `value` is specified, then `this` ComboBox instance is returned, otherwise a value of selected item is returned, or `null` if no item is selected.
+     */
+    selectedValue(...args: any[]): ComboBox | number | string | null;
+    /**
+     * Selects a first item whose `id` property matches provided `id`, or gets an `id` property of currently selected item.
+     *
+     * @param {string|number} [id] - ID of an item to be selected.
+     * @returns {ComboBox|number|string|null} If `id` parameter is specified, then `this` ComboBox instance is returned, otherwise an `id` of selected item is returned, or `null` if no item is selected.
+     */
+    selectedID(...args: any[]): ComboBox | number | string | null;
+    /**
+     *
+     * Sets or gets an array of list items. When setting, all existing items in the list will be removed before new ones are added.
+     *
+     * @param {Array<string|number|ListItem>} [items] - Items as an Array of objects, strings or numbers. Can be a mix of these types. For item Object's format check out add() method example .
+     * @returns {ComboBox|Array<ListItem>} When getting, an Array is returned, otherwise `this` component instance is returned.
+     */
+    items(...args: any[]): ComboBox | Array<ListItem>;
+    /**
+     * Removes all items.
+     * @return {ComboBox} Returns `this` component instance.
+     */
+    clear(): ComboBox;
+    /**
+     * Shows or hides the popup list, or get a boolean whether the popup is visible.
+     *
+     * @param {bool} [visible] - `true` to show, `false` to hide.
+     * @return {ComboBox|boolean} Returns `this` component instance if argument is passed, otherwise returns `boolean` value indication if the popup list is currently visible.
+     */
+    open(...args: any[]): ComboBox | boolean;
+    /**
+     * Registers, unregisters and gets a list of handler functions for the popup list events (when the popup becomes visible and hidden).
+     *
+     * @param {function(PopupEvent):any} [callback] - Handler function receiving {@link PopupEvent} object. Pass `null` to unregister all handler callbacks.
+     * @param {boolean} [remove] - Set to `true` to unregister the handler function.
+     * @return {function[]|ComboBox} Returns an array of registered handler functions if arguments are omitted, otherwise returns `this` component instance.
+     * @see PopupEvent
+     * @example
+     * // event Object format:
+     * const e = {
+     *   target: object,        // The component that triggered the event.
+     *   type: string,          // `show`, `hide`, `cancel`.
+     *   x: number,             // Component's X position
+     *   y: number,             // Component's Y position
+     *   interactive: boolean,  // Indicates if the popup was triggered by user's interaction (not programmatically).
+     * };
+     */
+    onPopupEvents(callback?: (arg0: PopupEvent) => any, ...args: any[]): Function[] | ComboBox;
+    /**
+     * Sets or gets the maximum number of items to show in a popup list without having to scroll.
+     *
+     * @param {number} size - Defines the maximum amount of items that should be visible in the popup list without having to scroll.
+     * @return {ComboBox|number} Returns `number` value if argument is omitted, otherwise returns `this` component instance.
+     */
+    popupSize(...args: any[]): ComboBox | number;
+    /**
+     * Gets or sets a padding for each item in the list. See example below.
+     *
+     * @param {number|string} padding - Number for same padding on all sides, string to specify padding for each side "top right bottom left"
+     * @return {string|List} Returns `this` component instance if at least one argument is provided, otherwise returns current padding.
+     * @example
+     * combobox.itemPadding(3);                // defines same padding for top, right, bottom and left.
+     * combobox.itemPadding("5 0 5 3");        // defines padding for each side separately, top=5, right=0, bottom=5 and left=3.
+     * const padding = combobox.itemPadding(); // gets the padding object
+     */
+    itemPadding(...args: any[]): string | List;
+    /**
+     * Finds first item whose text matches the string argument. If item is {text: "First Item", value: "item1"}, it should be found by passing value "First Item".
+     *
+     * @param {string} value - Search by this text
+     * @return {ListItem[]} Returns an array of found items. Each found item will have an `index` property fo convenience.
+     */
+    findByText(value: string): ListItem[];
+    /**
+     * Finds first item whose value matches the argument. If item is {text: "First Item", value: "item1", id: 1}, it should be found by passing value "item1".
+     *
+     * @param {string|number} value - Search by this text or number
+     * @return {ListItem[]} Returns an array of found items. Each found item will have an `index` property fo convenience.
+     */
+    findByValue(value: string | number): ListItem[];
+    /**
+     * Finds first item whose ID matches the argument. If item is {text: "First Item", value: "item1", id: 1}, it should be found by passing value 1.
+     *
+     * @param {string|number} value - Search by this text or number
+     * @return {ListItem[]} Returns an array of found items. Each found item will have an `index` property fo convenience.
+     */
+    findByID(value: string | number): ListItem[];
+}
+import { TextComponent } from "./TextComponent.js";

package/types/classes/ComponentContainer.d.ts

@@ -0,0 +1,131 @@
+/**
+ * ComponentContainer is not a standalone component and should not be instantiated.
+ * It provides methods and members for managing child components.
+ * ComponentContainer is extended by {@link Window}, {@link InternalWindowContainer}, {@link InternalWindow}, {@link Panel}, {@link ToolBar}, {@link MenuBar}, {@link Menu}, {@link ContextMenu}, {@link Tabs}, {@link SplitView} and a {@link ScrollPane}.
+ * @class
+ * @global
+ */
+export class ComponentContainer extends UIComponent {
+    static preInitProperties: string[];
+    static postInitProperties: string[];
+    /**
+     * ComponentContainer constructor.
+     * @internal
+     * @ignore
+     */
+    constructor(...args: any[]);
+    applyComponentProperties: any;
+    /**
+     * Loads UI Components and properties from UI designer file FILE_NAME.ui.json where FILE_NAME is the name of JavaScript file of the component.
+     *
+     * @param {string} class_name - Class name for which to load UI
+     * @private
+     * @ignore
+     */
+    private applyUIDefinition;
+    /**
+     * Gets an array of child components.
+     *
+     * A new array of child components is created each time `.children` is accessed, so you may not want to use it directly inside a `for(let i=0; i < component.children.length, i++){}` or `while(...){}` loops. First save it to a variable, then use it in such loop.
+     *
+     * In loops `for..in`, `for..of` or `component.children.forEach((c, i)=>{...})` it's accessed only once, so you are looping through the same array.
+     *
+     * @readonly
+     * @type {Object[]}
+     * @example <h2>Looping through Window's components</h2>
+     * // method 1
+     * for(child of window.children)
+     * {
+     *     ...
+     * }
+     *
+     * // method 2
+     * const _children = window.children;
+     * for(let i = 0; i < _children.length; i++)
+     * {
+     *     const child = _children[i];
+     *     ...
+     * }
+     *
+     * // method 3
+     * window.children.each(child=>{
+     *     ...
+     * });
+     */
+    readonly get children(): Object[];
+    /**
+     * Gets the number of components added to this container.
+     * @readonly
+     * @type {number}
+     */
+    readonly get childCount(): number;
+    /**
+     * Returns a child component at specified index, or `null` if index is outside of range.
+     *
+     * @param {number} index - Component index (z order).
+     * @return {UIComponent|null} A child component at specified index, or `null` if there is no child at specified index.
+     */
+    child(index: number): UIComponent | null;
+    /**
+     * Gets or sets the index of a child component within this container. Setting new index changes z-order of the component.
+     *
+     * @param {Object} child - Child component
+     * @param {number} [new_index] - The new index to assign to the child. Moves the component in z-order.
+     * @return {this|null|number} If `new_index` is provided, returns `this` component. If the child is not found in this container, returns `null`. Otherwise, returns the child's current z-index.
+     */
+    childIndex(child: Object, new_index?: number): this | null | number;
+    /**
+     * Adds a child component to this container component.
+     *
+     * @param {object} component - UI Component that can be a child of this component.
+     * @param {number|object} [data_or_index] - Argument to pass some extra data (such as Tab Name to add Panel to Tabs), or index at which to insert the child. By default component is added to the end.
+     * @returns {this} Returns an instance of `this` component for chaining.
+     * @see UIComponent#addTo
+     * @example <h2>Adding a component at specified index 5</h2>
+     * panel.addChild(new CheckBox("Enabled checkbox").position(10, 15), 5); // adds to panel and positions at (10,15) coordinates
+     *
+     * @example <h2>Adding a component at specified index</h2>
+     * tabs.addChild(new Panel(), {text: "Registration", enabled: true, tooltip: "Create new account", icon: "images/user.png"});
+     */
+    addChild(component: object, ...args: any[]): this;
+    /**
+     * Removes component's child by child object or child index.
+     *
+     * @param {object|number} child_or_index - Child component object or index of the child.
+     * @param {boolean} [recursive=false] - Boolean indicates if all descendents of this child should also be removed.
+     * @returns {UIComponent|null} The removed child component, or `null` if there is no child at specified index.
+     */
+    removeChild(child_or_index: object | number, recursive?: boolean): UIComponent | null;
+    /**
+     * Checks if passed component is a descendant of this container component.
+     *
+     * @param descendant - Child component to check.
+     * @returns {boolean} If the descendant component is inside of this component.
+     * @throws {TypeError} When passed argument is not an instance of UIComponent.
+     * @see UIComponent#insideOf
+     */
+    contains(descendant: any): boolean;
+    /**
+     * Gets, registers or unregisters an event handler function for container-related events
+     * triggered when a child component is added or removed.
+     *
+     * @param {function(ContainerEvent): any} [callback=undefined] - The event handler function that receives a {@link ContainerEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see ContainerEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,  // The container component that triggered the event.
+     *   type: string,    // `add`, `remove`.
+     *   child: object    // The child component that was added or removed
+     * };
+     */
+    onContainerEvents(...args: any[]): this | Function[];
+    /**
+     * @private
+     */
+    private applyComponentPropertiesV1_0;
+    #private;
+}
+import { UIComponent } from "./UIComponent.js";

package/types/classes/ContextMenu.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ContextMenu UI component that extends ComponentContainer, which extends UIComponent class.
+ * ContextMenu is used to create menus that pop up when user right clicks on UI component or system tray icon.
+ * @class
+ * @global
+ * @see ComponentContainer
+ */
+export class ContextMenu extends ComponentContainer {
+    _parents: any[];
+    /**
+     * Registers, unregisters and gets a list of handler functions for the context menu popup events (when the the context menu becomes visible and hidden).
+     *
+     * @param {function(PopupEvent):any|null} [callback] - Event handler function that receives a {@link PopupEvent} as an argument. Pass `null` to unregister all registered callbacks.
+     * @param {boolean} [remove] - Set to `true` to unregister the handler function.
+     * @return {function[]|ComboBox} Returns an array of registered handler functions if arguments are omitted, otherwise returns `this` component instance.
+     * @see PopupEvent
+     * @example
+     * // event Object format:
+     * const e = {
+     *   target: object,        // The component that triggered the event.
+     *   type: string,          // `show`, `hide`, `cancel`.
+     *   invoker: Object        // UI Component that invoked the popup, or `null` if it was invoked programmatically.
+     *   x: number,             // X position relative to invoker. Only present when invoker is not `null`.
+     *   y: number,             // Y position relative to invoker. Only present when invoker is not `null`.
+     *   screenX: number,       // X position relative to default screen.
+     *   screenY: number,       // Y position relative to default screen.
+     *   interactive: boolean,  // Indicates if the popup was triggered by user's interaction (not programmatically).
+     * };
+     */
+    onPopupEvents(callback?: (arg0: PopupEvent) => any | null, ...args: any[]): Function[] | ComboBox;
+    /**
+     * Adds a child component to this container component.
+     * Overrides addChild() method from UIComponent class to add component validation logic.
+     *
+     * @param {Object} component - UI Component that can be a child of this component.
+     * @param {...any} [data_or_index] - Argument to pass some extra data (such as Tab Name to add Panel to Tabs), or index at which to insert the child. By default component is added to the end.
+     * @returns {this}
+     */
+    addChild(component: Object, ...data: any[]): this;
+    /**
+     * Open the menu with all its parent menus or context menu.
+     * @param {object} [position] - Example: {x: 100, y: 100}. Used to specify position where to open the ContextMenu. If invoker is specified, then position is relative to position of invoker component, otherwise it a screen position.
+     * @param {object} [invoker] - Used to set invoker if the context menu isn't assigned to any object and you want to be able to get invoker by using "invoker" getter.
+     * @return {ContextMenu} Returns `this` ContextMenu instance.
+     */
+    open(position?: object, invoker?: object): ContextMenu;
+    /**
+     * Returns last invoker Object that invoked the popup, or `null` if no invoker was involved.
+     * @readonly
+     * @type {Object|null}
+     */
+    readonly get invoker(): Object | null;
+    /**
+     * Adds this ContextMenu to a specified parent component.
+     *
+     * @param {object} parent - A valid component that accepts ContextMenu. `parent` must be derived from UIComponent.
+     * @return {ContextMenu} Returns an instance of `this` object.
+     */
+    addTo(parent: object, ...args: any[]): ContextMenu;
+    /**
+     * Removes this ContextMenu from all parent components or removes a specified child component from this ContextMenu.
+     *
+     * @param {Object} [child] - Child to be removed. When omitted, this context menu gets removed from all parent components.
+     * @param {boolean} [recursive] - Indicates whether to also remove all child's descendents.
+     * @return {ContextMenu} Returns an instance of `this` component.
+     * @example
+     * child.remove(); // Removes this context menu from it's parent components
+     * child.remove(true); // Removes this context menu from it's parent components and all its descendants recursively
+     * parent.remove(child); // removes child from parent container
+     * parent.remove(child, true); // Removes child from parent container and all of child's descendants recursively
+     */
+    remove(...args: any[]): ContextMenu;
+}
+import { ComponentContainer } from "./ComponentContainer.js";

package/types/classes/DocumentEditor.d.ts

@@ -0,0 +1,95 @@
+/**
+ * DocumentEditor UI component that extends TextComponent and ScrollableComponent, which extend UIComponent class.
+ * DocumentEditor is a text editor that can be switched to HTML mode to display or edit an HTML styled page. Only HTML 3.2 is supported. Modern tags like in HTML5 are not supported and may be ignored. HTML page can be styles with CSS but CSS support is also limited.
+ * Editing the HTML page is not great, but may be enough for basic purposes. CSS can be added to the document separately by setCSS() and addCSS() methods, or it can be embedded into the HTML content using `style` tags.
+ *
+ * For more methods for this component check UIComponent class.
+ * @class
+ * @global
+ * @see TextComponent
+ * @see ScrollableComponent
+ */
+export class DocumentEditor extends TextComponent {
+    /**
+     * Sets or gets text or HTML content of the component (depending if HTML is enabled using html(boolean) method.
+     *
+     * @param {string} [text] - Can be plain text or HTML. HTML should be surrounded with HTML tags. Check example below.
+     * @param {TextAction} [action] - Specific action to perform with text. Replace, append, prepend, or insert. Do not use this argument for HTML content.
+     * @param {number} [insert_position] - Position where to insert text. Applies only if `action` argument is TextAction.Insert.
+     * @return {string|this} Returns text or HTML if no argument is set, otherwise returns `this` component.
+     * @example
+     * const txt = textfield.text(); // gets text value
+     * textfield.text("New Text"); // sets new text value
+     * textfield.html(true).text("<html>New Text Line 1<br />New Text Line 2</html>"); // changes editor's content type to HTML and sets HTML content
+     * textfield.text("Appended Text", TextAction.Append); // Appends new text to the end of current text
+     * textfield.text("Inserted Text", TextAction.Insert); // Inserts at current caret position
+     * textfield.text("Inserted Text", TextAction.Insert, textfield.caretPosition() - 50); // Inserts at specified position
+     */
+    text(...args: any[]): string | this;
+    /**
+     * Enables/Disables Word/Character line wrapping of long lines instead of scrolling horizontally.
+     *
+     * @param {LineWrap} [value] - LineWrap.Word, LineWrap.Character, or LineWrap.None
+     * @return {LineWrap|DocumentEditor} If argument is passed, `this` component instance is returned, otherwise line wrap value is returned.
+     * @see LineWrap
+     */
+    lineWrap(...args: any[]): LineWrap | DocumentEditor;
+    /**
+     * Sets or gets boolean value stating if content type of the document is HTML or not. True means HTML, false means plain text.
+     *
+     * @param {boolean} [value] - `true` to enable HTML content type, `false` to switch to plain text.
+     * @return {DocumentEditor|boolean} If argument is passed, `this` component instance is returned, otherwise `boolean` is returned.
+     */
+    html(...args: any[]): DocumentEditor | boolean;
+    /**
+     * Adds CSS styles to be applied to the HTML document without adding this CSS to the HTML content. This method should be used only when DocumentEditor's HTML content type is enabled using html(true) method. Added CSS cannot be removed separately. To remove all added CSS use setCSS("") method.
+     *
+     * @param {string} css - CSS content (without `style` tags).
+     * @return {DocumentEditor}
+     */
+    addCSS(css: string): DocumentEditor;
+    /**
+     * Sets new CSS styles to be applied to the HTML document without adding this CSS to the HTML content. It replaces previously added CSS. This method can be used to remove previously added CSS by calling setCSS(""). This method should be used only when DocumentEditor's HTML content type is enabled using html(true) method.
+     *
+     * @param {string} css - CSS content (without `style` tags).
+     * @return {DocumentEditor}
+     */
+    setCSS(css: string): DocumentEditor;
+    /**
+     * Sets/gets a comma separated list of HTML tags to be excluded (stripped away) from HTML document (when content type is set to HTML using html(true).
+     *
+     * @param {string} [tags] - A list of tags separated by comma. e.g. editor.excludedTags("hr audio video div");
+     * @return {DocumentEditor|string}
+     */
+    excludedTags(...args: any[]): DocumentEditor | string;
+    /**
+     * Sets or gets the ability to click on HTML document's hypertext links made with `a` tag to open the link in a web browser. When enabled, user can click on a hyperlink to open the link's URL in a default web browser. For that HTML content type must be enabled with html(true) method and editing should be disabled with editable(false) method.
+     *
+     * @param {boolean} [enabled] - `true` to enable, `false` to disable.
+     * @return {DocumentEditor|boolean} If argument is omitted, `boolean` is returned, otherwise `this` DocumentEditor instance is returned.
+     */
+    linksEnabled(...args: any[]): DocumentEditor | boolean;
+    /**
+     * Registers, unregisters, and gets an Array of event handlers for the event when user clicks on a hyperlink. It gives the ability to create a custom action for hyperlink clicks. Check for event Object format in example below.
+     *
+     * @param {function(LinkEvent):any} [callback] - Handler function receiving {@link LinkEvent} object. Pass `null` to unregister all handler callbacks.
+     * @param {boolean} [remove] - Set to `true` to unregister the handler function.
+     * @return {function[]|ComboBox} Returns an array of registered handler functions if arguments are omitted, otherwise returns `this` component instance.
+     * @see LinkEvent
+     * @example
+     * // LinkEvent format example
+     * LinkEvent {
+     *     target: DocumentEditor, // This component
+     *     type: string,           // `click`, `mouseenter`, or `mouseleave`
+     *     url: string,            // The href="" attribute of the `a` tag
+     *     text: string,           // Text of the hyperlink
+     *     shift: boolean,         // Indicates if Shift key was pressed when the event occurred
+     *     ctrl: boolean,          // Indicates if Ctrl key was pressed when the event occurred
+     *     alt: boolean,           // Indicates if Alt key was pressed when the event occurred
+     *     modifiers: string       // Keyboard modifiers mask
+     *     modifiersText: string   // Text representation of keyboard modifiers
+     * }
+     */
+    onLinkEvents(callback?: (arg0: LinkEvent) => any, ...args: any[]): Function[] | ComboBox;
+}
+import { TextComponent } from "./TextComponent.js";