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

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

@@ -0,0 +1,152 @@
+import { Canvas } from '../Canvas';
+import { Element, ElementArgs } from '../Element';
+import { NumericInput } from '../NumericInput';
+import { Panel } from '../Panel';
+import { TextInput } from '../TextInput';
+/**
+ * The arguments for the {@link GradientPicker} constructor.
+ */
+interface GradientPickerArgs extends ElementArgs {
+    /**
+     * If `true`, the picker will render changes to the gradient as they happen. Defaults to `true`.
+     */
+    renderChanges?: boolean;
+    /**
+     * An array of 4 integers containing the RGBA values the picker should be initialized to.
+     */
+    value?: number[];
+    /**
+     * Number of color channels. Defaults to 3. Changing to 4 adds the option to change the alpha value.
+     */
+    channels?: number;
+}
+/**
+ * Represents a gradient picker.
+ */
+declare class GradientPicker extends Element {
+    protected _canvas: Canvas;
+    protected _checkerboardPattern: CanvasPattern;
+    protected _resizeInterval: number;
+    protected _panel: Panel;
+    protected _colorRect: Canvas;
+    protected _colorHandle: HTMLDivElement;
+    protected _hueRect: Canvas;
+    protected _hueHandle: HTMLDivElement;
+    protected _alphaRect: Canvas;
+    protected _alphaHandle: HTMLDivElement;
+    protected _fields: HTMLDivElement;
+    protected _rField: NumericInput;
+    protected _gField: NumericInput;
+    protected _bField: NumericInput;
+    protected _aField: NumericInput;
+    protected _hexField: TextInput;
+    protected _hsva: number[];
+    protected _storeHsva: number[];
+    protected _dragMode: number;
+    protected _changing: boolean;
+    protected _copiedData: any;
+    protected _channels: number;
+    protected _value: {
+        type: number;
+        keys: any[];
+        betweenCurves: boolean;
+    };
+    protected _evtPickerChanged: any;
+    protected _evtRefreshPicker: any;
+    protected renderChanges: boolean;
+    protected Helpers: any;
+    protected CONSTANTS: any;
+    protected UI: any;
+    protected STATE: any;
+    protected fieldChangeHandler: (evt: Event) => void;
+    protected hexChangeHandler: (evt: Event) => void;
+    protected downHandler: (evt: MouseEvent) => void;
+    protected moveHandler: (evt: MouseEvent) => void;
+    protected upHandler: (evt: MouseEvent) => void;
+    /**
+     * Creates a new GradientPicker.
+     *
+     * @param args - The arguments. Extends the Element arguments. Any settable property can also
+     * be set through the constructor.
+     */
+    constructor(args?: Readonly<GradientPickerArgs>);
+    destroy(): void;
+    protected _createCheckerboardPattern(context: CanvasRenderingContext2D): CanvasPattern;
+    protected _onKeyDown: (evt: KeyboardEvent) => void;
+    protected _onFocus: (evt: FocusEvent) => void;
+    protected _onBlur: (evt: FocusEvent) => void;
+    protected _getDefaultValue(): {
+        type: number;
+        keys: any[];
+        betweenCurves: boolean;
+    };
+    protected _openGradientPicker(): void;
+    protected _onPickerChange(paths: string[], values: any[]): void;
+    protected _renderGradient(): void;
+    focus(): void;
+    blur(): void;
+    set channels(value: number);
+    get channels(): number;
+    set value(value: {
+        type: number;
+        keys: any[];
+        betweenCurves: boolean;
+    });
+    get value(): {
+        type: number;
+        keys: any[];
+        betweenCurves: boolean;
+    };
+    set values(values: any);
+    protected _generateHue(canvas: Canvas): void;
+    protected _generateAlpha(canvas: Canvas): void;
+    protected _generateGradient(canvas: Canvas, clr: number[]): void;
+    protected _onFieldChanged(): void;
+    protected _onHexChanged(): void;
+    protected _onMouseDown(evt: MouseEvent): void;
+    protected _onMouseMove(evt: MouseEvent): void;
+    protected _onMouseUp(evt: MouseEvent): void;
+    set hsva(hsva: number[]);
+    get hsva(): number[];
+    set color(clr: any);
+    get color(): any;
+    set editAlpha(editAlpha: any);
+    get editAlpha(): any;
+    open(): void;
+    close(): void;
+    onOpen(): void;
+    onClose(): void;
+    onDeleteKey(): void;
+    protected _onTypeChanged(value: number): void;
+    render(): void;
+    renderGradient(): void;
+    renderAnchors(): void;
+    renderAnchor(ctx: CanvasRenderingContext2D, time: number, type?: string): void;
+    evaluateGradient(time: number, alphaOverride?: number): any;
+    calcAnchorTimes(): any;
+    calcNormalizedCoord(x: number, y: number, rect: DOMRect): number[];
+    getClientRect(element: HTMLElement): DOMRect;
+    protected _onAnchorsMouseDown: (e: MouseEvent) => void;
+    protected _onAnchorsMouseMove: (e: MouseEvent) => void;
+    protected _onAnchorsMouseUp: (evt: MouseEvent) => void;
+    selectHovered(index: number): void;
+    selectAnchor(index: number): void;
+    dragStart(): void;
+    dragUpdate(time: number): void;
+    dragEnd(): void;
+    insertAnchor(time: number, color: any[]): void;
+    deleteAnchor(time: number): void;
+    moveSelectedAnchor(time: number): void;
+    colorSelectedAnchor(clr: number[], dragging?: boolean): void;
+    emitCurveChange(): void;
+    doCopy(): void;
+    doPaste(): void;
+    doDelete(): void;
+    createCheckerPattern(): CanvasPattern;
+    setValue(value: any, args?: any): void;
+    callOpenGradientPicker(value: any, args?: any): void;
+    getGradientPickerRect(): any;
+    positionGradientPicker(x: number, y: number): void;
+    setGradientPicker(value: any, args?: any): void;
+}
+export { GradientPicker, GradientPickerArgs };

package/node_modules/@playcanvas/pcui/react/types/components/GridView/component.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { Element } from '../Element/component';
+import { GridView as GridViewClass, GridViewArgs } from './index';
+/**
+ * Represents a container that shows a flexible wrappable list of items that looks like a grid.
+ * Contains GridViewItems.
+ */
+declare class GridView extends Element<GridViewArgs, any> {
+    static ctor: typeof GridViewClass;
+    constructor(props: GridViewArgs);
+    loadChildren(children: any, element: any): void;
+    render(): React.JSX.Element;
+}
+export { GridView };

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

@@ -0,0 +1,103 @@
+import { Container, ContainerArgs } from '../Container';
+import { GridViewItem } from '../GridViewItem';
+/**
+ * The arguments for the {@link GridView} constructor.
+ */
+interface GridViewArgs extends ContainerArgs {
+    /**
+     * If `true` the {@link GridView} layout will be vertical.
+     */
+    vertical?: boolean;
+    /**
+     * If `true`, the layout will allow for multiple options to be selected. Defaults to `true`.
+     */
+    multiSelect?: boolean;
+    /**
+     * If `true` and `multiSelect` is set to `false`, the layout will allow options to be deselected. Defaults to `true`.
+     */
+    allowDeselect?: boolean;
+    /**
+     * A filter function to filter {@link GridViewItem}s with signature `(GridViewItem) => boolean`.
+     */
+    filterFn?: (item: GridViewItem) => boolean;
+}
+/**
+ * Represents a container that shows a flexible wrappable list of items that looks like a grid.
+ * Contains {@link GridViewItem}s.
+ */
+declare class GridView extends Container {
+    /**
+     * Fired when user activates a {@link GridViewItem} by pressing Enter or double-clicking.
+     *
+     * @event
+     * @example
+     * ```ts
+     * const gridView = new GridView();
+     * gridView.on('activate', (item: GridViewItem) => {
+     *     console.log(`Activated item ${item.text}`);
+     * });
+     * ```
+     */
+    static readonly EVENT_ACTIVATE = "activate";
+    protected _vertical: boolean;
+    protected _clickFn: (evt: MouseEvent, item: GridViewItem) => void;
+    protected _filterFn: (item: GridViewItem) => boolean;
+    protected _filterAnimationFrame: number;
+    protected _filterCanceled: boolean;
+    protected _multiSelect: boolean;
+    protected _allowDeselect: boolean;
+    protected _selected: GridViewItem[];
+    protected _activeItem: GridViewItem;
+    /**
+     * Creates a new GridView.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<GridViewArgs>);
+    protected _onFocusIn: (evt: FocusEvent) => void;
+    protected _setActiveItem(item: GridViewItem | null): void;
+    protected _onAppendGridViewItem(item: GridViewItem): void;
+    protected _onRemoveGridViewItem(item: GridViewItem): void;
+    protected _onClickItem(evt: MouseEvent, item: GridViewItem): void;
+    protected _onSelectItem(item: GridViewItem): void;
+    protected _onDeselectItem(item: GridViewItem): void;
+    protected _onKeyDown: (evt: KeyboardEvent) => void;
+    protected _onDblClick: (evt: MouseEvent) => void;
+    protected _selectSingleItem(item: GridViewItem): void;
+    protected _findItemInAdjacentRow(item: GridViewItem, direction: number): GridViewItem | null;
+    protected _validateActiveItem(): void;
+    /**
+     * Deselects all selected grid view items.
+     */
+    deselect(): void;
+    /**
+     * Filters grid view items with the filter function provided in the constructor.
+     */
+    filter(): void;
+    /**
+     * Filters grid view items asynchronously by only allowing up to the specified number of grid
+     * view item operations. Fires the following events:
+     *
+     * - filter:start - When filtering starts.
+     * - filter:end - When filtering ends.
+     * - filter:delay - When an animation frame is requested to process another batch.
+     * - filter:cancel - When filtering is canceled.
+     *
+     * @param batchLimit - The maximum number of items to show before requesting another animation frame.
+     */
+    filterAsync(batchLimit?: number): void;
+    /**
+     * Cancels asynchronous filtering.
+     */
+    filterAsyncCancel(): void;
+    destroy(): void;
+    /**
+     * Gets the selected GridViewItems.
+     */
+    get selected(): GridViewItem[];
+    /**
+     * Gets whether the grid layout is vertical or not.
+     */
+    get vertical(): boolean;
+}
+export { GridView, GridViewArgs };

package/node_modules/@playcanvas/pcui/react/types/components/GridViewItem/component.d.ts

@@ -0,0 +1,9 @@
+import { Element } from '../Element/component';
+import { GridViewItem as GridViewItemClass, GridViewItemArgs } from './index';
+/**
+ * Represents a grid view item used in GridView.
+ */
+declare class GridViewItem extends Element<GridViewItemArgs, any> {
+    static ctor: typeof GridViewItemClass;
+}
+export { GridViewItem };

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

@@ -0,0 +1,82 @@
+import { Observer } from '@playcanvas/observer';
+import { Container, ContainerArgs } from '../Container';
+import { IFocusable } from '../Element';
+import { Label } from '../Label';
+import { RadioButton } from '../RadioButton';
+/**
+ * The arguments for the {@link GridViewItem} constructor.
+ */
+interface GridViewItemArgs extends ContainerArgs {
+    /**
+     * The type of the {@link GridViewItem}. Can be `null` or 'radio'.
+     */
+    type?: string;
+    /**
+     * If `true`, allow selecting the item. Defaults to `true`.
+     */
+    allowSelect?: boolean;
+    /**
+     * Whether the item is selected.
+     */
+    selected?: boolean;
+    /**
+     * The text of the item. Defaults to ''.
+     */
+    text?: string;
+    /**
+     * Sets the tabIndex of the {@link GridViewItem}. Defaults to 0.
+     */
+    tabIndex?: number;
+}
+/**
+ *  Represents a grid view item used in {@link GridView}.
+ */
+declare class GridViewItem extends Container implements IFocusable {
+    /**
+     * Determines whether the item can be selected. Defaults to `true`.
+     */
+    allowSelect: boolean;
+    protected _selected: boolean;
+    protected _radioButton: RadioButton;
+    protected _labelText: Label;
+    protected _type: string;
+    /**
+     * Creates a new GridViewItem.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<GridViewItemArgs>);
+    destroy(): void;
+    protected _onRadioButtonClick: () => void;
+    protected _onFocus: () => void;
+    protected _onBlur: () => void;
+    focus(): void;
+    blur(): void;
+    link(observers: Observer | Observer[], paths: string | string[]): void;
+    unlink(): void;
+    /**
+     * Sets whether the item is selected.
+     */
+    set selected(value: boolean);
+    /**
+     * Gets whether the item is selected.
+     */
+    get selected(): boolean;
+    /**
+     * Sets the text of the item.
+     */
+    set text(value: string);
+    /**
+     * Gets the text of the item.
+     */
+    get text(): string;
+    /**
+     * Gets the next visible sibling grid view item.
+     */
+    get nextSibling(): GridViewItem;
+    /**
+     * Gets the previous visible sibling grid view item.
+     */
+    get previousSibling(): GridViewItem;
+}
+export { GridViewItem, GridViewItemArgs };

package/node_modules/@playcanvas/pcui/react/types/components/InfoBox/component.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Element } from '../Element/component';
+import { InfoBox as InfoBoxClass, InfoBoxArgs } from './index';
+/**
+ * Represents an information box.
+ */
+declare class InfoBox extends Element<InfoBoxArgs, any> {
+    static ctor: typeof InfoBoxClass;
+    render(): React.JSX.Element;
+}
+export { InfoBox };

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

@@ -0,0 +1,71 @@
+import { Container, ContainerArgs } from '../Container';
+import { Element } from '../Element';
+/**
+ * The arguments for the {@link InfoBox} constructor.
+ */
+interface InfoBoxArgs extends ContainerArgs {
+    /**
+     * The CSS code for an icon for the {@link InfoBox}. e.g. 'E401' (notice we omit the '\\' character). Defaults to ''.
+     * Useful icon values for InfoBox are:
+     *
+     * - 'E218' - warning
+     * - 'E400' - info
+     */
+    icon?: string;
+    /**
+     * Sets the 'title' of the {@link InfoBox}. Defaults to ''.
+     */
+    title?: string;
+    /**
+     * Sets the 'text' of the {@link InfoBox}. Defaults to ''.
+     */
+    text?: string;
+    /**
+     * If `true`, the {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML innerHTML} property will be
+     * used to set the text. Otherwise, {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent textContent}
+     * will be used instead. Defaults to `false`.
+     */
+    unsafe?: boolean;
+}
+/**
+ * Represents an information box.
+ */
+declare class InfoBox extends Container {
+    protected _titleElement: Element;
+    protected _textElement: Element;
+    protected _unsafe: boolean;
+    protected _icon: string;
+    protected _title: string;
+    protected _text: string;
+    /**
+     * Creates a new InfoBox.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<InfoBoxArgs>);
+    /**
+     * Sets the icon of the info box.
+     */
+    set icon(value: string);
+    /**
+     * Gets the icon of the info box.
+     */
+    get icon(): string;
+    /**
+     * Sets the title of the info box.
+     */
+    set title(value: string);
+    /**
+     * Gets the title of the info box.
+     */
+    get title(): string;
+    /**
+     * Sets the text of the info box.
+     */
+    set text(value: string);
+    /**
+     * Gets the text of the info box.
+     */
+    get text(): string;
+}
+export { InfoBox, InfoBoxArgs };

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

@@ -0,0 +1,84 @@
+import { Element, ElementArgs, IBindable, IBindableArgs, IFocusable, IPlaceholder, IPlaceholderArgs } from '../Element';
+/**
+ * The arguments for the {@link InputElement} constructor.
+ */
+interface InputElementArgs extends ElementArgs, IBindableArgs, IPlaceholderArgs {
+    /**
+     * Sets whether pressing Enter will blur (unfocus) the field. Defaults to `true`.
+     */
+    blurOnEnter?: boolean;
+    /**
+     * Sets whether pressing Escape will blur (unfocus) the field. Defaults to `true`.
+     */
+    blurOnEscape?: boolean;
+    /**
+     * Sets whether any key up event will cause a change event to be fired.
+     */
+    keyChange?: boolean;
+    /**
+     * The input element to associate this {@link InputElement} with. If not supplied one will be created instead.
+     */
+    input?: HTMLInputElement;
+}
+/**
+ * The InputElement is an abstract class that manages an input DOM element. It is the superclass of
+ * {@link TextInput} and {@link NumericInput}. It is not intended to be used directly.
+ */
+declare abstract class InputElement extends Element implements IBindable, IFocusable, IPlaceholder {
+    /**
+     * Determines whether the input should blur when the enter key is pressed.
+     */
+    blurOnEnter: boolean;
+    /**
+     * Determines whether the input should blur when the escape key is pressed.
+     */
+    blurOnEscape: boolean;
+    protected _domInput: HTMLInputElement;
+    protected _suspendInputChangeEvt: boolean;
+    protected _prevValue: string;
+    protected _keyChange: boolean;
+    protected _renderChanges: boolean;
+    protected _onInputKeyDownEvt: (evt: KeyboardEvent) => void;
+    protected _onInputChangeEvt: (evt: Event) => void;
+    constructor(args?: InputElementArgs);
+    destroy(): void;
+    protected _onInputFocus: (evt: FocusEvent) => void;
+    protected _onInputBlur: (evt: FocusEvent) => void;
+    protected _onInputKeyDown(evt: KeyboardEvent): void;
+    protected _onInputChange(evt: Event): void;
+    protected _onInputKeyUp: (evt: KeyboardEvent) => void;
+    protected _onInputCtxMenu: (evt: MouseEvent) => void;
+    protected _updateInputReadOnly: () => void;
+    /**
+     * Focuses the input element. If the input contains text and select is `true`, the text will be
+     * selected on focus.
+     *
+     * @param select - If `true`, the input text will be selected.
+     */
+    focus(select?: boolean): void;
+    /**
+     * Unfocuses (blurs) the input element.
+     */
+    blur(): void;
+    set placeholder(value: string);
+    get placeholder(): string;
+    /**
+     * Sets the method to call when keyup is called on the input DOM element.
+     */
+    set keyChange(value: boolean);
+    /**
+     * Gets the method to call when keyup is called on the input DOM element.
+     */
+    get keyChange(): boolean;
+    /**
+     * Gets the input DOM element.
+     */
+    get input(): HTMLInputElement;
+    abstract set value(value: any);
+    abstract get value(): any;
+    abstract set values(value: Array<any>);
+    abstract get values(): Array<any>;
+    set renderChanges(value: boolean);
+    get renderChanges(): boolean;
+}
+export { InputElement, InputElementArgs };

package/node_modules/@playcanvas/pcui/react/types/components/Label/component.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Element } from '../Element/component';
+import { Label as LabelClass, LabelArgs } from './index';
+/**
+ * The Label is a simple span element that displays some text.
+ */
+declare class Label extends Element<LabelArgs, any> {
+    static ctor: typeof LabelClass;
+    render(): React.JSX.Element;
+}
+export { Label };

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

@@ -0,0 +1,85 @@
+import { Element, ElementArgs, IBindable, IBindableArgs, IPlaceholder, IPlaceholderArgs } from '../Element';
+/**
+ * The arguments for the {@link Label} constructor.
+ */
+interface LabelArgs extends ElementArgs, IBindableArgs, IPlaceholderArgs {
+    /**
+     * Sets the text of the Label. Defaults to ''.
+     */
+    text?: string;
+    /**
+     * If `true`, the {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML innerHTML} property will be
+     * used to set the text. Otherwise, {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent textContent}
+     * will be used instead. Defaults to `false`.
+     */
+    unsafe?: boolean;
+    /**
+     * If `true` then use the text of the label as the native HTML tooltip. Defaults to `false`.
+     */
+    nativeTooltip?: boolean;
+    /**
+     * If `true` then the label can be clicked to select text. Defaults to `false`.
+     */
+    allowTextSelection?: boolean;
+    /**
+     * The DOM element or its type to use for this component. Defaults to 'span'.
+     */
+    dom?: HTMLElement | string;
+    /**
+     * Sets the value of the Label. Defaults to ''.
+     */
+    value?: string;
+}
+/**
+ * The Label is a simple span element that displays some text.
+ */
+declare class Label extends Element implements IPlaceholder, IBindable {
+    protected _unsafe: boolean;
+    protected _text: string;
+    protected _renderChanges: boolean;
+    /**
+     * Creates a new Label.
+     *
+     * @param args - The arguments.
+     */
+    constructor(args?: Readonly<LabelArgs>);
+    protected _updateText(value: string): boolean;
+    /**
+     * Sets the text of the Label.
+     */
+    set text(value: string);
+    /**
+     * Gets the text of the Label.
+     */
+    get text(): string;
+    /**
+     * Sets the value of the Label. This is an alias for {@link Label#text}.
+     */
+    set value(value: string);
+    /**
+     * Gets the value of the Label. This is an alias for {@link Label#text}.
+     */
+    get value(): string;
+    /**
+     * Sets multiple values on the Label. If all values are the same, the Label will display that
+     * value. Otherwise, it will be empty and display a "multiple values" state.
+     */
+    set values(values: string[]);
+    /**
+     * Sets the placeholder text of the Label.
+     */
+    set placeholder(value: string);
+    /**
+     * Gets the placeholder text of the Label.
+     */
+    get placeholder(): string;
+    /**
+     * Sets whether the Label should flash when its value changes.
+     */
+    set renderChanges(value: boolean);
+    /**
+     * Gets whether the Label should flash when its value changes.
+     */
+    get renderChanges(): boolean;
+}
+export { Label, LabelArgs };

package/node_modules/@playcanvas/pcui/react/types/components/LabelGroup/component.d.ts

@@ -0,0 +1,10 @@
+import { Element } from '../Element/component';
+import { LabelGroup as LabelGroupClass, LabelGroupArgs } from './index';
+/**
+ * Represents a group of a Label and a Element. Useful for rows of labeled fields.
+ */
+declare class LabelGroup extends Element<LabelGroupArgs, any> {
+    static ctor: typeof LabelGroupClass;
+    attachElement: (nodeElement: HTMLElement, containerElement: any) => void;
+}
+export { LabelGroup };