blockbench-types 4.6.1 → 4.9.0

package/types/keyframe.d.ts

@@ -1,11 +1,26 @@
+interface KeyframeDataPointData {
+    [key: string]: any
+}
 declare class KeyframeDataPoint {
     constructor(keyframe: _Keyframe);
-    extend(data: any): void;
-    getUndoCopy(): {};
+    extend(data: KeyframeDataPointData): void;
+    getUndoCopy(): {
+        [key: string]: any
+    };
 }
 
 interface KeyframeOptions {
-
+    channel?: string
+    data_points: {}[]
+    time: number
+    color?: number
+    uniform?: boolean
+    interpolation?: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
+    bezier_linked?: boolean
+    bezier_left_time?: ArrayVector3
+    bezier_left_value?: ArrayVector3
+    bezier_right_time?: ArrayVector3
+    bezier_right_value?: ArrayVector3
 }
 type axisLetter = 'x' | 'y' | 'z'
 
@@ -13,6 +28,14 @@ declare class _Keyframe {
     constructor(options: KeyframeOptions, uuid: any);
 
     animator: GeneralAnimator;
+
+    channel: string
+    data_points: KeyframeDataPoint[]
+    time: number
+    color: number
+    uniform: boolean
+    interpolation: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
+    bezier_linked: boolean
     bezier_left_time: ArrayVector3;
     bezier_right_time: ArrayVector3;
     bezier_left_value: ArrayVector3;
@@ -42,4 +65,6 @@ declare class _Keyframe {
         channel?: string | null;
         data_points: object[];
     };
-}
+}
+
+declare function updateKeyframeSelection(): void;

package/types/math_util.d.ts

@@ -0,0 +1 @@
+	declare function guid(): string;

package/types/menu.d.ts

@@ -22,6 +22,9 @@ interface MenuOptions {
     keep_open?: boolean
     searchable?: boolean
 }
+/**
+ * Use the Menu class to create a context menu. Menus can contain custom entries and hierarchy, or existing actions and tools.
+ */
 declare class Menu extends Deletable {
     constructor(id: string, template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions)
     constructor(template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions)
@@ -78,12 +81,12 @@ declare namespace MenuBar {
     /**
      * 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, `file.export.0` places the action at the top position of the Export submenu in the File menu.
+     * @param path Path pointing to the location. Use the ID of each level of the menu, or index or group within a level, separated by a point. For example, `file.export.0` places the action at the top position of the Export submenu in the File menu.
      */
     function addAction(action: Action, path?: string): void
     /**
      * 
-     * @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.
+     * @param path Path pointing to the location. Use the ID of each level of the menu, or index or group 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.
      */
     function removeAction(path: string)
     /**

package/types/mesh.d.ts

@@ -71,10 +71,15 @@ declare class Mesh extends OutlinerElement {
 
 	static all: Mesh[]
 	static selected: Mesh[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 interface MeshFaceOptions extends FaceOptions {
-
+	vertices: string[]
+	uv: {[vkey: string]: ArrayVector2}
 }
 declare class MeshFace extends Face {
 	constructor(mesh: Mesh, data: MeshFaceOptions)

package/types/misc.d.ts

@@ -29,12 +29,16 @@ type EventName = 'remove_animation'
 	| 'reset_project'
 	| 'close_project'
 	| 'saved_state_changed'
+	| 'save_model_action'
 	| 'add_cube'
 	| 'add_mesh'
 	| 'add_group'
 	| 'add_texture_mesh'
 	| 'group_elements'
 	| 'update_selection'
+	| 'compile_bedrock_animations'
+	| 'load_animation'
+	| 'load_animation_controller'
 	| 'update_keyframe_selection'
 	| 'select_all'
 	| 'added_to_selection'
@@ -96,12 +100,22 @@ interface MessageBoxOptions {
 	 * Display a list of actions to do in the dialog. When clicked, the message box closes with the string ID of the command as first argument.
 	 */
 	commands?: {
-		[id: string]: string | {text: string}
+		[id: string]: string | {text: string, icon?: IconString, condition?: ConditionResolvable}
+	}
+	/**
+	 * Adds checkboxes to the bottom of the message box
+	 */
+	checkboxes: {
+		[id: string]: string | {
+			value?: boolean
+			condition: ConditionResolvable
+			text: string
+		}
 	}
 }
 
 
-
+type PropertyType = 'string' | 'number' | 'enum' | 'molang' | 'boolean' | 'array' | 'instance' | 'vector' | 'vector2'
 interface PropertyOptions {
 	default?: any
 	condition?: ConditionResolvable
@@ -111,6 +125,10 @@ interface PropertyOptions {
 	 * Options used for select types
 	 */
 	options?: object
+	/**
+	 * Enum possible values
+	 */
+	values: string[]
 	merge?: (instance: any, data: object) => void
 	reset?: (instance: any) => void
 	merge_validation?: (value: any) => boolean
@@ -119,20 +137,23 @@ interface PropertyOptions {
  * Creates a new property on the specified target class
  */
 declare class Property extends Deletable {
-    constructor(target_class: any, type: string, name: string, options?: PropertyOptions);
+    constructor(target_class: any, type: PropertyType, name: string, options?: PropertyOptions);
     class: any;
     name: string;
-    type: string;
+    type: PropertyType;
 	default: any;
 	
     isString: boolean;
+    isEnum: boolean;
     isMolang: boolean;
     isNumber: boolean;
     isBoolean: boolean;
     isArray: boolean;
     isVector: boolean;
 	isVector2: boolean;
+	isInstance: boolean;
 	
+	enum_values?: string[]
     merge_validation: undefined | ((value: any) => boolean);
     condition: ConditionResolvable;
     exposed: boolean;

package/types/mode.d.ts

@@ -31,4 +31,5 @@ declare namespace Modes {
 	const options: {
 		[id: string]: Mode
 	}
+	const selected: Mode;
 }

package/types/outliner.d.ts

@@ -9,6 +9,7 @@ type ArrayVector2 = [number, number]
 declare class OutlinerNode {
 	constructor ()
 	uuid: UUID
+	name: string
 	export: boolean
 	locked: boolean
 	parent: Group | 'root'
@@ -53,6 +54,10 @@ declare class OutlinerNode {
 	 * @param event Mouse event, determines where the context menu spawns.
 	 */
 	showContexnu(event: Event | HTMLElement): this
+
+	static uuids: {
+		[uuid: UUID]: OutlinerNode
+	}
 }
 
 /**
@@ -81,6 +86,10 @@ declare class Locator extends OutlinerElement {
 
 	static all: Locator[]
 	static selected: Locator[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 
@@ -103,6 +112,10 @@ declare class NullObject extends OutlinerElement {
 
 	static all: NullObject[]
 	static selected: NullObject[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 

package/types/painter.d.ts

@@ -1,4 +1,6 @@
-
+/**
+ * A global namespace containing various functionality for Blockbench's 2D and 3D paint tools and texture editor
+ */
 declare namespace Painter {
 	const currentPixel: ArrayVector2
 	const brushChanges: boolean

package/types/panel.d.ts

@@ -1,3 +1,5 @@
+type PanelSlot = 'left_bar' | 'right_bar' | 'top' | 'bottom' | 'float'
+
 interface PanelOptions {
 	id: string
 	name: string
@@ -10,9 +12,9 @@ interface PanelOptions {
 	expand_button: boolean
 	toolbars: {
 		[id: string]: Toolbar
-	}
+	} | Toolbar[]
 	default_position: {
-		slot: string
+		slot: PanelSlot
 		float_position: [number, number]
 		float_size: [number, number]
 		height: number
@@ -27,25 +29,38 @@ interface PanelOptions {
 }
 type PanelEvent = 'drag' | 'fold' | 'change_zindex' | 'move_to' | 'moved_to' | 'update'
 
+/**
+ * Panels are interface sections in Blockbench, that are always visible (in a specific format and mode), and can be added to the sidebars, above or below the 3D viewport, or used as free floating above the UI. Examples are the Outliner or the UV editor.
+ */
 declare class Panel {
 	constructor (id: string, options: PanelOptions)
 	constructor (options: PanelOptions)
 	isVisible(): boolean
 	isInSidebar(): boolean
-	slot: string
+	slot: PanelSlot
 	folded: boolean
+	inside_vue: Vue
+
+
 	fold(state?: boolean): this
 	/**
 	 * If the panel is floating, move it up to the front
 	 */
 	moveToFront(): this
-	moveTo(slot: string, ref_panel?: Panel, before?: boolean): this
+	moveTo(slot: PanelSlot, ref_panel?: Panel, before?: boolean): this
 	update(dragging?: boolean): this
 	dispatchEvent(event_name: PanelEvent, data?: any): void
 	/**
 	 * Add an event listener
 	 */
 	on(event_name: PanelEvent, callback: (data?) => void): void
+	/**
+	 * Adds a single-use event listener
+	 */
+	once(event_name: PanelEvent, callback: (data?) => void): void
+	/**
+	 * Removes an event listener
+	 */
 	removeListener(event_name: PanelEvent, callback: (data?) => void): void
 	delete(): void
 }

package/types/plugin.d.ts

@@ -29,7 +29,11 @@ interface PluginOptions {
 	/**
 	 * Set to true if the plugin must finish loading before a project is opened, i. e. because it adds a format
 	 */
-	await_loading?: string
+	await_loading?: boolean
+	/**
+	 * Use the new repository format where plugin, iron, and about are stored in a separate folder
+	 */
+	new_repository_format?: boolean
 	/**
 	 * Runs when the plugin loads
 	 */

package/types/preview.d.ts

@@ -20,9 +20,12 @@ type RaycastResult = {
     intersects?: object[]
     face?: string
     vertex: any
-    keyframe: Keyframe
+    keyframe: _Keyframe
 }
 
+/**
+ * Previews are 3D viewports, that can either be used as a viewport for the user, or as an offscreen view to record media.
+ */
 declare class Preview extends Deletable {
     constructor(options: PreviewOptions)
 

package/types/project.d.ts

@@ -2,6 +2,9 @@ interface ModelProjectOptions {
 	format: ModelFormat
 }
 
+/**
+ * A project instance. The tab bar can be used to switch between projects.
+ */
 declare class ModelProject {
 	constructor(options: ModelProjectOptions)
 
@@ -12,6 +15,7 @@ declare class ModelProject {
 	uuid: UUID
 	selected: boolean
 	model_identifier: string
+	parent: string
 	/**
 	 * When set to true, the project tab can no longer be selected or unselected
 	 */
@@ -53,7 +57,7 @@ declare class ModelProject {
 	textures: Texture[]
 	selected_texture: Texture | null;
 	outliner: OutlinerNode[]
-	animations: Animation[]
+	animations: _Animation[]
 	timeline_animators: []
 	display_settings: {
 		[slot: string]: {
@@ -61,8 +65,12 @@ declare class ModelProject {
 			rotation: [number, number, number]
 			scale: [number, number, number]
 			mirror: [boolean, boolean, boolean]
+			export(): void;
 		}
 	};
+	ambientocclusion: boolean;
+	front_gui_light: boolean;
+	overrides: any;
 
 	get model_3d(): THREE.Object3D;
     get materials(): {
@@ -82,13 +90,19 @@ declare class ModelProject {
 	static all: ModelProject[]
 }
 
-declare const Project: ModelProject | null
+/**
+ * Global variable and shortcut to get the currently opened project. If no project is open, or the New Tab is open, this value is falsy.
+ */
+declare const Project: ModelProject | 0
 
 declare function setupProject(format: ModelFormat | string): boolean;
 declare function newProject(format: ModelFormat | string): boolean;
 declare function setProjectResolution(width: number, height: number, modify_uv?: boolean): void;
 declare function updateProjectResolution(): void;
 
+/**
+ * An edit session instance. Edit sessions can be attached to a project to collaborate on it with multiple users via P2P connections.
+ */
 declare class EditSession {
 	constructor()
 

package/types/screencam.d.ts

@@ -28,6 +28,9 @@ interface RecordTimelapseOptions {
 }
 type ScreenshotReturn = (dataURL: string) => void
 
+/**
+ * A global namespace handling screenshot and GIF recording utilities.
+ */
 declare namespace Screencam {
 	/**
 	 * Provided preview with anti aliasing disabled that can be used for screenshots

package/types/settings.d.ts

@@ -1,7 +1,3 @@
-declare const settings: {
-    [id: string]: Setting
-};
-
 interface SettingOptions {
     name: string
     type?: 'number' | 'string' | 'boolean' | 'password' | 'select' | 'click'
@@ -21,10 +17,58 @@ interface SettingOptions {
     onChange?: (value: any) => void
 }
 
+/**
+ * Settings can be used to add global configuration options to Blockbench. All settings are listed under File > Preferences > Settings.
+ */
 declare class Setting extends Deletable {
     constructor(id: string, options: SettingOptions);
 
+    id: string
+    type: string
+    condition: any
+    /**
+     * The master value, not affected by profiles
+     */
+    master_value: any
+    /**
+     * The active value
+     */
+    value: any
+    /**
+     * The value that is displayed in the settings dialog
+     */
+    ui_value: any
+    name: string
+    description: string
+    category: string
+    /**
+     * If true, the setting can be used by the main process before initializing the Blockbench window. This is not available to custom settings created by plugins.
+     */
+    launch_setting: boolean
+    min?: number
+    max?: number
+    step?: number
+    icon?: string
+    options?: {
+        [id: string]: string
+    }
+    hidden?: boolean
+    onChange?: () => {}
+
+    /**
+     * Sets the value of the setting, while triggering the onChange function if available, and saving the change.
+     */
+    set(value): void
+    /**
+     * Triggers the setting, as if selected in action control. This toggles boolean settings, opens a dialog for string or numeric settings, etc.
+     */
+    trigger(event?: Event): void
+
+
 }
+/**
+ * Global namespace handling data and functionality related to settings.
+ */
 declare namespace Settings {
     const structure: {};
     const stored: {};
@@ -48,4 +92,8 @@ declare namespace Settings {
      * Returns the value of the specified setting
      */
     function get(setting_id: string): any;
-}
+}
+
+declare const settings: {
+    [id: string]: Setting
+};

package/types/shared_actions.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared Actions is a system in Blockbench to allow actions (including in toolbars, menus, via action control, or keybinding) to run different code in different cases, such as in different modes or different panels.
+ * As an example, the "Duplicate" action runs code to duplicate elements when used in the outliner, and duplicates textures when used in the textures panel.
+ * 
+ * 
+ * Handlers can be added for existing actions like this:
+
+### Example:
+
+```javascript
+	// Duplicate layers when using "Duplicate" in the layers panel
+	SharedActions.add('duplicate', {
+		subject: 'layer',
+		condition: () => Prop.active_panel == 'layers' && TextureLayer.selected,
+		run() {
+			let texture = Texture.selected;
+			let original = texture.getActiveLayer();
+			let copy = original.getUndoCopy(true);
+			copy.name += '-copy';
+			Undo.initEdit({textures: [texture]});
+			let layer = new TextureLayer(copy, texture);
+			layer.addForEditing();
+			Undo.finishEdit('Duplicate layer');
+		}
+	})
+```
+ * 
+ */
+declare namespace SharedActions {
+    const checks: {
+		[id: SharedActionID]: SharedActionHandler
+	}
+
+	/**
+	 * Add a new handler to a shared action
+	 * @param action_id Action ID
+	 * @param handler Handler options
+	 */
+	function add(action_id: SharedActionID, handler: SharedActionHandler): Deletable
+	/**
+	 * Run the active handler for a specific subject manually
+	 * @param action_id Action ID
+	 * @param event Event that triggered the interaction
+	 * @param context Optional context variable
+	 */
+	function run(action_id: SharedActionID, event?: Event, context?: any): boolean
+	/**
+	 * Run a specific handler manually
+	 * @param action_id Action ID
+	 * @param subject Subject to run on
+	 * @param event Event that triggered the interaction
+	 * @param context Optional context variable
+	 * @param force Force the specified handler to run and ignore its condition
+	 */
+	function runSpecific(action_id: SharedActionID, subject: string, event?: Event, context?: any, force?: boolean): boolean
+	/**
+	 * Check if there is an active and available handler in the current situation for a shared action
+	 * @param action_id 
+	 */
+	function condition(action_id: SharedActionID): boolean
+	/**
+	 * Find the active handler in the current situation for a shared action
+	 * @param action_id 
+	 * @param event 
+	 * @param context 
+	 */
+	function find(action_id: SharedActionID, event?: Event, context?: any): SharedActionHandler | null
+}
+
+interface SharedActionHandler {
+	priority: number
+	subject: string
+	condition: ConditionResolvable
+	run: (event?: Event, context?: any) => void
+}
+
+type SharedActionID = string | 'rename' | 'delete' | 'duplicate' | 'select_all' | 'unselect_all' | 'invert_selection'
+

package/types/texture_layers.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="three" />
+
+interface TextureLayerData {
+    name?: string
+    in_limbo?: boolean
+    offset?: ArrayVector2
+    scale?: ArrayVector2
+    opacity?: number
+    visible?: boolean
+    blend_mode?: 'default' | 'set_opacity' | 'color' | 'multiply' | 'add' | 'screen' | 'difference'
+    image_data?: ImageData
+    data_url?: string
+}
+
+/**
+ * Texture layers always belong to a texture and represent the layers of the texture. Each layer has its own HTML canvas and canvas context
+ */
+declare class TextureLayer {
+    constructor(data: TextureLayerData, texture: Texture, uuid?: string);
+
+    name: string
+    uuid: UUID
+    texture: Texture
+    canvas: HTMLCanvasElement
+    ctx: CanvasRenderingContext2D
+    in_limbo: boolean
+    img: HTMLImageElement
+    /**
+     * Layer offset from the top left corner of the texture to the top left corner of the layer
+     */
+    offset: ArrayVector2
+    /**
+     * Layer scale. This is only used by the layer transform tool and should be applied and reset to 1x1 before doing further changes
+     */
+    scale: ArrayVector2
+    opacity: number
+    visible: boolean
+    blend_mode: 'default' | 'set_opacity' | 'color' | 'multiply' | 'add' | 'screen' | 'difference'
+
+    extend(data: TextureLayerData): void
+    /**
+     * Selects the layer
+     */
+    select(): void
+    showContextMenu(event: Event): void
+    /**
+     * Remove the layer
+     * @param undo Create an undo point and update the texture
+     */
+    remove(undo: boolean): void
+    getUndoCopy(image_data: boolean): object
+    getSaveCopy(): object
+    /**
+     * Set the layer into a limbo state, where clicking Place or clicking next to the layer will place it on the layer below
+     */
+    setLimbo(): void
+    /**
+     * Resolves the limbo state by turning the limbo layer into a full layer, or merging it into the layer below
+     * @param keep_separate If true, the layer is kept as a separate layer
+     */
+    resolveLimbo(keep_separate): void
+    /**
+     * Set the layer size. This resizes the canvas, which discards the layer content
+     */
+    setSize(width: number, height: number): void
+    /**
+     * Toggle layer visibility. This creates an undo point
+     */
+    toggleVisibility(): void
+    /**
+     * Scroll the layer panel list to 
+     */
+    scrollTo(): void
+    /**
+     * Add the layer to the associated texture above the previously selected layer, select this layer, and scroll the layer panel list to it
+     */
+    addForEditing(): void
+    /**
+     * Merge this texture onto the texture below
+     * @param undo Create an undo entry
+     */
+    mergeDown(undo: boolean): void
+    /**
+     * Expand the layer to include the listed pixels
+     * @param points 
+     */
+    expandTo(...points: ArrayVector2): void
+    /**
+     * Flip the texture along an axis
+     * @param axis Flip axis, where 0 is X and 1 is Y
+     * @param undo Create an undo entry
+     */
+    flip(axis: number, undo): void
+    /**
+     * Rotate the layer around itself in 90 degree steps
+     * @param angle Angle in degrees
+     * @param undo Create an undo entry
+     */
+    rotate(angle: number, undo: boolean): void
+    /**
+     * Centers the layer on the texture
+     */
+    center(): void
+    /**
+     * Open the properties dialog
+     */
+    propertiesDialog(): void
+
+
+    /**
+     * Get all layers of the active texture
+     */
+    static all: TextureLayer[]
+    /**
+     * Get the selected layer
+     */
+    static selected: TextureLayer
+}