swing-ui 0.1.25 → 1.0.3

package/types/classes/MediaPlayer.d.ts

@@ -0,0 +1,381 @@
+/**
+ * Media player is an audio and video player component capable of playing video & audio files, video & audio live streams, video & audio from URL, and from audio & video capture devices, like microphone, web cam and other video capture devices.
+ * It's done with the help of pre-installed FFMPEG, so FFMPEG is required to be installed for this to work. FFMPEG is a free open-source software.
+ * @class
+ * @global
+ * @example <h2>Examples of formats of commonly used objects with media player:</h2>
+ *
+ * VideoDevice {
+ *     [name]: string,          // Name of the video input device.
+ *     id: string,              // ID if the video input device.
+ *     [formats]: VideoFormat[],// Available video formats (present only when getting video input devices)
+ *     [format]: VideoFormat    // Chosen video format to use (required when setting a video input device).
+ * }
+ *
+ * VideoFormat {
+ *      size: string,           // Video frame size in pixels
+ *      pixel_format: string    // Frame image encoding coming out of the device (e.g.: "yuyv422")
+ *      [fps]: number           // (required only when setting a video input device)
+ *      [min_fps]: number,      // Minimum available frame rate. For example 7.5 fps.
+ *      [max_fps]: number,      // Maximum available frame rate. For example 30 fps.
+ * }
+ *
+ * AudioDevice {
+ *     [name]: string,              // Name of audio device.
+ *     id: string,                  // ID of audio device. (required when setting an audio device).
+ *     [formats]: AudioFormats[],   // Available audio formats (present only when getting audio devices).
+ *     [format]: AudioFormat,       // Audio format to use (required when setting an audio device).
+ * }
+ *
+ * AudioFormat {
+ *      channels: number,   // Audio channels available
+ *      bits: number,       // Bits per sample
+ *      [rate]: number,     // Sample rate in Hz. It's only used for audio input device formats (not output). Set it when setting an audio output device.
+ *      [encoding]: string  // Audio encoding (e.g.: PCM_UNSIGNED, PCM_SIGNED). (Only available in audio output device formats).
+ * }
+ */
+export class MediaPlayer extends UIComponent {
+    /**
+     * Enum for media player states.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} NoMedia - No media loaded.
+     * @property {number} Stopped - Media is stopped.
+     * @property {number} Playing - Media is playing.
+     * @see MediaPlayer#state
+     * @example
+     * if(player.state === MediaPlayer.State.Playing)
+     * {
+     *     console.log("Player is playing");
+     * }
+     */
+    static readonly State: Readonly<{
+        NoMedia: 0;
+        Stopped: 1;
+        Playing: 2;
+    }>;
+    /**
+     * Enum for video interpolation methods. Used to smooth resized video and reduce pixelation.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} None - No interpolation applied.
+     * @property {number} ByGUI - Interpolation performed by the GUI.
+     * @property {number} ByFFMPEG - Interpolation performed by FFMPEG.
+     * @example
+     * player.interpolation(MediaPlayer.Interpolation.ByFFMPEG);
+     */
+    static readonly Interpolation: Readonly<{
+        None: 0;
+        ByGUI: 1;
+        ByFFMPEG: 2;
+    }>;
+    /**
+     * Enum for subtitle background styles. Used to enhance subtitle readability over video. Background color can be changed by {@link MediaPlayer#subtitleBackground}
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} None - Subtitles not visible (only sent as a player event).
+     * @property {number} Plain - Visible but without a background.
+     * @property {number} Shadow - Subtitle has a shadow background. (Default)
+     * @property {number} Box - Subtitle is placed inside a solid box.
+     * @property {number} RoundBox - Subtitle is placed inside a solid box with rounded corners.
+     * @see MediaPlayer#subtitleStyle
+     * @see MediaPlayer#subtitleBackground
+     * @example
+     * player.subtitleStyle(MediaPlayer.SubtitleStyle.Box);
+     */
+    static readonly SubtitleStyle: Readonly<{
+        None: 0;
+        Plain: 1;
+        Shadow: 2;
+        Box: 3;
+        RoundBox: 4;
+    }>;
+    /**
+     * Sets the path to ffmpeg executable file, preferably absolute path. Default is `ffmpeg`, and it requires the path to ffmpeg to be added to `Path` environment variable.
+     * When setting path, `boolean` is returned whether path is valid and accepted.
+     * When getting value, `string` of previously specified or default value is returned.
+     *
+     * @param {string} [path] - Path to the executable FFMPEG file. Default path is "ffmpeg".
+     * @return {boolean|string} Returns `string` path when getting, or `boolean` when setting. `boolean` indicates if specified path was accepted (if it exists).
+     */
+    static ffmpegPath(...args: any[]): boolean | string;
+    /**
+     * Initializes the MediaPlayer UI component.
+     * @see VideoDevice
+     * @see AudioDevice
+     * @see VideoFormat
+     * @see AudioFormat
+     */
+    constructor();
+    /**
+     * Sets a path of a local media file as a new media source. Resets player and overrides previously set source.
+     *
+     * @param {string} path - Path to media file.
+     * @param {number} [videoStream] - If the media file has more than one video stream, specify which one to use. Default is 0. For audio-only files this is ignored.
+     * @param {number} [audioStream] - If the media file has more than one audio stream (such as multiple languages), specify which one to use. Default is 0. For media without audio stream this is ignored.
+     * @param {number|string|null} [subtitleStream=null] - Index of a subtitle stream or a subtitles file path. Default is `null` for no subtitles.
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    setFile(path: string, videoStream?: number, audioStream?: number, subtitleStream?: number | string | null): MediaPlayer;
+    /**
+     * Sets URL of the media source. Resets player and overrides previously set source.
+     *
+     * @param {string} url - URL of media.
+     * @param {number} [videoStream] - If the media has more than one video stream, specify which one to use. Default is 0. For audio-only files this is ignored.
+     * @param {number} [audioStream] - If the media has more than one audio stream (such as multiple languages), specify which one to use. Default is 0. For media without audio stream this is ignored.
+     * @param {number|null} [subtitleStream=null] - Index of a subtitle stream. There may be multiple streams in case of multiple languages. Default is NULL for no subtitles.
+     * @param {string|null} [format] - Recommended to set for live video streams, such as web cam stream. This value is set as "-input_format" option for FFMPEG command. For example: mjpeg, rtsp, flv, mpegts, hls, http, https, srt or icecast.
+     * @param {boolean} [lowLatency] - Set to TRUE to use ffmpeg options for low latency for live video streams (ffmpeg options such as low buffering).
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    setURL(url: string, videoStream?: number, audioStream?: number, subtitleStream?: number | null, format?: string | null, lowLatency?: boolean): MediaPlayer;
+    /**
+     * Sets video device and audio device to use as video and audio source. Resets player and overrides previously set source.
+     * To get a list of available devices and their details getters {@link MediaPlayer#videoInputDevices} and {@link MediaPlayer#audioInputDevices} can be used.
+     *
+     * @param {VideoDevice|null} videoDevice - Video device object (camera or video capture card). Set to `null` to omit video device.
+     * @param {AudioDevice|null} [audioDevice=undefined] - Audio device object (microphone, audio capture card or system audio). Omit or set to `null` to omit audio device.
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    setInputDevice(videoDevice: VideoDevice | null, audioDevice?: AudioDevice | null): MediaPlayer;
+    /**
+     * Sets or gets current playing time in seconds. Decimal points are allowed (e.g. player.seek(165.43); ).
+     *
+     * @param {number} [seconds] - Sets seek time in seconds. Two decimal points allowed for more precision.
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    seek(...args: any[]): MediaPlayer;
+    /**
+     * Makes the media player start media playback (assuming that media was previously specified using setFile(), setURL() or setInputDevice() functions).
+     *
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    play(): MediaPlayer;
+    /**
+     * Makes media player pause the playback.
+     *
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    pause(): MediaPlayer;
+    /**
+     * Makes media player stop the playback. Seek time resets to 0, so play() function would start the playback from beginning.
+     *
+     * @return {MediaPlayer} Returns `this` component instance.
+     */
+    stop(): MediaPlayer;
+    /**
+     * Sets or get whether video frame should be resized to fit the media player component.
+     *
+     * @param {boolean} [fit] - `true` to resize video to fit player component, `false` to use actual resolution of the video.
+     * @returns {boolean|MediaPlayer} Returns `this` component instance if setting, `boolean` if getting.
+     */
+    fit(...args: any[]): boolean | MediaPlayer;
+    /**
+     * Sets or get hardware acceleration setting for ffmpeg video decoding.
+     * To get a list of supported hardware acceleration options use `hardwareAccelerations` getter property.
+     *
+     * @param {string} [hwaccel] - `-hwaccel` option value for FFMPEG. Default is "auto". `null` or "none" to disable hardware acceleration.
+     * @returns {string|MediaPlayer} Returns `this` component instance if setting, `string` if getting.
+     */
+    hardwareAcceleration(...args: any[]): string | MediaPlayer;
+    /**
+     * Gets a list of supported hardware acceleration options that can be used by FFMPEG on this system.
+     * Returns an array of supported hardware accelerations that can be used to decode a video by FFMPEG.
+     * @readonly
+     * @type {string[]}
+     */
+    readonly get hardwareAccelerations(): string[];
+    /**
+     * Gets an array of enabled video input devices (such as WebCam or video capture device) with an array of accepted video formats (size and frame rate).
+     * Returns an array of objects that contain information about each video input device recognized by FFMPEG.
+     * NOTE: On linux it is recommended to have `v4l2-utils` installed for fast video devices lookup, otherwise alternative method take a lot longer to complete and may return less video formats and FPS options.
+     *
+     * @readonly
+     * @type {VideoDevice[]}
+     * @see VideoDevice
+     */
+    readonly get videoInputDevices(): VideoDevice[];
+    /**
+     * Gets an array of enabled audio input devices (such as microphone, system sound) with an array of accepted audio formats (sample rate, bit depth, and amount of channels).
+     * Returns an array of objects that contain information about each audio input device recognized by FFMPEG.
+     *
+     * @readonly
+     * @type {AudioDevice[]}
+     * @see AudioDevice
+     */
+    readonly get audioInputDevices(): AudioDevice[];
+    /**
+     * Gets a list of output audio devices (such as speaker, bluetooth headphones, etc.) and their accepted audio formats.
+     * These devices may be specified to be used while playing video or audio.
+     * Returns an array of objects that contain information about each audio output device recognized by FFMPEG.
+     *
+     * @readonly
+     * @type {AudioDevice[]}
+     * @see AudioDevice
+     */
+    readonly get audioOutputDevices(): AudioDevice[];
+    /**
+     * Sets or gets a current audio output device. To obtain a list of devices you can use  "audioOutputDevices" getter property (e.g. player.audioOutputDevices), which returns a list of devices with their ID and formats.
+     * Device name or ID may be passed, but name is preferred, because when devices are added or removed, their ID may change, because it's just an index of the list of devices (enumerator), but names are unique.
+     *
+     * @param {string} [name] - Audio output device name (or ID) obtained from {@link AudioDevice} object using `{@link MediaPlayer#audioOutputDevices}` getter.
+     * @return {MediaPlayer|string} Returns `this` component instance when setting, otherwise current audio output device info as an `object`.
+     * @see AudioDevice
+     * @see MediaPlayer#audioOutputDevice
+     * @example <h2>Getting a list of devices and setting first one:</h2>
+     * const player = new MediaPlayer();
+     * const _devices = player.audioOutputDevices;
+     *
+     * player.audioOutputDevice(_devices[0].name);
+     *
+     */
+    audioOutputDevice(...args: any[]): MediaPlayer | string;
+    /**
+     * Registers, unregisters, and gets an Array of event handlers for the MediaPlayer.
+     *
+     * @param {function(PlayerEvent):any} [callback] - Handler function receiving {@link PlayerEvent} object. Pass `null` to unregister all handler callbacks.
+     * @param {boolean} [remove] - Set to `true` to unregister the handler function.
+     * @return {MediaPlayer|function[]} Returns `this` component instance if adding or removing the handler, otherwise returns an array of added handler functions.
+     * @see PlayerEvent
+     * @see Media
+     * @see VideoStream
+     * @see AudioStream
+     * @see SubtitleStream
+     * @example
+     * // Example of PlayerEvent object
+     * PlayerEvent {
+     *     type: string,        // One of: `loadstart`, `loadedmetadata`, `seeking`, `timeupdate`, `play`, `stop`.
+     *     mediaType: string,   // The type of media that is set to play in the player. One of: `File`, `InputDevice`, `URL`.
+     *     media: Media,        // A Media formatted object that contains details about loaded media.
+     *     currentTime: number, // Current play time.
+     *     duration: number,    // Duration of the media in seconds. When event type is `timeupdate`.
+     *     reason: string,      // Reason for stopping: `Pause`, `EndOfMediaFile`
+     * }
+     *
+     * // Example of a VideoStream object
+     * VideoStream {
+     *      sampleWidth: number,
+     *      sampleHeight: number,
+     *      width: number,
+     *      height: number,
+     *      pixelAspectRatio: string,
+     *      displayAspectRatio: string,
+     *      frameRate: number,
+     *      codec: string,
+     *      pixelFormat: string,
+     *      progressive: boolean,
+     *      default: boolean
+     * }
+     *
+     * // Example of a AudioStream object
+     * AudioStream {
+     *      sampleRate: number,
+     *      channels: number,
+     *      bitDepth: number,
+     *      codec: string,
+     *      default: boolean
+     * }
+     *
+     * // Example of a SubtitleStream object
+     * SubtitleStream {
+     *      language: string,
+     *      codec: string,
+     *      default: boolean
+     * }
+     */
+    onPlayerEvents(callback?: (arg0: PlayerEvent) => any, ...args: any[]): MediaPlayer | Function[];
+    /**
+     * Gets the current state of the media player component. The returned value corresponds to {@link MediaPlayer#State}.
+     *
+     * @readonly
+     * @see MediaPlayer#State
+     * @type {MediaPlayer.State}
+     */
+    readonly get state(): Readonly<{
+        NoMedia: 0;
+        Stopped: 1;
+        Playing: 2;
+    }>;
+    /**
+     * Sets or gets the method how smoothing is done when video is resized.
+     * `ByGUI` means that video frames are smoothed out while drawing on the player component in GUI.
+     * `ByFFMPEG` means that ffmpeg will resize video to the size of the component before sending it to GUI. When component is resized while video is playing, the video will have to stop and then start again at the same position.
+     * `None` means that video will not be smoothed, and when it's resized, it will look pixelated.
+     *
+     * @param {MediaPlayer.Interpolation} [interpolation] - Specifies a method of smoothing video when it's displayed in not it's original size. Options: MediaPlayer.Interpolation.[None|ByGUI|ByFFMPEG]
+     * @return {MediaPlayer.Interpolation|MediaPlayer} When setting value an instance of `this` object is returned, otherwise a current value is returned.
+     */
+    interpolation(...args: any[]): Readonly<{
+        None: 0;
+        ByGUI: 1;
+        ByFFMPEG: 2;
+    }> | MediaPlayer;
+    /**
+     * Sets or gets whether to show visualizer for audio-only streams (when no video stream is present, such as when playing music).
+     *
+     * @param {boolean} enable - Use or not use visualizer for audio-only streams.
+     * @return {boolean|MediaPlayer} When setting value an instance of `this` object is returned, otherwise a current value is returned.
+     */
+    visualizer(...args: any[]): boolean | MediaPlayer;
+    /**
+     * Sets or get value if media should be looping. Valid values are `true`, `false`, or a positive integer how many times it should be looped.
+     * The stream continues even though video or audio repeats, after first iteration current time stops updating because it would show time of the
+     * total playback, not the current media time. If you need correct media progress time, implement your own loop by starting video again when it stops.
+     *
+     * @param {boolean|number} [loop] - Loop or not to loop `boolean`, or a `number` how many times to loop.
+     * @return {boolean|number|MediaPlayer} When setting a value, an instance of `this` object is returned; otherwise a current value is returned.
+     */
+    loop(...args: any[]): boolean | number | MediaPlayer;
+    /**
+     * Sets or gets the mute state of the media player audio. If muted, it will produce silence instead of provided sound.
+     * Its only used if audio stream is present.
+     *
+     * @param {boolean} mute - `true` to mute, `false` to unmute.
+     * @return {boolean|MediaPlayer} When setting value an instance of `this` object is returned, otherwise a current value is returned.
+     */
+    mute(...args: any[]): boolean | MediaPlayer;
+    /**
+     * Sets or gets the background color of subtitles text. The background is used for improved readability when video colors are similar to colors of subtitles text.
+     *
+     * @param {String} [color] - Color string (e.g.: "#000000" or "00000000"). Supports alpha channel for setting transparency.
+     * @return {String|MediaPlayer} If called without parameters, the instance of the MediaPlayer component is returned, otherwise current value is returned.
+     * @see MediaPlayer#subtitleStyle
+     */
+    subtitleBackground(...args: any[]): string | MediaPlayer;
+    /**
+     * Sets or gets the style of the subtitles. When `None`, subtitles are not visible. The background is used for improved readability when video colors are similar to colors of subtitles text.
+     *
+     * @param {MediaPlayer.SubtitleStyle} [style] - Style of the subtitle, or `None` to make it not visible. It's still sent as a `PlayerEvent`.
+     * @return {MediaPlayer.SubtitleStyle|MediaPlayer} If called without parameters, the instance of the MediaPlayer component is returned, otherwise current value is returned.
+     * @see MediaPlayer#SubtitleStyle
+     * @see MediaPlayer#subtitleBackground
+     * @see PlayerEvent
+     */
+    subtitleStyle(...args: any[]): Readonly<{
+        None: 0;
+        Plain: 1;
+        Shadow: 2;
+        Box: 3;
+        RoundBox: 4;
+    }> | MediaPlayer;
+    /**
+     * Sets video filters to be applied to the video video by FFMPEG. If one of preset filters is not enough, feel free to set a `custom` filter (any ffmpeg video filter that is compatible with -vf option).
+     *
+     * @param {VideoFilters|null} filters - A VideoFilters object. Check out `VideoFilters` type definition for details. Set to `null` to clear previously set video filters.
+     * @returns {MediaPlayer} Returns this MediaPlayer instance for chaining.
+     * @see VideoFilters
+     */
+    videoFilters(filters: VideoFilters | null): MediaPlayer;
+    /**
+     * Sets or gets component opacity float value between 0 and 1 inclusive.
+     *
+     * @param {number} [opacity] - A number between 0 and 1 inclusive.
+     * @return {number|this} If `opacity` argument is provided, `this` component is returned, otherwise opacity `number` is returned.
+     */
+    opacity(...args: any[]): number | this;
+    #private;
+}
+import { UIComponent } from "./UIComponent.js";

package/types/classes/Menu.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Menu UI component is used to create menus in a menu bar or create a submenu in context menu. It extends MenuItem class.
+ * Menu object can be added to MenuBar, ContextMenu, or another Menu object to create a submenu.
+ * @class
+ * @global
+ * @extends MenuItem
+ */
+export class Menu extends MenuItem {
+    /**
+     * Registers, unregisters and gets a list of handler functions for the menu popup events (when the menu becomes expended and collapsed).
+     *
+     * @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
+     * mainForm.mainMenuBar = new MenuBar();
+     * let handler = function(e){console.log(e);}
+     * mainForm.fileMenu = new Menu("File").addTo(mainForm.mainMenuBar).onPopupEvents(handler);
+     *
+     * // 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 UIComponent.addChild() to validate components being added.
+     *
+     * @param {Object} component - UI Component that can be a child of this component.
+     * @param {...any} [data_or_index] - Argument to pass index at which to insert the child. By default component is added to the end.
+     * @returns {this}
+     */
+    addChild(component: Object, ...data: any[]): this;
+}
+import { MenuItem } from "./MenuItem.js";

package/types/classes/MenuBar.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MenuBar UI component is used to create a menu bar at the top of the application. It extends UIComponent class.
+ *
+ * Menu bar can be added to Window in two ways, by setting the MenuBar as the Window's main menu bar using window.menuBar(menuBar) method, or adding the MenuBar object as any other UI component using menuBar.addTo(window) or window.addChild(menuBar).
+ *
+ * Using window.menuBar(menuBar) automatically positions and resizes the menu bar to Window's width and in MacOS it uses it as the main menu bar shows at the top menu bar of the operating system.
+ *
+ * Adding the menu bar as a regular UI component to Window will keep the menu inside the Window and you will have to resize it by setting the desired width (and optionally height).
+ *
+ * Only Menu objects can be added to MenuBar.
+ *
+ * Extends {@link ComponentContainer}, which extends {@link UIComponent}.
+ * @class
+ * @global
+ */
+export class MenuBar extends ComponentContainer {
+    /**
+     * Adds a child menu component to this menu bar. Overrides UIComponent.addChild() to validate components being added.
+     *
+     * @param {Object} component - UI Component that can be a child of this component.
+     * @param {...any} [index] - Argument to pass index at which to insert the child. By default component is added to the end.
+     * @returns {this} Returns an instance of `this` component.
+     */
+    addChild(component: Object, ...data: any[]): this;
+}
+import { ComponentContainer } from "./ComponentContainer.js";

package/types/classes/MenuItem.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Menu item UI component that extends UIComponent class.
+ * This class is extended by Menu, CheckBoxMenuItem, and RadioButtonMenuItem.
+ * For more methods and properties for this component or sub-components check UIComponent class.
+ * @class
+ * @global
+ */
+export class MenuItem extends UIComponent {
+    /**
+     * Constructor for Menu, MenuItem, CheckBoxMenuItem, and RadioButtonMenuItem.
+     *
+     * @param {string} [text] - Text displayed in the menu item
+     */
+    constructor(...args: any[]);
+    /**
+     * Sets keyboard shortcut (accelerator) to menu item type of components: MenuItem, CheckBoxMenuItem, RadioButtonMenuItem. See examples below. Allows to activate the menu item action using specified keyboard key combination on keyboard. This shortcut is usually display in the right side of the mnu item's text.
+     *
+     * @param {string} keys - Key combination as a string. See example how to construct it.
+     * @returns String Description of keyboard shortcut
+     * @example
+     * Modifiers: CTRL|CONTROL|SHIFT|ALT|ALTGRAPH|META
+     *
+     * Keys: A-Z|0-9|NUMPAD[0-9]|SPACE|INSERT|ESCAPE|F[1-24]|TAB|ADD|SUBTRACT|DELETE|BACK_SPACE|BACK_SLASH|
+     * BRACELEFT|BRACERIGHT|OPEN_BRACKET|CLOSE_BRACKET|SEMICOLON|COMMA|CAPS_LOCK|BACK_QUOTE|MINUS|PERIOD|
+     * UP|DOWN|RIGHT|LEFT|MULTIPLY|DIVIDE|NUM_LOCK|HOME|END|PAGE_UP|PAGE_DOWN|PAUSE|SCROLL_LOCK|WINDOWS|
+     * CONTEXT_MENU|DECIMAL|ENTER
+     *
+     * Example key combinations: CTRL+Q, ALT+F1, CTRL+SHIFT+5, CTRL+N4, META+SHIFT+6, DELETE+SHIFT, SHIFT+UP, CTRL+OPEN_BRACKET, ATL+DOWN
+     *
+     * menuItem1.accelerator("CTRL+Q");
+     * menuItemUP.accelerator("SHIFT+NUMPAD[8]");
+     *
+     */
+    accelerator(...args: any[]): any;
+    /**
+     * Gets or sets the mnemonic (keyboard shortcut key) for menu item type of components: Menu, MenuItem, CheckBoxMenuItem, RadioButtonMenuItem. It's not same as setting accelerator(...).
+     * A mnemonic allows users to activate the menu item using the keyboard (typically Alt + key).<br />
+     * NOTE: Not all systems and UIs show underline under mnemonic character. Some systems only show it after Alt key was pressed.
+     *
+     * @param {number|string|null} [key] - A key code integer or a single ASCII character representing the mnemonic key (case-insensitive). If omitted, acts as a getter. To clear mnemonic, pass `0`, `""`, or `null`.
+     * @returns {number|MenuItem} If called without arguments, returns the current mnemonic key code integer. If called with an argument, returns `this` instance object for chaining.
+     * @example
+     * menuItem.text("Quit").mnemonic("q"); // Makes letter Q to be used as the keyboard shortcut key
+     * menuItem.mnemonic(""); // clears the mnemonic
+     */
+    mnemonic(...args: any[]): number | MenuItem;
+    /**
+     * Opens this menu item and all of its parent menus or context menu.
+     *
+     * @param {object} [position] - Example: {x: 100, y: 100}. Use only when root ancestor of this item is ContextMenu, to specify position where to position the ContextMenu.
+     *                                     If invoker is specified, then position is relative to position of invoker component, otherwise it's 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 {MenuItem} Returns `this` MenuItem instance.
+     */
+    open(position?: object, invoker?: object): MenuItem;
+}
+import { UIComponent } from "./UIComponent.js";

package/types/classes/Panel.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Panel UI component, rectangular UI component that can be used in many different ways:
+ *  - Container for other components
+ *  - As a horizontal/vertical line or a rectangle
+ *  - Container with scroll bars that can contain objects even outside its boundaries.
+ *  - Background can be set to color, image, and gradient (like in CSS), which opens lots of opportunities, such as animating background, streaming MJPEG video by setting frames as background of the panel sequentially, and more.
+ *  - As a canvas to draw Shapes or create an interactive game using Shapes drawn on this canvas.
+ *
+ *  Panel class extends ComponentContainer and ShapeContainer, which extend UIComponent
+ *
+ *  NOTE: Add Panel to Tabs, SplitView, or ScrollPane containers before adding child components to the panel to have expected behavior when setting anchors to child components of the Panel.
+ *  @class
+ *  @global
+ *  @see ShapeContainer
+ *  @see ComponentContainer
+ */
+export class Panel extends ShapeContainer {
+    _shapes: any[];
+    temp_token: undefined;
+    /**
+     * Sets or gets component opacity float value between 0 and 1 inclusive.
+     *
+     * @param {number} [opacity] - A number between 0 and 1 inclusive.
+     * @return {number|this} If `opacity` argument is provided, `this` component is returned, otherwise opacity `number` is returned.
+     */
+    opacity(...args: any[]): number | this;
+}
+import { ShapeContainer } from "./ShapeContainer.js";

package/types/classes/PasswordField.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Password field is used to type masked text. Use echoChar() method to set a custom mask character.
+ * All other methods are inherited from TextComponent and UIComponent.
+ * @class
+ * @global
+ */
+export class PasswordField extends TextComponent {
+    /**
+     * Sets/Gets a Unicode character to use for masking real characters.
+     *
+     * Some disk characters to try:
+     * const myChar = '\u00B7';
+     * const myChar = '\u2022';
+     * const myChar = '\u25CF';
+     * const myChar = '\u2B24';
+     *
+     * @param {string} [character] - A one character string character. If the string has more than one character, only first one will be used.
+     * @returns {PasswordField|string} Returns an instance of `this` object when setting a value, otherwise current value is returned.
+     */
+    echoChar(...args: any[]): PasswordField | string;
+}
+import { TextComponent } from "./TextComponent.js";

package/types/classes/Polygon.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Polygon is a shape with multiple corners at specified points. Each point is an X and Y coordinate relative to the shapes X and Y position.
+ *
+ * Polygon extends {@link Shape} class.
+ *
+ * @class
+ * @global
+ * @see Shape
+ */
+export class Polygon extends Shape {
+    /**
+     * Creates an instance of Polygon shape object.
+     *
+     * @param {Stroke} [stroke] - A border of the shape.
+     * @param {string|null} [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 {Point[]} [_points=[]] - An array of `Point` objects that represent each corner of the shape [{x:number,y:number}, ...]. For example a simple start has 10 points.
+     */
+    constructor(stroke?: Stroke, background?: string | null, opacity?: number, x?: number, y?: number, _points?: Point[]);
+    _points: any[];
+    /**
+     * Adds a point to the Polygon as a last point or at a specified index.
+     *
+     * @param {Point} point - A {@link Point} formatted object with X and Y coordinates (e.g., {x: 20, y:30});
+     * @param {number} [insertAt=undefined] - If specified, the point will be added at this position; otherwise at the end.
+     * @returns {Polygon} Returns this Polygon shape object for chaining.
+     * @see Point
+     * @example <h2>Adding a point to the end of the points array:</h2>
+     * polygon.addPoint({x:20, y:30});
+     *
+     * @example <h2>Adding a point at a specified index:</h2>
+     * polygon.addPoint({x:30, y:60}, 0); // adds a point the beginning of points array
+     */
+    addPoint(point: Point, insertAt?: number): Polygon;
+    /**
+     * Removes a point from the Polygon at a specified index.
+     *
+     * @param {number} index - Index of the point to return.
+     * @returns {{x:number, y:number}|null} Returns the deleted point or `null` of there was no point at specified index.
+     */
+    removePoint(index: number): {
+        x: number;
+        y: number;
+    } | null;
+    /**
+     * Sets or gets a point of the Polygon {x:number, y:number} at a specified index.
+     *
+     * @param {number} index - Index of the existing point to update.
+     * @param {Point|number} [point_or_x=undefined] - New point object or X coordinate of the new point.
+     * @param {number} [y=undefined] - Y coordinate of the new point.
+     * @returns {Point|null|Polygon} When getting a point, returns a point object or `undefined` when a point at specified index doesn't exist. When setting the point, returns this Polygon or throws an Error.
+     * @see Point
+     * @example <h2>Updating a point at index 3:</h2>
+     * polygon.point(3, 50, 80); // x = 50, y = 80
+     *
+     * // or...
+     *
+     * polygon.point(3, {x:50, y:80});
+     *
+     * @example <h2>Getting a point at index 3:</h2>
+     * let p = polygon.point(3);
+     */
+    point(index: number, point_or_x?: Point | number, y?: number): Point | null | Polygon;
+    /**
+     * Sets an array of new points, or get an array of existing point.
+     *
+     * @param {Point[]} [points] - An array of new point objects [{x:number, y:number}, ...]. Omit to get current point.
+     * @returns {Point[]|Polygon} When called without arguments, returns current points; otherwise returns this Polygon for method chaining.
+     * @see Point
+     * @example <h2>Getting existing points as an Array:</h2>
+     * let _points = polygon.points(); // -> array of objects
+     *
+     * @example <h2>Setting a new array of points:</h2>
+     * polygon.points({
+     *     {x:10, y:10},
+     *     {x:40, y:10},
+     *     {x:60, y:60},
+     *     {x:30, y:60},
+     *     {x:10, y:10}
+     * });
+     */
+    points(...args: any[]): Point[] | Polygon;
+    /**
+     * 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";