blockbench-types 5.2.0-beta.0-next.1 → 5.2.0-beta.0-next.2

package/generated/interface/main_tools.d.ts

@@ -0,0 +1,23 @@
+declare global {
+    interface BarItemRegistry {
+        move_tool: Tool;
+        resize_tool: Tool;
+        rotate_tool: Tool;
+        pivot_tool: Tool;
+        vertex_snap_tool: Tool;
+        stretch_tool: Tool;
+        swap_tools: Action;
+        set_element_marker_color: Action;
+        randomize_marker_colors: Action;
+        new_window: Action;
+        open_model_folder: Action;
+        reload: Action;
+        open_dev_tools: Action;
+        fullscreen: Action;
+        zoom_in: Action;
+        zoom_out: Action;
+        zoom_reset: Action;
+        toggle_sidebars: Action;
+    }
+}
+export {};

package/generated/interface/menu.d.ts

@@ -0,0 +1,141 @@
+/**
+ * The menu class lets you create content menus. Context menus can contain custom menu items, and a number of existing UI elements, including Actions, Tools, etc.
+ *
+ * ## Example
+ * ```
+ * document.addEventListener('contextmenu', event => {
+ *   let items = [
+ *     'open_model',
+ *     {
+ *       name: 'Example',
+ *       icon: 'house',
+ *       click() {
+ *         console.log('Hello World')
+ *       }
+ *     }
+ *   ];
+ *   new Menu(items).open(event);
+ * })
+ * ```
+ * @module
+ */
+export interface CustomMenuItem {
+    name: string;
+    id?: string;
+    icon: IconString | boolean | ((context: any) => (IconString | boolean));
+    color?: string;
+    description?: string;
+    condition?: ConditionResolvable;
+    /**
+     * Keybind or string to display in the menu, won't work as an actual keybinding by default
+     */
+    keybind?: Keybind | string;
+    /**
+     * If true, mark the menu item as the selected one (underlined text in default theme)
+     */
+    marked?: boolean | ((context: any) => boolean);
+    /**
+     * Adds a search bar to the menu or submenu
+     */
+    searchable?: boolean;
+    children?: MenuItem[] | ((context: any) => MenuItem[]);
+    click?(context?: any, event?: Event): void;
+}
+export type MenuItem = CustomMenuItem | Action | BarSelect | MenuSeparator | string | ((context: any) => MenuItem);
+type MenuOpenPositionAnchor = MouseEvent | HTMLElement | 'mouse';
+export interface MenuOptions {
+    onOpen?(position: MenuOpenPositionAnchor, context?: any): void;
+    onClose?(): void;
+    keep_open?: boolean;
+    searchable?: boolean;
+    class?: string | string[];
+}
+export declare class MenuSeparator {
+    id: string;
+    label?: string;
+    menu_node: HTMLLIElement;
+    constructor(id?: string, label?: string);
+}
+/**
+ * Use the Menu class to create a context menu. Menus can contain custom entries and hierarchy, or existing actions and tools.
+ */
+export declare class Menu implements Deletable {
+    id: string;
+    children: [];
+    structure: MenuItem[] | ((context: any) => MenuItem[]);
+    options?: MenuOptions;
+    condition?: ConditionResolvable;
+    onOpen?(position: MenuOpenPositionAnchor, context?: any): void;
+    onClose?(): void;
+    node: HTMLUListElement;
+    highlight_action?: MenuItem;
+    type: string;
+    /**
+     * Creates a new context menu
+     */
+    constructor(template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions);
+    constructor(id: string, template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions);
+    hover(node: HTMLElement, event?: Event, expand?: boolean): void;
+    /**
+     * Trigger keyboard navigation
+     * @param e Event
+     * @returns True if the input was used for navigation
+     * @private
+     */
+    keyNavigate(e: KeyboardEvent): boolean;
+    /**
+     * Opens the menu somewhere
+     * @param position Position where to open the menu. Can be a mouse event, or a node that the menu is spawned below.
+     * @param context Context for the click events inside the menu
+     */
+    open(position?: MenuOpenPositionAnchor, context?: any): this;
+    /**
+     * Alias for .open()
+     */
+    show(position?: MenuOpenPositionAnchor, context?: any): this;
+    /**
+     * Closes the menu if it's open
+     */
+    hide(): this;
+    /**
+     * @deprecated
+     */
+    conditionMet(): boolean;
+    /**
+     * Adds an action to the menu structure
+     * @param action Action to add
+     * @param path Path pointing to the location. Use the ID of each level of the menu, or index within a level, separated by a point. For example, `export.0` places the action at the top position of the Export submenu.
+     */
+    addAction(action: Action | CustomMenuItem | '_', path?: string | number): void;
+    /**
+     * Remove an action or menu item from the menu
+     * @param path Path pointing to the location. Use the ID of each level of the menu, or index within a level, or item ID, separated by a point. For example, `export.export_special_format` removes the action "Export Special Format" from the Export submenu.
+     */
+    removeAction(path: string | Action): void;
+    /**
+     * @deprecated Use removeAction instead
+     */
+    deleteItem(rm_item: Action): void;
+    delete(): void;
+    static open: Menu | null;
+    static closed_in_this_click?: string;
+}
+export declare function preventContextMenu(): void;
+declare const global: {
+    MenuSeparator: typeof import("./menu").MenuSeparator;
+    Menu: typeof import("./menu").Menu;
+    preventContextMenu: typeof import("./menu").preventContextMenu;
+    open_menu: any;
+};
+declare global {
+    type Menu = import('./menu').Menu;
+    const Menu: typeof global.Menu;
+    type MenuSeparator = import('./menu').MenuSeparator;
+    const MenuSeparator: typeof global.MenuSeparator;
+    function preventContextMenu(): void;
+    let open_menu: Menu | null;
+    interface Window {
+        open_menu: Menu | null;
+    }
+}
+export {};

package/generated/interface/menu_bar.d.ts

@@ -1,7 +1,6 @@
 declare global {
     class BarMenu extends Menu {
         constructor(id: any, structure: any, options?: {});
-        type: string;
         id: any;
         children: any[];
         condition: any;
@@ -9,7 +8,7 @@ declare global {
         name: string;
         label: HTMLElement;
         structure: any;
-        highlight_action: any;
+        highlight_action: import("./menu").MenuItem;
         open(...args: any[]): void;
         hide(): this;
         highlight(action: any): void;
@@ -27,5 +26,5 @@ declare global {
         function removeAction(path: any): void;
     }
 }
-
+import { Menu } from "./menu";
 export {};

package/generated/interface/shared_actions.d.ts

@@ -6,6 +6,7 @@
  * Handlers can be added for existing actions like this:
 
 ### Example:
+* @example
 ```javascript
     // Duplicate layers when using "Duplicate" in the layers panel
     SharedActions.add('duplicate', {
@@ -23,6 +24,10 @@
         }
     })
 ```
+* @module
+ */
+/**
+ * Global Shared Actions namespace to access any functionality related to Shared Actions
  */
 export declare const SharedActions: {
     /**

package/generated/interface/toolbars.d.ts

@@ -1,50 +1,150 @@
+/**
+ * Toolbars are UI elements that are usually constantly displayed on screen, e. g inside a panel, and can hold any number of BarItems, including Actions, Tools, BarSelects etc.
+ * Toolbars are made to be customized by users
+ * @module
+ */
+/**
+ * Registry of all toolbars
+ */
+export interface ToolbarRegistry {
+    tools: Toolbar;
+    main_tools: Toolbar;
+    element_position: Toolbar;
+    element_size: Toolbar;
+    element_stretch: Toolbar;
+    element_origin: Toolbar;
+    element_rotation: Toolbar;
+    brush: Toolbar;
+    vertex_snap: Toolbar;
+    seam_tool: Toolbar;
+    weight_brush: Toolbar;
+    outliner: Toolbar;
+    reference_images: Toolbar;
+    animations: Toolbar;
+    collections: Toolbar;
+    texturelist: Toolbar;
+    layers: Toolbar;
+    uv_editor: Toolbar;
+    display: Toolbar;
+    keyframe: Toolbar;
+    timeline: Toolbar;
+    color_picker: Toolbar;
+    palette: Toolbar;
+    skin_pose: Toolbar;
+    [id: string]: Toolbar;
+}
+export declare const Toolbars: Record<string, Toolbar>;
+export interface ToolbarOptions {
+    id?: string;
+    name?: string;
+    /**
+     * If true, the toolbar will display a label abovee
+     */
+    label?: boolean;
+    condition?: ConditionResolvable;
+    /**
+     * If true, the toolbar will only take as much width as needed
+     */
+    narrow?: boolean;
+    vertical?: boolean;
+    /**
+     * If true, the toolbar will not wrap into new line, and will instead display an overflow button in case of overflow
+     */
+    no_wrap?: boolean;
+    /**
+     * If true, add the toolbar automatically to it's designated spot in the UI
+     * @deprecated
+     */
+    default_place?: boolean;
+    /**
+     * Default content of the toolbar. Separators are available, where _ = separator, + = spaces, # = line break
+     */
+    children: ('_' | '+' | '#' | string | BarItem)[];
+}
+export declare class Toolbar {
+    id: string;
+    name: string;
+    label: boolean;
+    label_node: HTMLElement;
+    condition: ConditionResolvable;
+    children: (BarItem | string)[];
+    no_wrap: boolean;
+    narrow: boolean;
+    vertical: boolean;
+    default_place: boolean;
+    default_children: (BarItem | string)[];
+    positionLookup: any;
+    condition_cache: any;
+    previously_enabled: any;
+    postload: any;
+    node: HTMLElement;
+    constructor(id: string, data: ToolbarOptions);
+    /**
+     * Legacy constructor
+     * @deprecated
+     */
+    constructor(data: ToolbarOptions);
+    /**
+     * Builds the toolbar from data
+     * @param {object} data Data used to build the toolbar
+     * @param {boolean} force If true, customization data will be ignored. Used when resetting toolbar
+     */
+    build(data: any, force?: boolean): this;
+    contextmenu(event: MouseEvent): void;
+    editMenu(): this;
+    add(action: BarItem, position?: number): this;
+    remove(action: BarItem | string, update?: boolean): this;
+    update(force?: boolean): this;
+    toPlace(place: string): this;
+    save(): this;
+    reset(): this;
+    menu: Menu;
+}
+export declare const BARS: {
+    stored: {
+        _known: any[];
+    };
+    editing_bar: any;
+    action_definers: any[];
+    condition: typeof Condition;
+    dialog: Dialog;
+    defineActions(definer: () => void): void;
+    setupActions(): void;
+    setupToolbars(): void;
+    setupVue(): void;
+    updateConditions(): void;
+};
+type ToolboxToolbar = Toolbar & {
+    selected: Tool;
+    original: any;
+    toggleTransforms(event?: MouseEvent): void;
+};
+declare const global: {
+    Toolbar: typeof import("./toolbars").Toolbar;
+    BARS: {
+        stored: {
+            _known: any[];
+        };
+        editing_bar: any;
+        action_definers: any[];
+        condition: typeof Condition;
+        dialog: Dialog;
+        defineActions(definer: () => void): void;
+        setupActions(): void;
+        setupToolbars(): void;
+        setupVue(): void;
+        updateConditions(): void;
+    };
+    Toolbars: Record<string, import("./toolbars").Toolbar>;
+};
 declare global {
-    const Toolbars: {};
-    class Toolbar {
-        constructor(id: any, data: any);
-        id: any;
-        name: string;
-        label: boolean;
-        label_node: any;
-        condition: any;
-        children: any[];
-        condition_cache: any[];
-        postload: any[][];
-        positionLookup: {};
-        no_wrap: boolean;
-        vertical: boolean;
-        default_children: any;
-        previously_enabled: boolean;
-        node: HTMLElement;
-        /**
-         * Builds the toolbar from data
-         * @param {object} data Data used to build the toolbar
-         * @param {boolean} force If true, customization data will be ignored. Used when resetting toolbar
-         */
-        build(data: object, force: boolean): this;
-        contextmenu(event: any): void;
-        editMenu(): this;
-        add(action: any, position: any): this;
-        remove(action: any, update?: boolean): this;
-        update(force: any): this;
-        toPlace(place: any): this;
-        save(): this;
-        reset(): this;
-        menu: Menu;
-    }
-    namespace BARS {
-        namespace stored {
-            let _known: any[];
-        }
-        let editing_bar: any;
-        let action_definers: any[];
-        let condition: typeof Condition;
-        function defineActions(definer: any): void;
-        function setupActions(): void;
-        function setupToolbars(): void;
-        function setupVue(): void;
-        function updateConditions(): void;
+    type Toolbar = import('./toolbars').Toolbar;
+    const Toolbar: typeof global.Toolbar;
+    const Toolbars: ToolbarRegistry;
+    const BARS: typeof global.BARS;
+    const Toolbox: ToolboxToolbar;
+    interface Window {
+        Toolbox: ToolboxToolbar;
     }
 }
-
 export {};

package/generated/io/format.d.ts

@@ -278,6 +278,7 @@ export type FormatOptions = FormatFeatures & {
     confidential?: boolean;
     condition?: ConditionResolvable;
     show_on_start_screen?: boolean;
+    show_in_new_list?: boolean;
     can_convert_to?: boolean;
     format_page?: FormatPage;
     onFormatPage?(): void;

package/generated/io/project.d.ts

@@ -92,7 +92,7 @@ export declare class ModelProject {
     selected_groups: any;
     spline_selection: any;
     texture_groups: any;
-    collections: any;
+    collections: Collection[];
     animation_controllers: any;
     constructor(options?: ModelProjectOptions, uuid?: UUID);
     extend(object: any): void;

package/generated/main.d.ts

@@ -38,6 +38,8 @@ import "./interface/keybinding";
 import "./interface/settings";
 import "./interface/about";
 import "./interface/action_control";
+import "./interface/toolbars";
+import "./interface/main_tools";
 import "./copy_paste";
 import "./undo";
 import './desktop.ts';
@@ -74,6 +76,7 @@ import "./modeling/mirror_modeling";
 import "./modeling/spline_editing";
 import "./modeling/weight_paint";
 import "./modeling/generate_bounding_box";
+import "./find_replace";
 import "./texturing/textures";
 import "./texturing/layers";
 import "./texturing/texture_groups";

package/generated/modeling/mesh/add_mesh.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface BarItemRegistry {
+        add_mesh: Action;
+    }
+}
+export {};

package/generated/modeling/mesh/util.d.ts

@@ -1,5 +1,11 @@
+export declare function sameMeshEdge(edge_a: MeshEdge, edge_b: MeshEdge): boolean;
+declare const global: {
+    sameMeshEdge: typeof import("./util").sameMeshEdge;
+};
 declare global {
-    function sameMeshEdge(edge_a: MeshEdge, edge_b: MeshEdge): boolean;
+    const sameMeshEdge: typeof global.sameMeshEdge;
+    interface BarItemRegistry {
+        selection_mode: BarSelect;
+    }
 }
-
 export {};

package/generated/modes.d.ts

@@ -52,7 +52,7 @@ export declare const Modes: {
     edit: boolean;
     paint: boolean;
     pose: boolean;
-    mobileModeMenu(button: any, event: any): Menu;
+    mobileModeMenu(button: any, event: any): import("./interface/menu").Menu;
 };
 declare const global: {
     Mode: typeof import("./modes").Mode;
@@ -67,7 +67,7 @@ declare const global: {
         edit: boolean;
         paint: boolean;
         pose: boolean;
-        mobileModeMenu(button: any, event: any): Menu;
+        mobileModeMenu(button: any, event: any): import("./interface/menu").Menu;
     };
 };
 declare global {

package/generated/native_apis.d.ts

@@ -55,5 +55,8 @@ declare const global: {
 declare global {
     const openDevTools: typeof global.openDevTools;
     const SystemInfo: typeof global.SystemInfo;
+    interface Window {
+        SystemInfo: typeof global.SystemInfo | null;
+    }
 }
 export {};

package/generated/outliner/abstract/outliner_element.d.ts

@@ -12,6 +12,7 @@ interface OutlinerElementData {
 }
 export declare abstract class OutlinerElement extends OutlinerNode {
     allow_mirror_modeling?: boolean;
+    faces?: Record<string, Face>;
     static animator?: BoneAnimator;
     static isParent: false;
     static all: OutlinerElement[];

package/generated/outliner/abstract/outliner_node.d.ts

@@ -7,6 +7,7 @@ export declare abstract class OutlinerNode {
     scope: number;
     parent: (OutlinerNode & OutlinerNodeParentTraits) | 'root';
     selected: boolean;
+    visibility?: boolean;
     readonly _static: {
         properties: any;
         temp_data: Record<string, any>;

package/generated/outliner/types/armature.d.ts

@@ -44,7 +44,7 @@ export declare class Armature extends OutlinerElement {
     icon: string;
     name_regex: () => false | "a-zA-Z0-9_";
     buttons: OutlinerToggle[];
-    menu: Menu;
+    menu: import("../../interface/menu").Menu;
     static all: Armature[];
     static selected: Armature[];
 }

package/generated/outliner/types/armature_bone.d.ts

@@ -73,7 +73,7 @@ export declare class ArmatureBone extends OutlinerElement {
     icon: string;
     name_regex: () => false | "a-zA-Z0-9_";
     buttons: OutlinerToggle[];
-    menu: Menu;
+    menu: import("../../interface/menu").Menu;
 }
 export declare function getAllArmatureBones(): any[];
 declare const global: {

package/generated/outliner/types/billboard.d.ts

@@ -75,7 +75,7 @@ declare global {
         mapAutoUV(): void;
         title: string;
         icon: string;
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
         buttons: OutlinerToggle[];
     }
 }

package/generated/outliner/types/bounding_box.d.ts

@@ -14,7 +14,7 @@ export declare class BoundingBox extends OutlinerElement {
     title: string;
     type: string;
     icon: string;
-    menu: Menu;
+    menu: import("../../interface/menu").Menu;
     buttons: OutlinerToggle[];
     visibility: boolean;
     color: number;

package/generated/outliner/types/cube.d.ts

@@ -134,7 +134,7 @@ declare global {
         isStretched(): boolean;
         title: string;
         icon: string;
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
         buttons: OutlinerToggle[];
     }
 }

package/generated/outliner/types/group.d.ts

@@ -55,7 +55,7 @@ declare global {
         icon: string;
         name_regex(): string | false;
         buttons: OutlinerToggle[];
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
     }
     namespace Group {
         let all: globalThis.Group[];

package/generated/outliner/types/locator.d.ts

@@ -17,7 +17,7 @@ declare global {
         name_regex(): string;
         visibility: boolean;
         buttons: OutlinerToggle[];
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
     }
     namespace Locator {
         function updateAutocompleteList(): void;

package/generated/outliner/types/mesh.d.ts

@@ -103,7 +103,7 @@ declare global {
         applyTexture(texture: any, faces: any): void;
         title: string;
         icon: string;
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
         buttons: OutlinerToggle[];
     }
 }

package/generated/outliner/types/null_object.d.ts

@@ -16,7 +16,7 @@ declare global {
         icon: string;
         visibility: boolean;
         buttons: OutlinerToggle[];
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
     }
 }
 export {};

package/generated/outliner/types/spline_mesh.d.ts

@@ -118,7 +118,6 @@ declare global {
          * Refresh the dummy face object of this spline, allowing us to paint on it, or to convert it to a Mesh.
          */
         refreshTubeFaces(): void;
-        faces: {};
         getSelectedVertices(make: any): any;
         /**
         Readonly list of selected handles, based on selected vertices.
@@ -206,7 +205,7 @@ declare global {
         isSmoothShaded(): boolean;
         title: string;
         icon: string;
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
         buttons: OutlinerToggle[];
     }
 }

package/generated/outliner/types/texture_mesh.d.ts

@@ -19,7 +19,7 @@ declare global {
         };
         title: string;
         icon: string;
-        menu: Menu;
+        menu: import("../../interface/menu").Menu;
         buttons: OutlinerToggle[];
     }
 }

package/generated/plugin_loader.d.ts

@@ -215,7 +215,7 @@ export declare class Plugin {
     fetchChangelog(force?: boolean): Promise<void>;
     getPluginDetails(force_refresh?: boolean): PluginDetails;
     static selected: Plugin | null;
-    static menu: Menu;
+    static menu: import("./interface/menu").Menu;
     static register(id: string, data: PluginOptions): Plugin;
 }
 export declare const BBPlugin: typeof Plugin;