@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.1

package/node_modules/@playcanvas/pcui/types/components/Menu/index.d.ts

@@ -0,0 +1,70 @@
+import { Container, ContainerArgs } from '../Container';
+import { Element, IFocusable } from '../Element';
+import { MenuItem, MenuItemArgs } from '../MenuItem';
+/**
+ * The arguments for the {@link Menu} constructor.
+ */
+interface MenuArgs extends ContainerArgs {
+    /**
+     * An array of {@link MenuItemArgs}. If these are passed then new MenuItems will be created
+     * and appended to the menu.
+     */
+    items?: MenuItemArgs[];
+    /**
+     * Sets whether this {@link Menu} is hidden. Defaults to `true`.
+     */
+    hidden?: boolean;
+    /**
+     * Sets the tabIndex of the {@link Menu}. Defaults to 1.
+     */
+    tabIndex?: number;
+}
+/**
+ * A Menu is a list of {@link MenuItem}s which can contain child MenuItems. Useful to show context
+ * menus and nested menus. Note that a Menu must be appended to the root Element and then
+ * positioned accordingly.
+ */
+declare class Menu extends Container implements IFocusable {
+    protected _containerMenuItems: Container;
+    /**
+     * Creates a new Menu.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<MenuArgs>);
+    destroy(): void;
+    protected _onAppendChild(element: Element): void;
+    protected _onRemoveChild(element: Element): void;
+    protected _onClickMenu: (evt: MouseEvent) => void;
+    protected _onFocus: (evt: FocusEvent) => void;
+    protected _onBlur: (evt: FocusEvent) => void;
+    protected _filterMenuItems(item: MenuItem): void;
+    protected _onShowMenu(): void;
+    protected _onKeyDown: (evt: KeyboardEvent) => void;
+    protected _limitSubmenuAtScreenEdges(item: MenuItem): void;
+    focus(): void;
+    blur(): void;
+    /**
+     * Positions the top-left corner of the menu at the specified coordinates.
+     *
+     * @param x - The x coordinate.
+     * @param y - The y coordinate.
+     * @example
+     * ```ts
+     * // open a context menu at the mouse position
+     * window.addEventListener('contextmenu', (event) => {
+     *     event.stopPropagation();
+     *     event.preventDefault();
+     *
+     *     menu.hidden = false;
+     *     menu.position(event.clientX, event.clientY);
+     * });
+     * ```
+     */
+    position(x: number, y: number): void;
+    /**
+     * Remove all the current menu items from the menu.
+     */
+    clear(): void;
+}
+export { Menu, MenuArgs };

package/node_modules/@playcanvas/pcui/types/components/MenuItem/index.d.ts

@@ -0,0 +1,139 @@
+import { Observer } from '@playcanvas/observer';
+import { Container, ContainerArgs } from '../Container';
+import { Element, IBindable } from '../Element';
+import { Label } from '../Label';
+/**
+ * The arguments for the {@link MenuItem} constructor.
+ */
+interface MenuItemArgs extends ContainerArgs {
+    value?: any;
+    /**
+     * Whether the MenuItem has any child MenuItems.
+     */
+    hasChildren?: boolean;
+    /**
+     * Sets the text shown on the MenuItem.
+     */
+    text?: string;
+    /**
+     * Sets the CSS code for an icon for the MenuItem. e.g. 'E401' (notice we omit the '\\' character).
+     */
+    icon?: string;
+    /**
+     * Sets the parent Menu Element.
+     */
+    menu?: any;
+    /**
+     * Sets the function called when we select the MenuItem.
+     */
+    onSelect?: (evt?: MouseEvent) => void;
+    /**
+     * Sets the function that determines whether the MenuItem should be enabled when the Menu is shown.
+     */
+    onIsEnabled?: () => boolean;
+    /**
+     * Sets the function that determines whether the MenuItem should be visible when the Menu is shown.
+     */
+    onIsVisible?: () => boolean;
+    /**
+     * An array of MenuItem constructor data. If defined then child MenuItems will be created and added to the MenuItem.
+     */
+    items?: Array<MenuItemArgs>;
+    /**
+     * Sets the keyboard shortcut to display on the MenuItem (e.g., 'Ctrl+C').
+     */
+    shortcut?: string;
+}
+/**
+ * The MenuItem is a selectable option that is appended to a {@link Menu}. A MenuItem can also
+ * contain child MenuItems (by appending them to the MenuItem). This can be useful to show nested
+ * Menus.
+ */
+declare class MenuItem extends Container implements IBindable {
+    /**
+     * The function called when the MenuItem is selected.
+     */
+    onSelect: (evt?: MouseEvent) => void;
+    /**
+     * The function that determines whether the MenuItem should be enabled when the Menu is shown.
+     */
+    onIsEnabled: () => boolean;
+    /**
+     * The function that determines whether the MenuItem should be visible when the Menu is shown.
+     */
+    onIsVisible: () => boolean;
+    protected _containerContent: Container;
+    protected _numChildren: number;
+    protected _icon: string;
+    protected _labelText: Label;
+    protected _labelShortcut: Label;
+    protected _containerItems: Container;
+    protected _menu: any;
+    protected _renderChanges: boolean;
+    /**
+     * Creates a new MenuItem.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<MenuItemArgs>);
+    destroy(): void;
+    protected _onAppendChild(element: Element): void;
+    protected _onRemoveChild(element: Element): void;
+    protected _onClickMenuItem: (evt: MouseEvent) => void;
+    link(observers: Observer | Observer[], paths: string | string[]): void;
+    unlink(): void;
+    /**
+     * Selects the MenuItem which also happens automatically when the user clicks on the MenuItem.
+     */
+    select(): void;
+    /**
+     * Sets the text shown on the MenuItem.
+     */
+    set text(value: string);
+    /**
+     * Gets the text shown on the MenuItem.
+     */
+    get text(): string;
+    set value(value: string);
+    get value(): string;
+    set values(values: string[]);
+    /**
+     * Sets the CSS code for an icon for the MenuItem. e.g. 'E401' (notice we omit the '\\' character).
+     */
+    set icon(value: string);
+    /**
+     * Gets the CSS code for an icon for the MenuItem.
+     */
+    get icon(): string;
+    /**
+     * Sets the keyboard shortcut displayed on the MenuItem.
+     */
+    set shortcut(value: string);
+    /**
+     * Gets the keyboard shortcut displayed on the MenuItem.
+     */
+    get shortcut(): string;
+    /**
+     * Sets the binding for the MenuItem label.
+     */
+    set binding(value: import("../..").BindingBase);
+    /**
+     * Gets the binding for the MenuItem label.
+     */
+    get binding(): import("../..").BindingBase;
+    /**
+     * Sets the menu.
+     */
+    set menu(value: any);
+    /**
+     * Gets the menu.
+     */
+    get menu(): any;
+    /**
+     * Returns whether the MenuItem has children.
+     */
+    get hasChildren(): boolean;
+    set renderChanges(value: boolean);
+    get renderChanges(): boolean;
+}
+export { MenuItem, MenuItemArgs };

package/node_modules/@playcanvas/pcui/types/components/NumericInput/index.d.ts

@@ -0,0 +1,173 @@
+import { Element } from '../Element';
+import { InputElement, InputElementArgs } from '../InputElement';
+/**
+ * The arguments for the {@link NumericInput} constructor.
+ */
+interface NumericInputArgs extends InputElementArgs {
+    /**
+     * Sets the minimum value this field can take.
+     */
+    min?: number;
+    /**
+     * Sets the maximum value this field can take.
+     */
+    max?: number;
+    /**
+     * Sets the decimal precision of this field. Defaults to 7.
+     */
+    precision?: number;
+    /**
+     * Sets the amount that the value will be increased or decreased when using the arrow keys and
+     * the slider input.
+     */
+    step?: number;
+    /**
+     * Sets the amount that the value will be increased or decreased when holding shift using the
+     * arrow keys and the slider input. Defaults to {@link NumericInput#step} * 0.1.
+     */
+    stepPrecision?: number;
+    /**
+     * Hide the input mouse drag slider.
+     */
+    hideSlider?: boolean;
+    /**
+     * Sets whether the value can be `null`. If not then it will be 0 instead of `null`.
+     */
+    allowNull?: boolean;
+}
+/**
+ * The NumericInput represents an input element that holds numbers.
+ *
+ * NumericInput accepts `number` values. It also accepts strings that contain mathematical
+ * expressions which are then evaluated to a number. Here are some examples:
+ *
+ * | Input String       | Evaluated Number Value |
+ * | ------------------ | ---------------------- |
+ * | `"10 + 20"`        | `30`                   |
+ * | `"10 - 20"`        | `-10`                  |
+ * | `"10 * 20"`        | `200`                  |
+ * | `"10 / 20"`        | `0.5`                  |
+ * | `"10 * (20 + 30)"` | `500`                  |
+ *
+ * By default, a NumericInput displays a slider input that can be used to quickly change the value
+ * via a click and drag. The slider can be disabled by setting the `hideSlider` argument to `true`.
+ */
+declare class NumericInput extends InputElement {
+    /**
+     * Fired when the value of the NumericInput changes.
+     *
+     * @event
+     * @example
+     * ```ts
+     * const numericInput = new NumericInput();
+     * numericInput.on('change', (value: number) => {
+     *     console.log('Value changed to:', value);
+     * });
+     * ```
+     */
+    static readonly EVENT_CHANGE = "change";
+    /**
+     * Fired when the user starts dragging the slider.
+     *
+     * @event
+     * @example
+     * ```ts
+     * const numericInput = new NumericInput();
+     * numericInput.on('slider:mousedown', (evt: MouseEvent) => {
+     *     console.log('Slider drag started');
+     * });
+     * ```
+     */
+    static readonly EVENT_SLIDER_MOUSEDOWN = "slider:mousedown";
+    /**
+     * Fired when the user stops dragging the slider.
+     *
+     * @event
+     * @example
+     * ```ts
+     * const numericInput = new NumericInput();
+     * numericInput.on('slider:mouseup', () => {
+     *     console.log('Slider drag ended');
+     * });
+     * ```
+     */
+    static readonly EVENT_SLIDER_MOUSEUP = "slider:mouseup";
+    protected _min: number;
+    protected _max: number;
+    protected _allowNull: boolean;
+    protected _precision: number;
+    protected _step: number;
+    protected _stepPrecision: number;
+    protected _oldValue: number;
+    protected _historyCombine: boolean;
+    protected _historyPostfix: string;
+    protected _sliderPrevValue: number;
+    protected _sliderControl: Element;
+    protected _sliderMovement: number;
+    protected _sliderUsed: boolean;
+    /**
+     * Creates a new NumericInput.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<NumericInputArgs>);
+    destroy(): void;
+    protected _updatePosition(movement: number, shiftKey: boolean): void;
+    protected _onSliderMouseWheel: (evt: WheelEvent) => void;
+    protected _onSliderMouseMove: (evt: MouseEvent) => void;
+    protected _onSliderMouseDown: (evt: MouseEvent) => void;
+    protected _onSliderMouseUp: () => void;
+    protected _onInputChange(evt: Event): void;
+    protected _onInputKeyDown(evt: KeyboardEvent): void;
+    protected _getPointerLockElementByShadowRoot(pointerLockElement: any): boolean;
+    protected _isScrolling(): boolean;
+    protected _onPointerLockChange: () => void;
+    protected _normalizeValue(value: any): any;
+    protected _updateValue(value: number, force?: boolean): boolean;
+    /**
+     * Sets the value of the NumericInput.
+     */
+    set value(value: number);
+    /**
+     * Gets the value of the NumericInput.
+     */
+    get value(): number;
+    /**
+     * Sets multiple values on the input. If all values are the same, the input will display that
+     * value. Otherwise, it will be empty and display a "multiple values" state.
+     */
+    set values(values: number[]);
+    /**
+     * Sets the minimum value this field can take.
+     */
+    set min(value: number);
+    /**
+     * Gets the minimum value this field can take.
+     */
+    get min(): number;
+    /**
+     * Sets the maximum value this field can take.
+     */
+    set max(value: number);
+    /**
+     * Gets the maximum value this field can take.
+     */
+    get max(): number;
+    /**
+     * Sets the precision of the input.
+     */
+    set precision(value: number);
+    /**
+     * Gets the precision of the input.
+     */
+    get precision(): number;
+    /**
+     * Sets the amount that the value will be increased or decreased when using the arrow keys and the slider input.
+     */
+    set step(value: number);
+    /**
+     * Gets the amount that the value will be increased or decreased when using the arrow keys and the slider input.
+     */
+    get step(): number;
+}
+export { NumericInput, NumericInputArgs };

package/node_modules/@playcanvas/pcui/types/components/Overlay/index.d.ts

@@ -0,0 +1,53 @@
+import { Container } from '../Container';
+import { ElementArgs } from '../Element';
+/**
+ * The arguments for the {@link Overlay} constructor.
+ */
+interface OverlayArgs extends ElementArgs {
+    /**
+     * Whether the overlay can be hidden by clicking on it.
+     */
+    clickable?: boolean;
+    /**
+     * Whether the overlay is transparent or not.
+     */
+    transparent?: boolean;
+}
+/**
+ * An overlay element.
+ */
+declare class Overlay extends Container {
+    protected _domClickableOverlay: HTMLDivElement;
+    /**
+     * Creates a new Overlay.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<OverlayArgs>);
+    destroy(): void;
+    protected _onPointerDown: (evt: PointerEvent) => void;
+    /**
+     * Position the overlay at specific x, y coordinates.
+     *
+     * @param x - The x coordinate.
+     * @param y - The y coordinate.
+     */
+    position(x: number, y: number): void;
+    /**
+     * Sets whether the overlay can be hidden by clicking on it.
+     */
+    set clickable(value: boolean);
+    /**
+     * Gets whether the overlay can be hidden by clicking on it.
+     */
+    get clickable(): boolean;
+    /**
+     * Sets whether the overlay is transparent or not.
+     */
+    set transparent(value: boolean);
+    /**
+     * Gets whether the overlay is transparent or not.
+     */
+    get transparent(): boolean;
+}
+export { Overlay, OverlayArgs };

package/node_modules/@playcanvas/pcui/types/components/Panel/index.d.ts

@@ -0,0 +1,178 @@
+import { Button } from '../Button';
+import { Container, ContainerArgs } from '../Container';
+import { Label } from '../Label';
+/**
+ * The arguments for the {@link Panel} constructor.
+ */
+interface PanelArgs extends ContainerArgs {
+    /**
+     * Sets whether the Element is collapsible.
+     */
+    collapsible?: boolean;
+    /**
+     * Sets whether the Element should be collapsed.
+     */
+    collapsed?: boolean;
+    /**
+     * Sets whether the panel can be reordered.
+     */
+    sortable?: boolean;
+    /**
+     * Sets whether the panel collapses horizontally - this would be the case for side panels. Defaults to `false`.
+     */
+    collapseHorizontally?: boolean;
+    /**
+     * Sets whether the panel can be removed.
+     */
+    removable?: boolean;
+    /**
+     * The height of the header in pixels. Defaults to 32.
+     */
+    headerSize?: number;
+    /**
+     * The header text of the panel. Defaults to the empty string.
+     */
+    headerText?: string;
+    /**
+     * Sets the panel type.
+     */
+    panelType?: 'normal';
+    /**
+     * A DOM element to use for the content container.
+     */
+    content?: HTMLElement;
+    /**
+     * A DOM element to use for the header container.
+     */
+    header?: HTMLElement;
+}
+/**
+ * The Panel is a {@link Container} that itself contains a header container and a content
+ * container. The respective Container functions work using the content container. One can also
+ * append elements to the header of the Panel.
+ */
+declare class Panel extends Container {
+    /**
+     * Fired when the panel gets collapsed.
+     *
+     * @event
+     * @example
+     * ```ts
+     * const panel = new Panel();
+     * panel.on('collapse', () => {
+     *     console.log('Panel collapsed');
+     * });
+     * ```
+     */
+    static readonly EVENT_COLLAPSE = "collapse";
+    /**
+     * Fired when the panel gets expanded.
+     *
+     * @event
+     * @example
+     * ```ts
+     * const panel = new Panel();
+     * panel.on('expand', () => {
+     *     console.log('Panel expanded');
+     * });
+     * ```
+     */
+    static readonly EVENT_EXPAND = "expand";
+    protected _suspendReflow: boolean;
+    protected _reflowTimeout: number;
+    protected _widthBeforeCollapse: string;
+    protected _heightBeforeCollapse: string;
+    protected _iconSort: Label;
+    protected _btnRemove: Button;
+    protected _containerContent: Container;
+    protected _containerHeader: Container;
+    protected _labelTitle: Label;
+    protected _collapsible: boolean;
+    protected _collapseHorizontally: boolean;
+    protected _draggedChild: this;
+    protected _collapsed: boolean;
+    protected _sortable: boolean;
+    protected _headerSize: number;
+    protected _onDragEndEvt: (event: MouseEvent) => void;
+    /**
+     * Creates a new Panel.
+     *
+     * @param args - The arguments. Extends the Container constructor arguments. All settable
+     * properties can also be set through the constructor.
+     */
+    constructor(args?: Readonly<PanelArgs>);
+    destroy(): void;
+    protected _initializeHeader(args: PanelArgs): void;
+    protected _onHeaderClick: (evt: MouseEvent) => void;
+    protected _onClickRemove(evt: MouseEvent): void;
+    protected _initializeContent(args: PanelArgs): void;
+    protected _reflow(): void;
+    protected _onDragStart: (evt: MouseEvent) => void;
+    protected _onDragMove: (evt: MouseEvent) => void;
+    protected _onDragEnd(evt: MouseEvent): void;
+    /**
+     * Sets whether the Element is collapsible.
+     */
+    set collapsible(value: boolean);
+    /**
+     * Gets whether the Element is collapsible.
+     */
+    get collapsible(): boolean;
+    /**
+     * Sets whether the Element should be collapsed.
+     */
+    set collapsed(value: boolean);
+    /**
+     * Gets whether the Element should be collapsed.
+     */
+    get collapsed(): boolean;
+    /**
+     * Sets whether the panel can be reordered.
+     */
+    set sortable(value: boolean);
+    /**
+     * Gets whether the panel can be reordered.
+     */
+    get sortable(): boolean;
+    /**
+     * Sets whether the panel can be removed
+     */
+    set removable(value: boolean);
+    /**
+     * Gets whether the panel can be removed
+     */
+    get removable(): boolean;
+    /**
+     * Sets whether the panel collapses horizontally. This would be the case for side panels. Defaults to `false`.
+     */
+    set collapseHorizontally(value: boolean);
+    /**
+     * Gets whether the panel collapses horizontally.
+     */
+    get collapseHorizontally(): boolean;
+    /**
+     * Gets the content container.
+     */
+    get content(): Container;
+    /**
+     * Gets the header container.
+     */
+    get header(): Container;
+    /**
+     * Sets the header text of the panel. Defaults to the empty string.
+     */
+    set headerText(value: string);
+    /**
+     * Gets the header text of the panel.
+     */
+    get headerText(): string;
+    /**
+     * Sets the height of the header in pixels. Defaults to 32.
+     */
+    set headerSize(value: number);
+    /**
+     * Gets the height of the header in pixels.
+     */
+    get headerSize(): number;
+}
+export { Panel, PanelArgs };

package/node_modules/@playcanvas/pcui/types/components/Progress/index.d.ts

@@ -0,0 +1,33 @@
+import { Container, ContainerArgs } from '../Container';
+import { Element } from '../Element';
+/**
+ * The arguments for the {@link Progress} constructor.
+ */
+interface ProgressArgs extends ContainerArgs {
+    /**
+     * Sets the value of the progress bar (between 0 and 100).
+     */
+    value?: number;
+}
+/**
+ * Represents a bar that can highlight progress of an activity.
+ */
+declare class Progress extends Container {
+    protected _inner: Element;
+    protected _value: number;
+    /**
+     * Creates a new Progress.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<ProgressArgs>);
+    /**
+     * Sets the value of the progress bar. The range is from 0 to 100.
+     */
+    set value(val: number);
+    /**
+     * Gets the value of the progress bar.
+     */
+    get value(): number;
+}
+export { Progress, ProgressArgs };

package/node_modules/@playcanvas/pcui/types/components/RadioButton/index.d.ts

@@ -0,0 +1,33 @@
+import { Element, ElementArgs, IBindable, IBindableArgs, IFocusable } from '../Element';
+/**
+ * The arguments for the {@link RadioButton} constructor.
+ */
+interface RadioButtonArgs extends ElementArgs, IBindableArgs {
+}
+/**
+ * A radio button element.
+ */
+declare class RadioButton extends Element implements IBindable, IFocusable {
+    protected _value: boolean;
+    protected _renderChanges: boolean;
+    /**
+     * Creates a new RadioButton.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<RadioButtonArgs>);
+    destroy(): void;
+    protected _onClick(evt: MouseEvent): void;
+    protected _onKeyDown: (evt: KeyboardEvent) => void;
+    protected _onFocus: (evt: FocusEvent) => void;
+    protected _onBlur: (evt: FocusEvent) => void;
+    protected _updateValue(value: boolean): boolean;
+    focus(): void;
+    blur(): void;
+    set value(value: boolean);
+    get value(): boolean;
+    set values(values: boolean[]);
+    set renderChanges(renderChanges: boolean);
+    get renderChanges(): boolean;
+}
+export { RadioButton, RadioButtonArgs };