blockbench-types 4.6.0 → 4.8.0

package/types/mode.d.ts

@@ -11,18 +11,18 @@ interface ModeOptions {
 	hide_status_bar?: boolean
 	condition?: ConditionResolvable
 	component?: Vue.Component
-	onSelect?: () => void
-	onUnselect?: () => void
+	onSelect?(): void
+	onUnselect?(): void
 }
 declare class Mode extends KeybindItem {
 	constructor(id: string, options: ModeOptions)
 
 	/**Selects the mode */
-	select: () => void
+	select(): void
 	/**Unselects the mode */
-	unselect: () => void
+	unselect(): void
 	/**Activates the mode */
-	trigger: () => void
+	trigger(): void
 
 	static selected: Mode
 }

package/types/outliner.d.ts

@@ -9,47 +9,55 @@ type ArrayVector2 = [number, number]
 declare class OutlinerNode {
 	constructor ()
 	uuid: UUID
+	name: string
 	export: boolean
 	locked: boolean
 	parent: Group | 'root'
-	init: () => this
-	addTo: (target?: OutlinerNode) => this
-	sortInBefore: (target?: OutlinerNode, index_modifier?: number) => this
-	getParentArray: () => OutlinerNode[]
+	/**
+	 * Initializes the node. This should always be called when creating nodes that will be used in the outliner.
+	 */
+	init(): this
+	addTo(target?: OutlinerNode): this
+	sortInBefore(target?: OutlinerNode, index_modifier?: number): this
+	getParentArray(): OutlinerNode[]
 	/**
 	 * Unfolds the outliner and scrolls up or down if necessary to show the group or element.
 	 */
-	showInOutliner: () => this
+	showInOutliner(): this
 	/**
 	 * Updates the Vue node of the element. This is only necessary in some rare situations
 	 */
-	updateElement: () => this
+	updateElement(): this
 	/**
 	 * Removes the element.
 	 */
-	remove: () => this
+	remove(): this
 	/**
 	 * Marks the name of the group or element in the outliner for renaming.
 	 */
-	rename: () => this
+	rename(): this
 	/**
 	 * Saves the changed name of the element by creating an undo point and making the name unique if necessary.
 	 */
-	saveName: () => this
+	saveName(): this
 	/**
 	 * Create a unique name for the group or element by adding a number at the end or increasing it.
 	 */
-	createUniqueName: () => this
+	createUniqueName(): this
 	/**
 	 * Checks of the group or element is a child of `group`.
 	 * @param max_levels The maximum number of generations that can be between the element and the group
 	 */
-	isChildOf: ( group: Group, max_levels: number ) => boolean
+	isChildOf( group: Group, max_levels: number ): boolean
 	/**
 	 * Displays the context menu of the element
 	 * @param event Mouse event, determines where the context menu spawns.
 	 */
-	showContexnu: (event: Event | HTMLElement) => this
+	showContexnu(event: Event | HTMLElement): this
+
+	static uuids: {
+		[uuid: UUID]: OutlinerNode
+	}
 }
 
 /**
@@ -59,87 +67,11 @@ declare class OutlinerElement extends OutlinerNode {
 	constructor ()
 	selected: boolean
 	readonly mesh: THREE.Object3D | THREE.Mesh
-	getMesh: () => THREE.Object3D | THREE.Mesh
+	getMesh(): THREE.Object3D | THREE.Mesh
 	static fromSave: (data: object, keep_uuid?: boolean) => OutlinerElement
 	static isParent: false
 }
 
-interface GroupOptions {
-	/**Group name */
-	name: string
-	/**Array of the group pivot point */
-	origin: ArrayVector3
-	/**Array of the group rotation */
-	rotation: ArrayVector3
-	/**If a bone, whether to reset the informations of inherited bones in bedrock edition. */
-	reset: boolean
-	/**Whether to shade the contents of the group */
-	shade: boolean
-	/**Whether the group is selected */
-	selected: boolean
-	/**Whether the group is visible */
-	visibility: boolean
-	/**Whether to export the entire group */
-	export: boolean
-	/**Auto UV setting for the children. Can be 0, 1 or 2. */
-	autouv: 0 | 1 | 2
-}
-
-declare class Group extends OutlinerNode {
-	constructor (options: Partial<GroupOptions>)
-	static selected: Group
-	static all: Group[]
-
-	name: string
-	children: OutlinerNode[]
-	origin: ArrayVector3
-	rotation: ArrayVector3
-	reset: boolean
-	shade: boolean
-	selected: boolean
-	visibility: boolean
-	autouv: 1 | 2 | 3
-	isOpen: boolean
-	ik_enabled: boolean
-	ik_chain_length: number
-
-	extend: (options: Partial<GroupOptions>) => this
-	selectChildren: (event: Event) => this
-	selectLow: (highlight: boolean) => this
-	unselect: () => this
-	matchesSelection: () => boolean
-	/**
-	 * Opens theOpens the group and all of its ancestor groups.
-	 */
-	openUp: () => this
-	/**
-	 * Removes the group
-	 * @param undo If true, an undo point will be created.
-	 */
-	remove: (undo?: boolean) => this
-	/**
-	 * Remove the group and leave all of its children in the parent array.
-	 */
-	resolve: () => OutlinerNode[]
-	/**
-	 * Move the origin of a bone to a specific location without visually affecting the position of it's content.
-	 */
-	transferOrigin: (origin: ArrayVector3) => this
-	/**
-	 * Sort the content of the group alphabetically. This will automatically create an undo point.
-	 */
-	sortContent: () => this
-	/**
-	 * Duplicate the group
-	 */
-	duplicate: () => Group
-	getSaveCopy: () => object
-	getChildlessCopy: () => Group
-	compile: (undo: boolean) => object
-	forEachChild(callback: (object: OutlinerNode) => void, type?: any, for_self?: boolean)
-}
-
-
 interface LocatorOptions {
 	name: string
 	from: ArrayVector3
@@ -154,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
 }
 
 
@@ -176,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
@@ -9,9 +11,9 @@ declare namespace Painter {
 	const erase_mode: boolean
 	const default_brush_presets: object[]
 
-	function edit(texture: Texture, callback: (canvas: HTMLCanvasElement) => void, options: TextureEditOptions)
-	function setAlphaMatrix(texture: Texture, x, y, val)
-	function getAlphaMatrix(texture: Texture, x, y)
+	function edit(texture: Texture, callback: (canvas: HTMLCanvasElement) => void, options: TextureEditOptions): void
+	function setAlphaMatrix(texture: Texture, x: number, y: number, val: number): void
+	function getAlphaMatrix(texture: Texture, x: number, y: number): number
 
 	function combineColors(base: RGBAColor, added: RGBAColor, opacity: number): RGBAColor
 	function blendColors(base: RGBAColor, added: RGBAColor, opacity: number, blend_mode: string): RGBAColor

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
@@ -22,30 +24,43 @@ interface PanelOptions {
 	default_side: 'right' | 'left'
 	insert_before: string
 	insert_after: string
-	onResize: () => void
-	onFold: () => void
+	onResize(): void
+	onFold(): void
 }
 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

@@ -30,6 +30,10 @@ 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
+	/**
+	 * 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
 	 */
@@ -47,6 +51,10 @@ interface PluginOptions {
 	 */
 	onuninstall?(): void
 }
+
+/**
+ * A Blockbench plugin. "BBPlugin" is the Typescript alias to the regular name "Plugin", which is also valid in Javascript projects.
+ */
 declare class BBPlugin {
 	constructor(id: string, options: PluginOptions)
 

package/types/preview.d.ts

@@ -23,6 +23,9 @@ type RaycastResult = {
     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)
 
@@ -82,13 +85,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
@@ -48,6 +51,11 @@ declare namespace Screencam {
 
 	function returnScreenshot(dataUrl, cb: ScreenshotReturn, blob): void
 
+	/**
+	 * Runs callback in a clean canvas, where only the model is visible and the control gizmos are hidden
+	 * @param options 
+	 * @param cb 
+	 */
 	function cleanCanvas(options, cb: ScreenshotReturn): void
 
 	function createGif(options: RecordGIFOptions, cb: ScreenshotReturn): void

package/types/settings.d.ts

@@ -1,12 +1,8 @@
-declare const settings: {
-    [id: string]: Setting
-};
-
 interface SettingOptions {
     name: string
     type?: 'number' | 'string' | 'boolean' | 'password' | 'select' | 'click'
     value: boolean | number | string
-    condition?: any
+    condition?: ConditionResolvable
     category: string
     description?: string
     //launch_setting?: boolean
@@ -14,38 +10,90 @@ interface SettingOptions {
     max?: number
     step?: number
     icon?: string
-    click?: () => void
+    click?(): void
     options?: {
         [id: string]: string
     }
     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
+
+
 }
-declare const Settings: {
-    structure: {};
-    stored: {};
+/**
+ * Global namespace handling data and functionality related to settings.
+ */
+declare namespace Settings {
+    const structure: {};
+    const stored: {};
     /**
      * Opens the settings dialog
      * @param options 
      */
-    open(options?: Partial<{
+    function open(options?: Partial<{
         search: string
         tab: 'setting' | 'keybindings' | 'layout_settings' | 'credits'
     }>): void;
     /**
      * Save all settings to the local storage
      */
-    saveLocalStorages(): void;
+    function saveLocalStorages(): void;
     /**
      * Save the settings and apply changes
      */
-    save(): void;
+    function save(): void;
     /**
      * Returns the value of the specified setting
      */
-    get(setting_id: string): any;
+    function get(setting_id: string): any;
+}
+
+declare const settings: {
+    [id: string]: Setting
 };

package/types/textures.d.ts

@@ -38,12 +38,61 @@ interface TextureEditOptions {
     no_undo_finish?: boolean
 }
 
+/**
+ * A texture combines the functionality of material, texture, and image, in one. Textures can be linked to files on the local hard drive, or hold the information in RAM.
+ */
 declare class Texture {
     constructor(data: TextureData, uuid?: string);
     readonly frameCount: number | undefined;
     readonly display_height: number;
     readonly ratio: number;
 
+    path: string
+    name: string
+    /** Relative path to the file's directory, used by some formats such as Java Block/Item*/
+    folder: string
+    namespace: string
+    /** Texture ID or key, used by some formats. By default this is a number that increases with every texture that is added */
+    id: string
+    /** Whether the texture is used for the models particle system. Used by some formats such as Java Block/Item */
+    particle: boolean
+    render_mode: 'default' | 'emissive' | 'additive' | 'layered' | string
+    render_sides: 'auto' | 'front' | 'double' | string
+
+    /** Texture animation frame time */
+    frame_time: number
+    frame_order_type: 'custom' | 'loop' | 'backwards' | 'back_and_forth'
+    /** Custom frame order */
+    frame_order: string
+    /** Interpolate between frames */
+    frame_interpolate: boolean
+
+    /** HTML-style source of the texture's displayed data. Can be a path (desktop app only), or a base64 data URL */
+    source: string
+    selected: boolean
+    show_icon: boolean
+    error: number
+    /** Whether the texture is visible. Used for layered textures mode */
+    visible: boolean
+    /** Whether the texture canvas is displayed in the UV/2D editor, for live feedback */
+    display_canvas: boolean
+    width: number
+    height: number
+    currentFrame: number
+    saved: boolean
+    /** Whether the latest version of the texture is currently loaded from and linked to a file on disk, or held in memory as bitmap data */
+    mode: 'link' | 'bitmap'
+    uuid: UUID
+
+    /**
+     * The texture's associated canvas. Note: This may not always be up to date with the texture data
+     */
+    canvas: HTMLCanvasElement
+    /**
+     * Texture image element
+     */
+    img: HTMLImageElement
+
     getErrorMessage(): string;
     extend(data: TextureData): this;
     /**
@@ -80,7 +129,7 @@ declare class Texture {
      * Adds texture to the textures list and initializes it
      * @param undo If true, an undo point is created
      */
-    add(undo?: boolean): any;
+    add(undo?: boolean): Texture;
     /**
      * Removes the texture
      * @param no_update If true, the texture is silently removed. The interface is not updated, no undo point is created
@@ -126,7 +175,7 @@ declare class Texture {
     menu: Menu
 
     static all: Texture[]
-    static getDefault: () => Texture
+    static getDefault(): Texture
 }
 /**
  * Saves all textures

package/types/timeline.d.ts

@@ -1,8 +1,11 @@
 declare namespace Timeline {
-    const animators: object[]
+    const animators: GeneralAnimator[]
     const selected: Keyframe[]
     const playing_sounds: any[]
     let playback_speed: number
+    /**
+     * Current time
+     */
     let time: number
     let playing: boolean
 

package/types/undo.d.ts

@@ -1,14 +1,27 @@
 interface UndoAspects {
     selection?: boolean
     elements?: OutlinerElement[]
+    /**
+     * Saves the entire outliner structure and hierarchy, including all groups. This is required when adding, or removing any elements, or changing their position in the outliner.
+     */
     outliner?: boolean
+    /**
+     * Saves an individual group, but not it's children or hierarchy position
+     */
     group?: Group
+    /**
+     * Textures to save
+     */
     textures?: Texture[]
     texture_order?: boolean
+    /**
+     * Save which texture is selected
+     */
     selected_texture?: boolean
     settings?: {}
     uv_mode?: boolean
     animations?: Animation[]
+    animation_controllers?: AnimationController[]
     keyframes?: Keyframe[]
     display_slots?: string[]
     exploded_view?: boolean
@@ -42,11 +55,11 @@ type UndoEntry = {
 }
 interface AmendEditForm {
     condition?: ConditionResolvable
-    type?: 'number'
+    type?: 'number' | 'checkbox'
     label: string
     interval_type: 'position' | 'rotation'
     getInterval?: (Event) => number
-    value?: number | string,
+    value?: number | string | 'boolean',
     min?: number,
     max?: number,
     step?: number,
@@ -58,17 +71,12 @@ declare class UndoSystem {
      * Starts an edit to the current project by saving the state of the provided aspects
      * @param aspects Aspects to save
      */
-    initEdit(aspects: UndoAspects): any;
+    initEdit(aspects: UndoAspects): UndoEntry;
     /**
      * Finishes an edit by saving the state of the project after it was changed
      * @param action Description of the edit
      */
-    finishEdit(action: string, aspects?: UndoAspects): {
-        before: any;
-        post: any;
-        action: any;
-        time: number;
-    };
+    finishEdit(action: string, aspects?: UndoAspects): UndoEntry;
     /**
      * Cancels an event before it was finished and reset the project to the state before
      */
@@ -104,6 +112,18 @@ declare class UndoSystem {
     loadSave(save: UndoSave, reference: UndoSave, mode?: 'session'): void;
 }
 /**
- * Blockbench's system to register edits to the project and switch between them
+ * Blockbench's undo system of the current project to register edits to the project and switch between them
+
+## Example
+
+```javascript
+Undo.initEdit({elements: []});
+
+var new_cube = new Cube({name: 'kevin'}).init();
+var other_cube = new Cube({name: 'lars'}).init();
+
+Undo.finishEdit('add new cubes', {elements: [new_cube, other_cube]});
+```
  */
 declare let Undo: UndoSystem;
+