@cp949/phyx-blockly 12.5.1-p1

package/core/layer_manager.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IFocusableNode } from './interfaces/i_focusable_node.js';
+import { IRenderedElement } from './interfaces/i_rendered_element.js';
+import { Coordinate } from './utils/coordinate.js';
+import { WorkspaceSvg } from './workspace_svg.js';
+/** @internal */
+export declare class LayerManager {
+    private workspace;
+    /** The layer elements being dragged are appended to. */
+    private dragLayer;
+    /** The layer elements being animated are appended to. */
+    private animationLayer;
+    /** The layers elements not being dragged are appended to.  */
+    private layers;
+    /** @internal */
+    constructor(workspace: WorkspaceSvg);
+    private createDragLayer;
+    private createAnimationLayer;
+    /**
+     * Appends the element to the animation layer. The animation layer doesn't
+     * move when the workspace moves, so e.g. delete animations don't move
+     * when a block delete triggers a workspace resize.
+     *
+     * @internal
+     */
+    appendToAnimationLayer(elem: IRenderedElement): void;
+    /**
+     * Translates layers when the workspace is dragged or zoomed.
+     *
+     * @internal
+     */
+    translateLayers(newCoord: Coordinate, newScale: number): void;
+    /**
+     * Moves the given element to the drag layer, which exists on top of all other
+     * layers, and the drag surface.
+     *
+     * @param elem The element to move onto the drag layer.
+     * @param focus Whether or not to focus the element post-move.
+     *
+     * @internal
+     */
+    moveToDragLayer(elem: IRenderedElement & IFocusableNode, focus?: boolean): void;
+    /**
+     * Moves the given element off of the drag layer.
+     *
+     * @param elem The element to move off of the drag layer.
+     * @param layerNum The identifier of the layer to move the element onto.
+     *     Should be a constant from layers.ts.
+     * @param focus Whether or not the element should be focused once moved onto
+     *     the destination layer.
+     *
+     * @internal
+     */
+    moveOffDragLayer(elem: IRenderedElement & IFocusableNode, layerNum: number, focus?: boolean): void;
+    /**
+     * Appends the given element to a layer. If the layer does not exist, it is
+     * created.
+     *
+     * @internal
+     */
+    append(elem: IRenderedElement, layerNum: number): void;
+    /**
+     * Creates a layer and inserts it at the proper place given the layer number.
+     *
+     * More positive layers exist later in the dom and are rendered ontop of
+     * less positive layers. Layers are added to the layer map as a side effect.
+     */
+    private createLayer;
+    /**
+     * Returns true if the given element is a layer managed by the layer manager.
+     * False otherwise.
+     *
+     * @internal
+     */
+    hasLayer(elem: SVGElement): boolean;
+    /**
+     * We need to be able to access this layer explicitly for backwards
+     * compatibility.
+     *
+     * @internal
+     */
+    getBlockLayer(): SVGGElement;
+    /**
+     * We need to be able to access this layer explicitly for backwards
+     * compatibility.
+     *
+     * @internal
+     */
+    getBubbleLayer(): SVGGElement;
+    /**
+     * Returns the drag layer.
+     *
+     * @internal
+     */
+    getDragLayer(): SVGGElement | undefined;
+}
+//# sourceMappingURL=layer_manager.d.ts.map

package/core/layers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The layer to place blocks on.
+ *
+ */
+export declare const BLOCK = 50;
+/**
+ * The layer to place bubbles on.
+ *
+ */
+export declare const BUBBLE = 100;
+//# sourceMappingURL=layers.d.ts.map

package/core/main.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=main.d.ts.map

package/core/marker_manager.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Object in charge of managing markers and the cursor.
+ *
+ * @class
+ */
+import { LineCursor } from './keyboard_nav/line_cursor.js';
+import type { Marker } from './keyboard_nav/marker.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class to manage the multiple markers and the cursor on a workspace.
+ */
+export declare class MarkerManager {
+    private readonly workspace;
+    /** The name of the local marker. */
+    static readonly LOCAL_MARKER = "local_marker_1";
+    /** The cursor. */
+    private cursor;
+    /** The map of markers for the workspace. */
+    private markers;
+    /**
+     * @param workspace The workspace for the marker manager.
+     * @internal
+     */
+    constructor(workspace: WorkspaceSvg);
+    /**
+     * Register the marker by adding it to the map of markers.
+     *
+     * @param id A unique identifier for the marker.
+     * @param marker The marker to register.
+     */
+    registerMarker(id: string, marker: Marker): void;
+    /**
+     * Unregister the marker by removing it from the map of markers.
+     *
+     * @param id The ID of the marker to unregister.
+     */
+    unregisterMarker(id: string): void;
+    /**
+     * Get the cursor for the workspace.
+     *
+     * @returns The cursor for this workspace.
+     */
+    getCursor(): LineCursor;
+    /**
+     * Get a single marker that corresponds to the given ID.
+     *
+     * @param id A unique identifier for the marker.
+     * @returns The marker that corresponds to the given ID, or null if none
+     *     exists.
+     */
+    getMarker(id: string): Marker | null;
+    /**
+     * Sets the cursor and initializes the drawer for use with keyboard
+     * navigation.
+     *
+     * @param cursor The cursor used to move around this workspace.
+     */
+    setCursor(cursor: LineCursor): void;
+    /**
+     * Dispose of the marker manager.
+     * Go through and delete all markers associated with this marker manager.
+     *
+     * @internal
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=marker_manager.d.ts.map

package/core/menu.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { MenuSeparator } from './menu_separator.js';
+import { MenuItem } from './menuitem.js';
+import * as aria from './utils/aria.js';
+import { Coordinate } from './utils/coordinate.js';
+import type { Size } from './utils/size.js';
+/**
+ * A basic menu class.
+ */
+export declare class Menu {
+    /**
+     * Array of menu items and separators.
+     */
+    private readonly menuItems;
+    /**
+     * Coordinates of the pointerdown event that caused this menu to open. Used to
+     * prevent the consequent pointerup event due to a simple click from
+     * activating a menu item immediately.
+     */
+    openingCoords: Coordinate | null;
+    /**
+     * This is the element that we will listen to the real focus events on.
+     * A value of null means no menu item is highlighted.
+     */
+    private highlightedItem;
+    /** Pointer over event data. */
+    private pointerMoveHandler;
+    /** Click event data. */
+    private clickHandler;
+    /** Pointer enter event data. */
+    private pointerEnterHandler;
+    /** Pointer leave event data. */
+    private pointerLeaveHandler;
+    /** Key down event data. */
+    private onKeyDownHandler;
+    /** The menu's root DOM element. */
+    private element;
+    /** ARIA name for this menu. */
+    private roleName;
+    /** Constructs a new Menu instance. */
+    constructor();
+    /**
+     * Add a new menu item to the bottom of this menu.
+     *
+     * @param menuItem Menu item or separator to append.
+     * @internal
+     */
+    addChild(menuItem: MenuItem | MenuSeparator): void;
+    /**
+     * Creates the menu DOM.
+     *
+     * @param container Element upon which to append this menu.
+     * @returns The menu's root DOM element.
+     */
+    render(container: Element): HTMLDivElement;
+    /**
+     * Gets the menu's element.
+     *
+     * @returns The DOM element.
+     * @internal
+     */
+    getElement(): HTMLDivElement | null;
+    /**
+     * Focus the menu element.
+     *
+     * @internal
+     */
+    focus(): void;
+    /** Blur the menu element. */
+    private blur;
+    /**
+     * Set the menu accessibility role.
+     *
+     * @param roleName role name.
+     * @internal
+     */
+    setRole(roleName: aria.Role): void;
+    /** Dispose of this menu. */
+    dispose(): void;
+    /**
+     * Returns the child menu item that owns the given DOM element,
+     * or null if no such menu item is found.
+     *
+     * @param elem DOM element whose owner is to be returned.
+     * @returns Menu item for which the DOM element belongs to.
+     */
+    private getMenuItem;
+    /**
+     * Highlights the given menu item, or clears highlighting if null.
+     *
+     * @param item Item to highlight, or null.
+     * @internal
+     */
+    setHighlighted(item: MenuItem | null): void;
+    /**
+     * Highlights the next highlightable item (or the first if nothing is
+     * currently highlighted).
+     *
+     * @internal
+     */
+    highlightNext(): void;
+    /**
+     * Highlights the previous highlightable item (or the last if nothing is
+     * currently highlighted).
+     *
+     * @internal
+     */
+    highlightPrevious(): void;
+    /** Highlights the first highlightable item. */
+    private highlightFirst;
+    /** Highlights the last highlightable item. */
+    private highlightLast;
+    /**
+     * Helper function that manages the details of moving the highlight among
+     * child menuitems in response to keyboard events.
+     *
+     * @param startIndex Start index.
+     * @param delta Step direction: 1 to go down, -1 to go up.
+     */
+    private highlightHelper;
+    /**
+     * Handles pointermove events. Highlight menu items as the user hovers over
+     * them.
+     *
+     * @param e Pointer event to handle.
+     */
+    private handlePointerMove;
+    /**
+     * Handles click events. Pass the event onto the child menuitem to handle.
+     *
+     * @param e Click event to handle.
+     */
+    private handleClick;
+    /**
+     * Handles pointer enter events. Focus the element.
+     *
+     * @param _e Pointer event to handle.
+     */
+    private handlePointerEnter;
+    /**
+     * Handles pointer leave events by clearing the active highlight.
+     *
+     * @param _e Pointer event to handle.
+     */
+    private handlePointerLeave;
+    /**
+     * Attempts to handle a keyboard event.
+     *
+     * @param e Key event to handle.
+     */
+    private handleKeyEvent;
+    /**
+     * Get the size of a rendered menu.
+     *
+     * @returns Object with width and height properties.
+     * @internal
+     */
+    getSize(): Size;
+    /**
+     * Returns the action menu items (omitting separators) in this menu.
+     *
+     * @returns The MenuItem objects displayed in this menu.
+     */
+    private getMenuItems;
+}
+//# sourceMappingURL=menu.d.ts.map

package/core/menu_separator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Representation of a section separator in a menu.
+ */
+export declare class MenuSeparator {
+    /**
+     * DOM element representing this separator in a menu.
+     */
+    private element;
+    /**
+     * Creates the DOM representation of this separator.
+     *
+     * @returns An <hr> element.
+     */
+    createDom(): HTMLHRElement;
+    /**
+     * Disposes of this separator.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=menu_separator.d.ts.map

package/core/menuitem.d.ts

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Blockly menu item similar to Closure's goog.ui.MenuItem
+ *
+ * @class
+ */
+import * as aria from './utils/aria.js';
+/**
+ * Class representing an item in a menu.
+ */
+export declare class MenuItem {
+    private readonly content;
+    private readonly opt_value?;
+    /** Is the menu item clickable, as opposed to greyed-out. */
+    private enabled;
+    /** The DOM element for the menu item. */
+    private element;
+    /** Whether the menu item is rendered right-to-left. */
+    private rightToLeft;
+    /** ARIA name for this menu. */
+    private roleName;
+    /** Is this menu item checkable. */
+    private checkable;
+    /** Is this menu item currently checked. */
+    private checked;
+    /** Is this menu item currently highlighted. */
+    private highlight;
+    /** Bound function to call when this menu item is clicked. */
+    private actionHandler;
+    /**
+     * @param content Text caption to display as the content of the item, or a
+     *     HTML element to display.
+     * @param opt_value Data/model associated with the menu item.
+     */
+    constructor(content: string | HTMLElement, opt_value?: string | undefined);
+    /**
+     * Creates the menuitem's DOM.
+     *
+     * @returns Completed DOM.
+     */
+    createDom(): Element;
+    /** Dispose of this menu item. */
+    dispose(): void;
+    /**
+     * Gets the menu item's element.
+     *
+     * @returns The DOM element.
+     * @internal
+     */
+    getElement(): Element | null;
+    /**
+     * Gets the unique ID for this menu item.
+     *
+     * @returns Unique component ID.
+     * @internal
+     */
+    getId(): string;
+    /**
+     * Gets the value associated with the menu item.
+     *
+     * @returns value Value associated with the menu item.
+     * @internal
+     */
+    getValue(): string | null;
+    /**
+     * Set menu item's rendering direction.
+     *
+     * @param rtl True if RTL, false if LTR.
+     * @internal
+     */
+    setRightToLeft(rtl: boolean): void;
+    /**
+     * Set the menu item's accessibility role.
+     *
+     * @param roleName Role name.
+     * @internal
+     */
+    setRole(roleName: aria.Role): void;
+    /**
+     * Sets the menu item to be checkable or not. Set to true for menu items
+     * that represent checkable options.
+     *
+     * @param checkable Whether the menu item is checkable.
+     * @internal
+     */
+    setCheckable(checkable: boolean): void;
+    /**
+     * Checks or unchecks the component.
+     *
+     * @param checked Whether to check or uncheck the component.
+     * @internal
+     */
+    setChecked(checked: boolean): void;
+    /**
+     * Highlights or unhighlights the component.
+     *
+     * @param highlight Whether to highlight or unhighlight the component.
+     * @internal
+     */
+    setHighlighted(highlight: boolean): void;
+    /**
+     * Returns true if the menu item is enabled, false otherwise.
+     *
+     * @returns Whether the menu item is enabled.
+     * @internal
+     */
+    isEnabled(): boolean;
+    /**
+     * Enables or disables the menu item.
+     *
+     * @param enabled Whether to enable or disable the menu item.
+     * @internal
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Performs the appropriate action when the menu item is activated
+     * by the user.
+     *
+     * @param menuSelectEvent the event that triggered the selection
+     * of the menu item.
+     *
+     * @internal
+     */
+    performAction(menuSelectEvent: Event): void;
+    /**
+     * Set the handler that's called when the menu item is activated by the user.
+     * `obj` will be used as the 'this' object in the function when called.
+     *
+     * @param fn The handler.
+     * @param obj Used as the 'this' object in fn when called.
+     * @internal
+     */
+    onAction(fn: (p1: MenuItem, menuSelectEvent: Event) => void, obj: object): void;
+    /**
+     * Adds or removes the checkmark indicator on this menu item.
+     * The indicator is present even if this menu item is not checked, as long
+     * as it is checkable; its visibility is controlled with CSS.
+     *
+     * @param add True to add the checkmark indicator, false to remove it.
+     */
+    private toggleHasCheckbox;
+}
+//# sourceMappingURL=menuitem.d.ts.map