blockbench-types 4.11.1 → 4.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blockbench-types",
-	"version": "4.11.1",
+	"version": "4.12.0",
 	"description": "Blockbench typescript types",
 	"main": "",
 	"types": "types/index.d.ts",
@@ -30,7 +30,7 @@
 		"@types/three": "^0.129.2",
 		"@types/tinycolor2": "^1.4.6",
 		"dompurify": "^3.0.1",
-		"electron": "^31.4.0",
+		"electron": "^33.3.1",
 		"prismjs": "^1.29.0",
 		"tinycolor2": "^1.6.0",
 		"typescript": "^4.9.5",

package/scripts/generate_docs.js

@@ -25,6 +25,7 @@ async function main() {
 			'./types/blockbench.d.ts',
 			'./types/textures.d.ts',
 			'./types/texture_layers.d.ts',
+			'./types/texture_group.d.ts',
 			'./types/action.d.ts',
 			'./types/animation.d.ts',
 			'./types/animation_controller.d.ts',
@@ -39,6 +40,7 @@ async function main() {
 			'./types/legacy.d.ts',
 			'./types/menu.d.ts',
 			'./types/outliner.d.ts',
+			'./types/collection.d.ts',
 			'./types/group.d.ts',
 			'./types/cube.d.ts',
 			'./types/mesh.d.ts',

package/types/action.d.ts

@@ -11,31 +11,114 @@ declare interface KeybindKeys {
 	 * Main key, can be a numeric keycode or a lower case character
 	 */
 	key: number | string
-	ctrl?: boolean | null
-	shift?: boolean | null
-	alt?: boolean | null
-	meta?: boolean | null
+	ctrl?: boolean
+	shift?: boolean
+	alt?: boolean
+	meta?: boolean
 }
+type VariationModifier = 'always' | 'ctrl' | 'shift' | 'alt' | 'meta' | 'unless_ctrl' | 'unless_shift' | 'unless_alt'
+type ModifierKey = 'ctrl' | 'shift' | 'alt' | 'meta'
 /**
  * A customizable keybind
  */
 declare class Keybind {
-	constructor(keys: KeybindKeys)
+	/**
+	 * Create a keybind
+	 * @param {object} keys Set up the default keys that need to be pressed
+	 * @param {number|string} keys.key Main key. Check keycode.info to find out the numeric value, or simply use letters for letter keys
+	 * @param {boolean} keys.ctrl Control key. On MacOS this automatically works for Cmd
+	 * @param {boolean} keys.shift Shift key
+	 * @param {boolean} keys.alt Alt key
+	 * @param {boolean} keys.meta Meta key
+	 */
+	constructor(keys: KeybindKeys, variations?: Record<string, VariationModifier>)
 	key: number
 	ctrl?: boolean
 	shift?: boolean
 	alt?: boolean
+	variations?: {
+		[key: string]: {name: string, description?: string}
+	}
+	set(keys: KeybindKeys): this;
+	/**
+	 * Unassign the assigned key
+	 */
+	clear(): this;
+	/**
+	 * Save any changes to local storage
+	 * @param save Save all keybinding changes to local storage. Set to fales if updating multiple at once
+	 */
+	save(save?: false): this;
+	/**
+	 * Assign an action to the keybind
+	 * @param id ID of the action
+	 * @param sub_id sub keybind ID
+	 */
+	setAction(id: string, sub_id?: string): this | undefined;
+	/**
+	 * Get display text showing the keybind
+	 * @param formatted If true, the return string will include HTML formatting
+	 */
+	getText(formatted?: boolean): string;
 	/**
 	 * Get the name of the bound key
 	 */
-	getCode(): string
+	getCode(key: string): string
+	/**
+	 * Check if a key is assigned
+	 */
+	hasKey(): boolean;
+	/**
+	 * Test if the keybind would be triggered by the event
+	 */
+	isTriggered(event: Event): boolean;
+	/**
+	 * Test which variation would be triggered by the event. Returns the ID of the variation if triggered
+	 * @param event The event to test
+	 */
+	additionalModifierTriggered(event: Event): string | undefined;
+	/**
+	 * Test if a variation would be triggered by the event
+	 * @param event The event to test
+	 * @param variation The variation to test againts
+	 */
+	additionalModifierTriggered(event: Event, variation: string): boolean;
+	/**
+	 * Open a UI to let the user record a new key combination
+	 */
+	record(): this;
+	/**
+	 * Stop recording a new key combination
+	 */
+	stopRecording(): this;
+	/**
+	 * Returns the label of the keybinding
+	 */
+	toString(): string;
+
+	/**
+	 * Load an included keymap by ID
+	 * @param id 
+	 * @param from_start_screen 
+	 */
+	static loadKeymap(id: string, from_start_screen?: boolean): void | true
+	/**
+	 * Check if two KeybindItems are mutually exclusive, so only one can be available at the time. This is only the case if they each have a ConditionResolvable that is structured to support this
+	 */
+	static no_overlap(k1: KeybindItem, k2: KeybindItem): boolean
 }
 interface KeybindItemOptions {
 	keybind?: Keybind
+	variations?: {
+		[key: string]: {name: string, description?: string}
+	}
 }
 declare class KeybindItem extends Deletable {
 	constructor(id: string, options: KeybindItemOptions)
 	keybind: Keybind
+	variations?: {
+		[key: string]: {name: string, description?: string}
+	}
 }
 
 declare class MenuSeparator {
@@ -142,6 +225,14 @@ interface ActionOptions extends BarItemOptions {
 	 * Show the full label in toolbars
 	 */
 	label?: boolean
+	/**
+	 * Provide a menu that belongs to the action, and gets displayed as a small arrow next to it in toolbars.
+	 */
+	side_menu?: Menu
+	/**
+	 * Provide a window with additional configutation related to the action
+	 */
+	tool_config?: ToolConfig
 }
 /**
  * Actions can be triggered to run something, they can be added to menus, toolbars, assigned a keybinding, or run via Action Control
@@ -152,7 +243,11 @@ declare class Action extends BarItem {
 	/**
 	 * Provide a menu that belongs to the action, and gets displayed as a small arrow next to it in toolbars.
 	 */
-	side_menu?: Menu
+	side_menu?: Menu | ToolConfig
+	/**
+	 * Provide a window with additional configutation related to the action
+	 */
+	tool_config?: ToolConfig
 	click: ActionOptions['click']
 
 	condition?(): boolean

package/types/blockbench.d.ts

@@ -5,6 +5,7 @@
 /// <reference types="wintersky" />
 
 /// <reference types="./texture_layers" />
+/// <reference types="./texture_group" />
 /// <reference types="./action" />
 /// <reference types="./animation" />
 /// <reference types="./animation_controller" />
@@ -29,6 +30,7 @@
 /// <reference types="./mode" />
 /// <reference types="./molang" />
 /// <reference types="./outliner" />
+/// <reference types="./collection" />
 /// <reference types="./painter" />
 /// <reference types="./panel" />
 /// <reference types="./plugin" />
@@ -392,6 +394,7 @@ type BlockbenchTypeFace = typeof Face
 type BlockbenchTypeCubeFace = typeof CubeFace
 type BlockbenchTypeMeshFace = typeof MeshFace
 type BlockbenchTypeNodePreviewController = typeof NodePreviewController
+type BlockbenchTypeCollection = typeof Collection
 type BlockbenchTypeAnimator = typeof Animator
 type BlockbenchTypeTimeline = typeof Timeline
 type BlockbenchTypeAnimationItem = typeof AnimationItem
@@ -452,6 +455,7 @@ declare namespace Blockbench {
 	const CubeFace: BlockbenchTypeCubeFace
 	const MeshFace: BlockbenchTypeMeshFace
 	const NodePreviewController: BlockbenchTypeNodePreviewController
+	const Collection: BlockbenchTypeCollection
 	const Animator: BlockbenchTypeAnimator
 	const Timeline: BlockbenchTypeTimeline
 	const AnimationItem: BlockbenchTypeAnimationItem

package/types/codec.d.ts

@@ -14,6 +14,8 @@ interface CodecOptions {
 	overwrite?(content: any, path: string, callback: (path: any) => void): void
 	afterDownload?(path: any): void
 	afterSave?(path: any): void
+	exportCollection?(collection: Collection): void
+	writeCollection?(collection: Collection): void
 
 	dispatchEvent?(event_name: string, data: any): void
 
@@ -31,7 +33,7 @@ interface CodecOptions {
 	 * List of export option inputs, based on the Dialog form API
 	 */
 	export_options?: {
-		[key: string]: DialogFormElement
+		[key: string]: FormElement
 	}
 	/**
 	 * Default action that is used to export to the codec
@@ -89,6 +91,8 @@ declare class Codec extends Deletable {
 	overwrite(content: any, path: string, callback: (path: string) => void): void
 	afterDownload(path: string): void
 	afterSave(path: string): void
+	exportCollection(collection: Collection): void
+	writeCollection(collection: Collection): void
 
 	/**
 	 * Return the stored export option values of the current project
@@ -140,7 +144,7 @@ declare class Codec extends Deletable {
 	 * List of export option inputs
 	 */
 	export_options: {
-		[key: string]: DialogFormElement
+		[key: string]: FormElement
 	}
 
 	format: ModelFormat

package/types/collection.d.ts

@@ -0,0 +1,76 @@
+interface CollectionOptions {
+	children?: string[]
+	name?: string
+	export_codec?: string
+	export_path?: string
+	visibility?: boolean
+}
+
+/**
+ * Collections are "selection presets" for a set of groups and elements in your project, independent from outliner hierarchy
+ */
+declare class Collection {
+    constructor(data?: CollectionOptions, uuid?: string);
+
+	selected: boolean
+	/**
+	 * List of direct children, referenced by UUIDs
+	 */
+	children: string[]
+	name: string
+	export_codec: string
+	export_path: string
+	visibility: boolean
+
+    extend(data: CollectionOptions): this;
+    select(event?: Event): this;
+    clickSelect(event: Event): void;
+	/**
+	 * Get all direct children
+	 */
+    getChildren(): OutlinerNode[];
+    add(): this;
+	/**
+	 * Adds the current outliner selection to this collection
+	 */
+    addSelection(): this;
+	/**
+	 * Returns the visibility of the first contained node that supports visibility. Otherwise returns true.
+	 */
+    getVisibility(): boolean;
+	/**
+	 * Get all children, including indirect ones
+	 */
+    getAllChildren(): any[];
+	/**
+	 * Toggle visibility of everything in the collection
+	 * @param event If the alt key is pressed, the result is inverted and the visibility of everything but the collection will be toggled
+	 */
+    toggleVisibility(event: Event): void;
+	/**
+	 * Opens the context menu
+	 */
+    showContextMenu(event: Event): this;
+    getUndoCopy(): {
+        uuid: string;
+        index: number;
+		[key: string]: any;
+    };
+    getSaveCopy(): {
+        uuid: string;
+		[key: string]: any;
+    };
+	/**
+	 * Opens the properties dialog
+	 */
+    propertiesDialog(): void;
+
+	/**
+	 * Get all collections
+	 */
+	static all(): Collection[]
+	/**
+	 * Get selected collections
+	 */
+	static selected(): Collection[]
+}

package/types/dialog.d.ts

@@ -1,4 +1,4 @@
-interface DialogFormElement {
+interface FormElement {
 	label?: string
 	/**
 	 * Detailed description of the field, available behind the questionmark icon or on mouse hover
@@ -17,7 +17,10 @@ interface DialogFormElement {
 		| 'file'
 		| 'folder'
 		| 'save'
+		| 'inline_select'
+		| 'inline_multi_select'
 		| 'info'
+		| 'num_slider'
 		| 'buttons'
 	/**
 	 * If true, the label will be displayed without colon at the end
@@ -73,7 +76,20 @@ interface DialogFormElement {
 	 * Available options on select or inline_select inputs
 	 */
 	options?: { [key: string]: string | { name: string } }
+	/**
+	 * List of buttons for the button type
+	 */
 	buttons?: string[]
+
+	/**
+	 * Function to get the interval value for a num_slider based on the input event
+	 * @returns Interval value
+	 */
+	getInterval?: (event: Event) => number
+	/**
+	 * For num_sliders, the sliding interval mode
+	 */
+	interval_type?: 'position' | 'rotation'
 	/**
 	 * Allow users to toggle the entire option on or off
 	 */
@@ -91,6 +107,44 @@ interface DialogFormElement {
 
 type FormResultValue = string | number | boolean | []
 
+type InputFormConfig = {
+	[formElement: string]: '_' | FormElement
+}
+
+declare class InputForm {
+	constructor(form_config: InputFormConfig)
+	form_config: InputFormConfig
+	form_data: {[formElement: string]: {}}
+	node: HTMLDivElement
+	max_label_width: number
+	uses_wide_inputs: boolean
+	/**
+	 * Set the values of some or all form inputs
+	 * @param values The values to set
+	 * @param update Set to false to prevent triggering an update
+	 */
+	setValues(values: Record<string, FormResultValue>, update?: boolean): void
+	/**
+	 * Set the values of some or all form input toggles
+	 * @param values The toggle values to set
+	 * @param update Set to false to prevent triggering an update
+	 */
+	setToggles(values: Record<string, boolean>, update?: boolean): void
+	/**
+	 * Get the form result values
+	 */
+	getResult(): Record<string, FormResultValue>
+	/**
+	 * Register that the values have been changed. This should generally only be used internally
+	 * @param initial Indicate that the change is for the initial setup of the form, prevents dispatching a change event
+	 */
+	updateValues(initial: boolean): Record<string, FormResultValue>
+	/**
+	 * Returns the default value of a given form input
+	 */
+	static getDefaultValue(input_config: FormElement): FormResultValue
+}
+
 interface ActionInterface {
 	name: string
 	description?: string
@@ -150,9 +204,7 @@ interface DialogOptions {
 	/**
 	 * Creates a form in the dialog
 	 */
-	form?: {
-		[formElement: string]: '_' | DialogFormElement
-	}
+	form?: InputFormConfig
 	/**
 	 * Vue component
 	 */
@@ -234,6 +286,7 @@ declare class Dialog {
 	component: Vue.Component
 	sidebar: DialogSidebar | null
 	content_vue: Vue | null
+	form: InputForm | null
 	progress_bar?: {
 		/**
 		 * The current progress
@@ -386,6 +439,30 @@ declare class ShapelessDialog extends Dialog {
 	delete(): void
 }
 
+interface ToolConfigOptions extends DialogOptions {}
+
+declare class ToolConfig extends Dialog {
+	constructor(id: string, options: ToolConfigOptions)
+
+	options: {
+		[key: string]: FormResultValue
+	}
+	/**
+	 * Change and save a number of options in the config
+	 * @param options Options to set
+	 */
+	changeOptions(options: Record<string, FormResultValue>): void
+	/**
+	 * Save any changes in local storage
+	 */
+	save(): void
+	/**
+	 * Open the config menu
+	 * @param anchor Optional element to anchor the menu to
+	 */
+	show(anchor?: HTMLElement): this
+}
+
 interface DialogSidebarOptions {
 	pages?: {
 		[key: string]: string | { label: string; icon: IconString; color?: string }

package/types/format.d.ts

@@ -61,110 +61,196 @@ interface FormatOptions {
 	onSetup?(project: ModelProject, newModel?: boolean): void
 	convertTo?(): void
 
-	box_uv?: boolean
-	optional_box_uv?: boolean
-	single_texture?: boolean
-	single_texture_default?: boolean
-	per_group_texture?: boolean
-	per_texture_uv_size?: boolean
-	model_identifier?: boolean
-	legacy_editable_file_name?: boolean
-	parent_model_id?: boolean
-	vertex_color_ambient_occlusion?: boolean
-	animated_textures?: boolean
-	bone_rig?: boolean
-	centered_grid?: boolean
-	rotate_cubes?: boolean
-	stretch_cubes?: boolean
-	integer_size?: boolean
-	meshes?: boolean
-	texture_meshes?: boolean
-	locators?: boolean
-	rotation_limit?: boolean
-	rotation_snap?: boolean
-	uv_rotation?: boolean
-	java_face_properties?: boolean
-	select_texture_for_particles?: boolean
-	texture_mcmeta?: boolean
-	bone_binding_expression?: boolean
-	animation_files?: boolean
-	texture_folder?: boolean
-	image_editor?: boolean
-	edit_mode?: boolean
-	paint_mode?: boolean
-	display_mode?: boolean
-	animation_mode?: boolean
-	pose_mode?: boolean
-	animation_controllers?: boolean
-	box_uv_float_size?: boolean
-	java_cube_shading_properties?: boolean
-	cullfaces?: boolean
-	render_sides?: 'front' | 'double' | 'back' | (() => ('front' | 'double' | 'back'))
-
-	cube_size_limiter?: CubeSizeLimiter
-
-	codec?: Codec
-	onActivation?(): void
-	onDeactivation?(): void
-}
-
-declare class ModelFormat extends Deletable {
-	constructor(id: string, options: FormatOptions)
-	constructor(options: FormatOptions)
-
-	id: string
-	icon: string
-	name: string
-	description: string
-	category: string
-	target: string | string[]
-	confidential: boolean
-	condition?: ConditionResolvable
-	show_on_start_screen: boolean
-	format_page?: FormatPage
-	onFormatPage?(): void
-	onStart?(): void
-	onSetup?(): void
-
+	/**
+	 * Enables Box UV on cubes by default
+	 */
 	box_uv: boolean
+	/**
+	 * If true, box UV is optional and can be toggled on the project or per cube
+	 */
 	optional_box_uv: boolean
+	/**
+	 * If true, only one texture can be assigned to the model at a time, instead of textures being assigned per face
+	 */
 	single_texture: boolean
-	single_texture_default?: boolean
-	per_group_texture?: boolean
-	per_texture_uv_size?: boolean
+	/**
+	 * If true, a single texture is used as default, but textures can still be assigned to faces
+	 */
+	single_texture_default: boolean
+	/**
+	 * If true, textures can be assigned per group instead of per face
+	 */
+	per_group_texture: boolean
+	/**
+	 * If true, UV size (the size of the texture in UV space) will be defined per texture and not per project
+	 */
+	per_texture_uv_size: boolean
+	/**
+	 * Enable a model identifier field in the project settings. Default is true
+	 */
 	model_identifier: boolean
-	legacy_editable_file_name?: boolean
+	/**
+	 * If true, the file name of a project will be editable in the project settings
+	 */
+	legacy_editable_file_name: boolean
+	/**
+	 * If true, enables a field in the project settings to set a parent model ID
+	 */
 	parent_model_id: boolean
+	/**
+	 * Adds a toggle in the project settings to enable project wide vertex color ambient occlusion
+	 */
 	vertex_color_ambient_occlusion: boolean
+	/**
+	 * Enable flipbook animated textures
+	 */
 	animated_textures: boolean
+	/**
+	 * Enable groups to work as bones and rig the model
+	 */
 	bone_rig: boolean
+	/**
+	 * Align the grid center with the model origin, instead of the grid corner
+	 */
 	centered_grid: boolean
+	/**
+	 * Add the ability to rotate cubes
+	 */
 	rotate_cubes: boolean
+	/**
+	 * Add the ability to stretch cubes. Stretch scales cubes from the center without affecting UV
+	 */
 	stretch_cubes: boolean
+	/**
+	 * If true, cube sizes are limited to integer values
+	 */
 	integer_size: boolean
+	/**
+	 * Enable mesh elements
+	 */
 	meshes: boolean
+	/**
+	 * Enable texture meshes
+	 */
 	texture_meshes: boolean
+	/**
+	 * Enable locators
+	 */
 	locators: boolean
+	/**
+	 * Enforces a rotation limit for cubes of up to 45 degrees in either direction and one axis at a time
+	 */
 	rotation_limit: boolean
+	/**
+	 * Forces cube rotations to snap to 22.5 degree increments
+	 */
 	rotation_snap: boolean
+	/**
+	 * Allows cube UVs to be rotated
+	 */
 	uv_rotation: boolean
+	/**
+	 * Enables Minecraft Java block/item model specific cube face features (tint and export)
+	 */
 	java_face_properties: boolean
+	/**
+	 * Allows assigning one texture to be used as a texture for particles related to the model
+	 */
 	select_texture_for_particles: boolean
+	/**
+	 * Enable mcmeta files for animated texture files
+	 */
 	texture_mcmeta: boolean
+	/**
+	 * Enables an option to set an expression for bone bindings
+	 */
 	bone_binding_expression: boolean
+	/**
+	 * If true, animations will be saved into files
+	 */
 	animation_files: boolean
+	/**
+	 * Enables a folder path per texture that can be set in the texture properties window
+	 */
 	texture_folder: boolean
+	/**
+	 * Enables the 2D image editor
+	 */
 	image_editor: boolean
+	/**
+	 * Enables edit mode. Default is true
+	 */
 	edit_mode: boolean
+	/**
+	 * Enables paint mode. Default is true
+	 */
 	paint_mode: boolean
+	/**
+	 * Enables display mode
+	 */
 	display_mode: boolean
+	/**
+	 * Emaböes animation mode
+	 */
 	animation_mode: boolean
+	/**
+	 * Enables pose mode
+	 */
 	pose_mode: boolean
+	/**
+	 * Enables animation controllers
+	 */
+	animation_controllers: boolean
+	/**
+	 * If true, cube sizes will not be floored to calculate UV sizes with box UV. This can result in UVs not aligning with pixel edges
+	 */
 	box_uv_float_size: boolean
+	/**
+	 * Enables properties for Minecraft Java block/item models related to block shading (shading option and light emission value)
+	 */
 	java_cube_shading_properties: boolean
+	/**
+	 * Enables cullfaces, the ability on faces in Minecraft block models to set a direction, that, if covered by another block, will cause the face to unrender
+	 */
 	cullfaces: boolean
-	animation_controllers: boolean
+	/**
+	 * A set of characters that is allowed in node names (names of elements and groups that can be referenced externally, this does not apply to cubes or meshes)
+	 */
+	node_name_regex: string
+	/**
+	 * Set the default render sides for textures
+	 */
 	render_sides: 'front' | 'double' | 'back' | (() => ('front' | 'double' | 'back'))
+
+	/**
+	 * Options to limit the size of cubes
+	 */
+	cube_size_limiter?: CubeSizeLimiter
+
+	codec?: Codec
+	onActivation?(): void
+	onDeactivation?(): void
+}
+interface ModelFormat extends FormatOptions {}
+
+declare class ModelFormat extends Deletable implements FormatOptions {
+	constructor(id: string, options: Partial<FormatOptions>)
+	constructor(options: Partial<FormatOptions>)
+
+	id: string
+	icon: string
+	name: string
+	description: string
+	category: string
+	target: string | string[]
+	confidential: boolean
+	condition?: ConditionResolvable
+	show_on_start_screen: boolean
+	format_page?: FormatPage
+	onFormatPage?(): void
+	onStart?(): void
+	onSetup?(): void
+
 	
 
 	codec?: Codec

package/types/global.d.ts

@@ -4,7 +4,6 @@ declare global {
 	const Prism: typeof import('prismjs')
 	const scene: THREE.Scene
 	const Transformer: any
-	const DOMPurify: typeof import('dompurify')
 	const electron: typeof import('electron')
 	const { clipboard, shell, nativeImage, ipcRenderer, dialog }: typeof electron
 
@@ -17,6 +16,7 @@ declare global {
 	const fs: typeof import('fs')
 
 	const tinycolor: typeof import('tinycolor2')
+	const DOMPurify: typeof import('dompurify')
 
 	let selected: OutlinerElement[]
 	const Toolbars: Record<string, Toolbar>

package/types/group.d.ts

@@ -21,7 +21,22 @@ interface GroupOptions {
 
 declare class Group extends OutlinerNode {
 	constructor(options: Partial<GroupOptions> | string)
+	/**
+	 * Returns the first selected group. Depretated, use Group.multi_selected. In the future this will return an array of selected groups instead.
+	 * @deprecated
+	 */
 	static selected: Group
+	/**
+	 * The group that's the first in the list of selected groups
+	 */
+	static first_selected: Group
+	/**
+	 * The list of selected groups. Note that this only includes directly selected groups, not groups that are selected because the parent is selected
+	 */
+	static multi_selected: Group
+	/**
+	 * All groups in the current project
+	 */
 	static all: Group[]
 	static animator: BoneAnimator
 	/**Check if any groups are in the project */

package/types/menu.d.ts

@@ -16,7 +16,7 @@ interface CustomMenuItem {
 	children?: MenuItem[] | (() => MenuItem[])
 	click?(context?: any, event?: Event): void
 }
-type MenuItem = CustomMenuItem | Action | BarSelect | MenuSeparator | string
+type MenuItem = CustomMenuItem | Action | BarSelect<string> | MenuSeparator | string
 interface MenuOptions {
 	onOpen?(position: MouseEvent | HTMLElement, context?: any): void
 	onClose?(): void

package/types/mesh.d.ts

@@ -35,8 +35,10 @@ declare class MeshFace extends Face {
 	extend(data: MeshFaceOptions): void
 	/**
 	 * Returns the face normal in mesh space as calculated from the vertex positions
+	 * @param normalize If true, the values will be normalized.
+	 * @param alt_tri On quads, if true, this will return the normal of the second tri instead of the first
 	 */
-	getNormal(normalize: boolean): ArrayVector3
+	getNormal(normalize: boolean, alt_tri?: boolean): ArrayVector3
 	/**
 	 * Calculates which pixels the UV face occupies, and returns them as a map
 	 */

package/types/outliner.d.ts

@@ -152,18 +152,43 @@ declare class TextureMesh extends OutlinerElement {
 	static selected: TextureMesh[]
 }
 
+/**
+ * Toggle in the outliner
+ */
+interface OutlinerToggle {
+	id: string
+	title: string
+	icon: IconString
+	icon_off?: IconString
+	icon_alt?: IconString
+	condition?: ConditionResolvable
+	/**
+	 * If true, the toggle will only be visible when "Toggle More Options" is enabled
+	 */
+	advanced_option?: boolean
+	/**
+	 * Override the visibility and still show the toggle under certain conditions, even if more options are disabled
+	 */
+	visibilityException?: (node: OutlinerNode) => boolean
+	/**
+	 * It's complicated, check the source code
+	 */
+	getState?: (node: OutlinerNode) => boolean | 'alt'
+}
+
 declare namespace Outliner {
 	const root: OutlinerNode[]
 	const elements: OutlinerElement[]
 	const selected: OutlinerElement[]
 	let control_menu_group: MenuItem[]
 	const buttons: {
-		autouv: any
-		export: any
-		locked: any
-		mirror_uv: any
-		shade: any
-		visibility: any
+		autouv: OutlinerToggle
+		export: OutlinerToggle
+		locked: OutlinerToggle
+		mirror_uv: OutlinerToggle
+		shade: OutlinerToggle
+		visibility: OutlinerToggle
+		[id: string]: OutlinerToggle
 	}
 }
 

package/types/panel.d.ts

@@ -1,6 +1,6 @@
 /// <reference path="./blockbench.d.ts"/>
 
-type PanelSlot = 'left_bar' | 'right_bar' | 'top' | 'bottom' | 'float'
+type PanelSlot = 'left_bar' | 'right_bar' | 'top' | 'bottom' | 'float' | 'hidden'
 
 interface PanelOptions {
 	id: string

package/types/plugin.d.ts

@@ -62,6 +62,10 @@ interface PluginOptions {
 	 * Link to where users can report issues with the plugin
 	 */
 	bug_tracker?: string
+	/*
+	 * List of secondary contributors to the plugin, excluding the main author(s)
+	 */
+	contributors?: string[]
 	/**
 	 * Runs when the plugin loads
 	 */
@@ -89,7 +93,8 @@ declare class BBPlugin {
 	extend(options: PluginOptions): this
 
 	installed: boolean
-	expanded: boolean
+	id: string
+	disabled: boolean
 	title: string
 	author: string
 	/**
@@ -117,18 +122,22 @@ declare class BBPlugin {
 	 * In combination with a "Deprecated" tag, this can be used to provide context on why a plugin is deprecated
 	 */
 	deprecation_note?: string
-	website?: string
 	/*
 	 * Link to the plugin's website
 	 */
-	repository?: string
+	website?: string
 	/*
 	 * Link to the repository that contains the source for the plugin
 	 */
-	bug_tracker?: string
+	repository?: string
 	/*
 	 * Link to where users can report issues with the plugin
 	 */
+	bug_tracker?: string
+	/*
+	 * List of secondary contributors to the plugin, excluding the main author(s)
+	 */
+	contributors: string[]
 	onload(): void
 	onunload(): void
 	oninstall(): void
@@ -136,3 +145,33 @@ declare class BBPlugin {
 
 	static register(id: string, options: PluginOptions): BBPlugin
 }
+
+type PluginInstalledData = {
+	id: string
+	version: string
+	source: 'store' | 'file' | 'url'
+	path?: string
+	disabled?: boolean
+}
+declare namespace Plugins {
+	/**
+	 * All loaded plugins, including plugins from the store that are not installed
+	 */
+	const all: BBPlugin[]
+	/**
+	 * Data about which plugins are installed
+	 */
+	const installed: PluginInstalledData[]
+	/**
+	 * The plugins window
+	 */
+	const dialog: Dialog
+	/**
+	 * The currently used path to the plugin API
+	 */
+	const api_path: string
+	/**
+	 * Dev reload all side-loaded plugins
+	 */
+	function devReload(): void
+}

package/types/project.d.ts

@@ -88,9 +88,6 @@ declare class ModelProject {
 	front_gui_light: boolean
 
 	get model_3d(): THREE.Object3D
-	get materials(): {
-		[uuid: UUID]: THREE.ShaderMaterial
-	}
 	get nodes_3d(): {
 		[uuid: UUID]: THREE.Object3D
 	}

package/types/texture_group.d.ts

@@ -0,0 +1,73 @@
+/// <reference path="./blockbench.d.ts"/>
+
+
+interface TextureGroupData {
+    name?: string
+    is_material?: boolean
+    material_config?: TextureGroupMaterialConfigData
+}
+
+/**
+ * A way to group textures. Texture groups can also be used to represent materials in enabled formats
+ */
+declare class TextureGroup {
+    constructor(data?: TextureGroupData, uuid?: string);
+    uuid: string
+    name: string
+    folded: boolean
+    /**
+     * If true, the texture group works as a material
+     */
+    is_material: boolean
+    /**
+     * Material configuration
+     */
+    material_config: TextureGroupMaterialConfig
+    get material(): THREE.MeshStandardMaterial;
+    extend(data: TextureGroupData): this;
+    add(): this;
+    select(): this;
+    remove(): void;
+    showContextMenu(event: Event): void;
+    rename(): this;
+    getTextures(): Texture[];
+    getUndoCopy(): {
+        uuid: string;
+        index: number;
+        material_config: {};
+    };
+    getSaveCopy(): {
+        uuid: string;
+        material_config: {};
+    };
+    updateMaterial(): void;
+    getMaterial(): THREE.MeshStandardMaterial;
+}
+
+interface TextureGroupMaterialConfigData {
+    color_value?: [number, number, number, number]
+    mer_value?: [number, number, number]
+    saved?: boolean
+}
+declare class TextureGroupMaterialConfig {
+    constructor(texture_group: TextureGroup, data: TextureGroupMaterialConfigData);
+    color_value: [number, number, number, number]
+    mer_value: [number, number, number]
+    saved: boolean
+    menu: Menu
+    texture_group: TextureGroup
+
+    extend(data: TextureGroupMaterialConfigData): this;
+    getUndoCopy(): {};
+    getSaveCopy(): {};
+    compileForBedrock(): {
+        format_version: string;
+        "minecraft:texture_set": {};
+    };
+    getFilePath(): string;
+    getFileName(extension?: boolean): string;
+    save(): void;
+    showContextMenu(event: Event): void;
+    propertiesDialog(): void;
+}
+declare function importTextureSet(file: any): void;

package/types/textures.d.ts

@@ -3,13 +3,44 @@
 interface TextureData {
 	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
 	visible?: boolean
-	mode?: string
+	render_mode?: 'default' | 'emissive' | 'additive' | 'layered' | string
+	render_sides?: 'auto' | 'front' | 'double' | string
+	pbr_channel?: 'color' | 'normal' | 'height' | 'mer'
+
+	/**
+	 * 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
+	/**
+	 * Whether the texture is saved
+	 */
 	saved?: boolean
+	/**
+	 * Flag to indicate that the texture was manually resized, and on load it should not try to automatically adjust UV size
+	 */
 	keep_size?: boolean
 	source?: string
 	width?: number
@@ -61,6 +92,7 @@ declare class Texture {
 	particle: boolean
 	render_mode: 'default' | 'emissive' | 'additive' | 'layered' | string
 	render_sides: 'auto' | 'front' | 'double' | string
+	pbr_channel: 'color' | 'normal' | 'height' | 'mer'
 
 	/** Texture animation frame time */
 	frame_time: number
@@ -120,6 +152,7 @@ declare class Texture {
 	img: HTMLImageElement
 
 	relative_path?: string
+	readonly material: THREE.ShaderMaterial
 
 	getErrorMessage(): string
 	extend(data: TextureData): this
@@ -174,7 +207,18 @@ declare class Texture {
 	 * Reloads the texture. Only works in the desktop app
 	 */
 	reloadTexture(): void
-	getMaterial(): THREE.MeshLambertMaterial
+	/**
+	 * Get the material that the texture displays. When previewing PBR, this will return the shared PBR material
+	 */
+	getMaterial(): THREE.ShaderMaterial | THREE.MeshStandardMaterial
+	/**
+	 * Get the texture's own material
+	 */
+	getOwnMaterial(): THREE.ShaderMaterial
+	/**
+	 * Selects the texture
+	 * @param event Click event during selection
+	 */
 	select(event?: Event): this
 	/**
 	 * Adds texture to the textures list and initializes it

package/types/undo.d.ts

@@ -27,6 +27,9 @@ interface UndoAspects {
 	display_slots?: string[]
 	exploded_view?: boolean
 }
+interface UndoSelectionAspects {
+	texture_selection?: boolean
+}
 type UndoSave = {
 	aspects: UndoAspects
 	selection?: []
@@ -47,24 +50,63 @@ type UndoSave = {
 	keyframes?: {}
 	display_slots?: {}
 	exploded_views?: boolean
+	/**
+	 * Load the undo save
+	 */
+	load(reference: UndoSave, mode?: 'session'): void
+	/**
+	 * Add a texture to an undo edit during the edit
+	 */
+	addTexture(texture: Texture): void
+	/**
+	 * Add a texture to an undo edit during the edit
+	 */
+	addTextureOrLayer(texture: Texture): void
+	/**
+	 * Add elements to an undo edit during the edit
+	 */
+	addElements(elements: OutlinerElement[], aspects?: UndoAspects): void
+}
+type UndoSelectionSave = {
+	aspects: UndoSelectionAspects
+	elements: string[]
+	groups: string[]
+	geometry: {
+		[uuid: string]: {
+			faces: string[]
+			edges: string[]
+			vertices: string[]
+		}
+	}
+	mode: string
+	mesh_selection_mode: string
+	texture: string
+	texture_selection?: Int8Array | boolean
+	animation_item?: string
+	timeline?: {}
+	graph_editor_channel?: string
+	graph_editor_axis?: string
+	graph_editor_open?: boolean
+	/**
+	 * Load the selection save
+	 */
+	load(): void
+	/**
+	 * Test whether the selection save matches another selection
+	 * @param other Selection save to test against
+	 */
+	matches(other: UndoSelectionSave): boolean
 }
 type UndoEntry = {
-	before: UndoSave
-	post: UndoSave
+	before?: UndoSave
+	post?: UndoSave
+	selection_before?: UndoSelectionSave
+	selection_post?: UndoSelectionSave
 	action: string
+	type: 'original' | 'edit' | 'selection'
 	time: number
 }
-interface AmendEditForm {
-	condition?: ConditionResolvable
-	type?: 'number' | 'checkbox'
-	label: string
-	interval_type: 'position' | 'rotation'
-	getInterval?(event: Event): number
-	value?: number | string | 'boolean'
-	min?: number
-	max?: number
-	step?: number
-}
+
 
 declare class UndoSystem {
 	constructor()
@@ -90,6 +132,24 @@ declare class UndoSystem {
 	/**
 	 * Undoes the latest edit
 	 */
+	/**
+	 * Starts a selection change in the current project
+	 * @param aspects Aspects to save
+	 */
+	initSelection(aspects?: UndoSelectionAspects): UndoEntry
+	/**
+	 * Finishes a selection change in the current project
+	 * @param action Description of the edit
+	 */
+	finishSelection(action: string, aspects?: UndoSelectionAspects): UndoEntry
+	/**
+	 * Cancel the selection changes
+	 * @param revert_changes If true, the already tracked selection changes will be reverted to the state before initSelection
+	 */
+	cancelSelection(revert_changes?: boolean): void
+	/**
+	 * Cancels an event before it was finished and reset the project to the state before
+	 */
 	undo(remote?: boolean): void
 	/**
 	 * Redoes the latest edit
@@ -98,7 +158,11 @@ declare class UndoSystem {
 	/**
 	 * Provides a menu to amend the latest edit with slightly changed values
 	 */
-	amendEdit(form: AmendEditForm, callback: (values: any, form: any) => void): void
+	amendEdit(form: InputFormConfig, callback: (values: any, form: any) => void): void
+	/**
+	 * Closes the amend edit menu
+	 */
+	closeAmendEditMenu(): void
 
 	/**
 	 * Loads a specific undo save
@@ -123,11 +187,8 @@ Undo.initEdit({elements: []});
 let new_cube = new Cube({name: 'kevin'}).init();
 let other_cube = new Cube({name: 'lars'}).init();
 
-Undo.finishEdit('add new cubes', {elements: [new_cube, other_cube]});
+Undo.finishEdit('Add new cubes', {elements: [new_cube, other_cube]});
 ```
  */
 declare let Undo: UndoSystem
-interface CompileJSONOptions {
-	small?: boolean
-}
-declare function compileJSON(json: any, options?: CompileJSONOptions): string | ArrayBuffer
+

package/types/util.d.ts

@@ -215,3 +215,18 @@ declare class Rectangle {
 	fromUnorderedCoords(x1: number, y1: number, x2: number, y2: number): void
 	expandTo(x: number, y: number): void
 }
+
+interface CompileJSONOptions {
+	/**
+	 * Character or string used for indentation
+	 */
+	indentation?: string
+	/**
+	 * If true, compile everything in one line and without spaces
+	 */
+	small?: boolean
+}
+/**
+ * Blockbench's JSON compilation / stringify implementation
+ */
+declare function compileJSON(json: any, options?: CompileJSONOptions): string