blockbench-types 4.5.0 → 4.6.1

package/types/canvas.d.ts

@@ -38,174 +38,210 @@ interface UpdateViewOptions {
     selection?: boolean
 }
 
-declare const Canvas: {
-    materials: {
+declare namespace Canvas {
+    const materials: {
         [uuid: UUID]: THREE.Material
     };
-    meshes: {
+    const meshes: {
         [uuid: UUID]: THREE.Mesh
     };
-    bones: {
+    const bones: {
         [uuid: UUID]: THREE.Object3D
     };
     /**
      * Main scene, shared across all tabs
      */
-    scene: THREE.Scene
+    const scene: THREE.Scene
     /**
      * List of the gizmos (control and UI elements) in the 3D scene
      */
-    gizmos: []
+    const gizmos: []
     /**
      * The material used for all selection outlines
      */
-    outlineMaterial: THREE.LineBasicMaterial;
-    meshOutlineMaterial: THREE.LineBasicMaterial;
+    const outlineMaterial: THREE.LineBasicMaterial;
+    const meshOutlineMaterial: THREE.LineBasicMaterial;
     /**
      * The material used for the wireframe view
      */
-    wireframeMaterial: THREE.MeshBasicMaterial;
-    solidMaterial: THREE.ShaderMaterial;
-    normalHelperMaterial: THREE.ShaderMaterial;
-    uvHelperMaterial: THREE.ShaderMaterial;
-    meshVertexMaterial: THREE.PointsMaterial;
+    const wireframeMaterial: THREE.MeshBasicMaterial;
+    const solidMaterial: THREE.ShaderMaterial;
+    const normalHelperMaterial: THREE.ShaderMaterial;
+    const uvHelperMaterial: THREE.ShaderMaterial;
+    const meshVertexMaterial: THREE.PointsMaterial;
     /**
      * The material used for the grids
      */
-    gridMaterial: THREE.LineBasicMaterial;
+    const gridMaterial: THREE.LineBasicMaterial;
 
-    pivot_marker: THREE.Object3D
+    const pivot_marker: THREE.Object3D
 
-    global_light_color: THREE.Color
-    global_light_side: number
+    const global_light_color: THREE.Color
+    const global_light_side: number
 
-    face_order: string[];
+    const face_order: string[];
 
     /**
      * Raycast on the currently selected preview
      */
-    raycast(event: MouseEvent): any;
+    function raycast(event: MouseEvent): any;
     /**
      * Execute the callback function without any gizmos, grids and helpers visible
      */
-    withoutGizmos(cb: () => void): void;
+    function withoutGizmos(cb: () => void): void;
     /**
      * Clear all elements from the scene
      */
-    clear(): void;
-    buildGrid(): void;
-    updateShading(): void;
+    function clear(): void;
+    function buildGrid(): void;
+    function updateShading(): void;
     /**
      * Updates selected aspects of the preview
      * @param options 
      */
-    updateView(options: UpdateViewOptions): void; 
+    function updateView(options: UpdateViewOptions): void; 
     /**
      * Regenerate all elements in the scene. Very unoptimized, use with care
      */
-    updateAll(): void;
+    function updateAll(): void;
     /**
      * Update the position and shape of all elements
      */
-    updateAllPositions(): void;
+    function updateAllPositions(): void;
     /**
      * Update the visibility of all elements
      */
-    updateVisibility(): void;
+    function updateVisibility(): void;
     /**
      * Update all faces in the scene
      * @param texture Texture filter. If specified, only faces with this texture will be updated
      */
-    updateAllFaces(texture: Texture): void;
+    function updateAllFaces(texture: Texture): void;
     /**
      * Update all UV maps in the scene
      */
-    updateAllUVs(): void;
+    function updateAllUVs(): void;
     /**
      * Returns the three.js render sides based on the current settings and state
      */
-    getRenderSide(): number;
+    function getRenderSide(): number;
     /**
      * Update render sides of all materials
      */
-    updateRenderSides(): void;
+    function updateRenderSides(): void;
     /**
      * Redraw the selected elements in the scene
      * @param arr Optionally specify an array of elements to update
      */
     
-    updateSelected(arr: any): void;
+    function updateSelected(arr: any): void;
     /**
      * Update positions and shapes of the selected elements
      */
-    updatePositions(y): void;
+    function updatePositions(y): void;
     /**
      * Update the faces of all selected elements (material, UV map)
      */
-    updateSelectedFaces(): void;
+    function updateSelectedFaces(): void;
     /**
      * Update the UV maps of all selected elements
      */
-    updateUVs(): void;
+    function updateUVs(): void;
     /**
      * Update the hierarchy and position of all bones
      */
-    updateAllBones(): void;
+    function updateAllBones(): void;
     /**
      * Update the position of the origin / pivot point gizmo
      */
-    updateOrigin(): boolean;
+    function updateOrigin(): boolean;
     /**
      * Update the position and shape of the specified cube
      * @param cube Cube to update
      * @param mesh Mesh instance of the cube
      */
-    adaptObjectPosition(cube: Cube, mesh?: THREE.Mesh): void;
+    function adaptObjectPosition(cube: Cube, mesh?: THREE.Mesh): void;
     /**
      * Update the geometry faces of the specified cube
      * @param cube Cube to update
      */
-    adaptObjectFaceGeo(cube: any): void;
+    function adaptObjectFaceGeo(cube: any): void;
     /**
      * Update the faces (material) of the specified cube
      * @param cube Cube to update
      * @param mesh Mesh instance of the cube
      */
-    adaptObjectFaces(cube: any, mesh: any): void;
+    function adaptObjectFaces(cube: any, mesh: any): void;
     /**
      * Update the layered or not layered material of all elements
      */
-    updateLayeredTextures(): void;
+    function updateLayeredTextures(): void;
     /**
      * Update the UV map of the specified cube
      * @param cube Cube to update
      * @param animation Whether to display the current animated texture frame
      */
-    updateUV(cube: Cube, animation?: boolean): any;
+    function updateUV(cube: Cube, animation?: boolean): any;
     /**
      * Update the materials of marker colors if new colors were added
      */
-    updateMarkerColorMaterials(): void;
+    function updateMarkerColorMaterials(): void;
     /**
      * Create an additional outline around the specified cubes
      * @param arr List of cubes to outline
      */
-    outlineObjects(arr: Cube[]): void;
+    function outlineObjects(arr: Cube[]): void;
     /**
      * Calculate the size of the model, in the currently displayed shape. Returns [width, height] in blockbench units
      */
-    getModelSize(): [number, number];
-};
+    function getModelSize(): [number, number];
+}
 
 /**
  * Marks a specific aspect of the interface to be updated in the next tick. Useful to avoid an update function getting called multiple times in the same task.
  */
-declare const TickUpdates: {
-    outliner: undefined | true
-    selection: undefined | true
-    main_uv: undefined | true
-    texture_list: undefined | true
-    keyframes: undefined | true
-    keyframe_selection: undefined | true
-    keybind_conflicts: undefined | true
+declare namespace TickUpdates {
+    const outliner: undefined | true
+    const selection: undefined | true
+    const main_uv: undefined | true
+    const texture_list: undefined | true
+    const keyframes: undefined | true
+    const keyframe_selection: undefined | true
+    const keybind_conflicts: undefined | true
+}
+
+interface NodePreviewControllerOptions {
+    setup?(element: OutlinerNode): void
+    remove?(element: OutlinerNode): void
+    updateAll?(element: OutlinerNode): void
+    updateTransform?(element: OutlinerNode): void
+    updateVisibility?(element: OutlinerNode): void
+    updateSelection?(element: OutlinerNode): void
+    updateGeometry?(element: OutlinerNode): void
+    updateUV?(element: OutlinerNode): void
+    updateFaces?(element: OutlinerNode): void
+    updatePaintingGrid?(element: OutlinerNode): void
+    updateHighlight?(element: OutlinerNode): void
+}
+declare class NodePreviewController {
+    constructor(type: typeof OutlinerNode, options: NodePreviewControllerOptions)
+    type: typeof OutlinerNode
+    events: {
+        [event_name: string]: ((data) => void)[]
+    }
+    dispatchEvent(event_name: string, data: object)
+    on(event_name: string, cb: (data) => void)
+    removeListener(event_name: string, cb: (data) => void)
+
+    setup(element: OutlinerNode): void
+    remove(element: OutlinerNode): void
+    updateAll(element: OutlinerNode): void
+    updateTransform(element: OutlinerNode): void
+    updateVisibility(element: OutlinerNode): void
+    updateSelection(element: OutlinerNode): void
+    updateGeometry(instance: OutlinerNode): void
+    updateUV(instance: OutlinerNode): void
+    updateFaces(instance: OutlinerNode): void
+    updatePaintingGrid(instance: OutlinerNode): void
+    updateHighlight(instance: OutlinerNode): void
 }

package/types/codec.d.ts

@@ -1,3 +1,4 @@
+
 interface CodecOptions {
 	name: string
 	load?(model: any, file: object, add?: boolean): void
@@ -22,36 +23,96 @@ interface CodecOptions {
 	load_filter?: {
 		extensions: string[]
 		type: 'json' | 'text'
-		condition?: any
+		condition?: ConditionResolvable
 	}
 	export_action?: Action
 }
 
+/**
+ * A codec represents a specific file format that can be imported into and exported from Blockbench. The codec handles the compilation and parsing, as well as the loading and exporting logic
+ */
 declare class Codec extends Deletable {
+	/**
+	 * Creates a new codec
+	 * @param id Codec ID
+	 * @param options Codec options
+	 */
 	constructor(id: string, options: CodecOptions)
 
+	/**
+	 * Load a file into the program
+	 * @param model 
+	 * @param file 
+	 * @param add 
+	 */
 	load?(model: any, file: object, add?: boolean): void
+	/**
+	 * Compiles the file content
+	 * @param options 
+	 */
 	compile?(options?: object): any
+	/**
+	 * Takes the content of a file, and loads the model into the current Blockbench project
+	 * @param data File content
+	 * @param path File path
+	 */
 	parse?(data: any, path: string): void
+	/**
+	 * Opens the file browser to export a file of this type
+	 */
 	export?(): void
 	/**
 	 * Generate a file name to suggest when exporting
 	 */
 	fileName?(): string
+	/**
+	 * Generates the suggested file path. This is the path that the explorer opens in when exporting this type
+	 */
 	startPath?(): string
+	/**
+	 * Write the content of this file to the selected location. The default method can be overwritten to achieve custom behavior
+	 * @param content File content, as generated by compile()
+	 * @param path The file export path
+	 */
 	write?(content: any, path: string): void
 	overwrite?(content: any, path: string, callback: ((path) => void)): void
 	afterDownload?(path): void
 	afterSave?(path): void
+
+	/**
+	 * Adds an event listener to the codec
+	 * @param event_name The event type to listen for
+	 * @param callback 
+	 */
 	on(event_name: string, callback: (data: object) => void): void
+	/**
+	 * Removes an event listener from the codec
+	 * @param event_name 
+	 * @param callback 
+	 */
 	removeListener(event_name: string, callback: (data: object) => void): void
 	dispatchEvent(data: object): void
 	
+	/**
+	 * The display name of the codec
+	 */
 	name: string
+	/**
+	 * The default file extension that the codec uses
+	 */
 	extension: string
+	/**
+	 * Whether to remember files that use this codec in the recent models list
+	 */
 	remember: boolean
+	/**
+	 * If available, the action that is used to export files using this codec
+	 */
 	export_action?: Action
 
+	/**
+	 * Get a list of all possible extensions of all codecs
+	 */
 	static getAllExtensions(): string[]
 }
 

package/types/cube.d.ts

@@ -0,0 +1,132 @@
+interface CubeOptions {
+	name: string
+	autouv: 0 | 1 | 2
+	shade: boolean
+	mirror_uv: boolean
+	inflate: number
+	color: number
+	visibility: boolean
+	from: ArrayVector3
+	to: ArrayVector3
+	rotation: ArrayVector3
+	origin: ArrayVector3
+	/**
+	 * UV position for box UV mode
+	 */
+	uv_offset: ArrayVector2
+}
+declare class Cube extends OutlinerElement {
+	constructor (options: Partial<CubeOptions>, uuid?: string)
+	/**
+	 * Auto UV setting, saved as an integer, where 0 means disabled, 1 means enabled, and 2 means relative auto UV (cube position affects UV)
+	 */
+	autouv: 0 | 1 | 2
+	/**
+	 * Enable or disable shading based on face normal
+	 */
+	shade: boolean
+	/**
+	 * UV mirror across the X axis when using Box UV
+	 */
+	mirror_uv: boolean
+	/**
+	 * Inflate adds an inflation value to all sides equally
+	 */
+	inflate: number
+	/**
+	 * Visibility of the cube in the viewport
+	 */
+	visibility: boolean
+	from: ArrayVector3
+	to: ArrayVector3
+	rotation: ArrayVector3
+	origin: ArrayVector3
+	faces: {
+		[fkey: string]: CubeFace
+	}
+	/**
+	 * UV position for box UV mode
+	 */
+	uv_offset: ArrayVector2
+
+	extend(options: Partial<CubeOptions>): this
+	/**
+	 * Calculates and returns the size of a cube across a certain axis. If the axis argument is omitted, it returns all sizes as an array vector.
+	 */
+	size(axis?: number, floored?: boolean): number | ArrayVector3
+	rotationAxis(): void
+	getUndoCopy(aspects?: object): void
+	getSaveCopy(project?: boolean): void
+	/**
+	 * Rotate the cube around axis in 90 degree steps
+	 * @param axis Axis index
+	 * @param steps Number of steps
+	 * @param origin Rotation pivot
+	 */
+	roll(axis: number, steps: number, origin: ArrayVector3): void
+	flip(axis: number, center: number, skipUV?: boolean): void
+	/**
+	 * Transfer the origin to a new position, while updating from and to to keep the same visual position.
+	 */
+	transferOrigin(origin: ArrayVector3, update?: boolean): void
+	getWorldCenter(): THREE.Vector3
+	getGlobalVertexPositions(): ArrayVector3[]
+	setUVMode(box_uv: boolean): void
+	setColor(color: number): void
+	applyTexture(texture: Texture, faces: true | undefined | CubeFaceDirection[]): void
+	mapAutoUV(): void
+	moveVector(offset: ArrayVector3, axis: number, update?: boolean): void
+	resize(value: number, axis: number, negative: boolean, allow_negative?: boolean, bidirectional?: boolean): void
+
+	static all: Cube[]
+	static selected: Cube[]
+}
+
+interface FaceOptions {
+	texture?: Texture
+
+}
+declare class Face {
+	constructor()
+	texture: string | false | null
+
+	getTexture(): Texture | null
+	/**
+	 * Returns a 2D rectangle around the UV face
+	 */
+	getBoundingRect(): object
+	reset(): void
+	/**
+	 * Returns a save copy of the face, ready for serialization. Set project to true to save for a bbmodel project file
+	 */
+	getSaveCopy(project?: boolean): object
+	/**
+	 * Get a copy for undo tracking
+	 */
+	getUndoCopy(): Face
+}
+
+type CubeFaceDirection = 'north' | 'south' | 'east' | 'west' | 'up' | 'down'
+interface CubeFaceOptions extends FaceOptions {
+	uv?: [number, number, number, number]
+	rotation?: number
+	tint?: number
+	cullface?: CubeFaceDirection | ''
+	material_name?: string
+	enabled?: boolean
+}
+declare class CubeFace extends Face {
+	constructor(direction: CubeFaceDirection, data: CubeFaceOptions, cube: Cube)
+	cube: Cube
+	direction: CubeFaceDirection
+	uv: [number, number, number, number]
+	readonly uv_size: ArrayVector2
+	rotation: number
+	tint: number
+	cullface: CubeFaceDirection | ''
+	material_name: string
+	enabled: boolean
+	
+	extend(data: CubeFaceOptions)
+	getVertexIndices(): [number, number, number, number]
+}

package/types/dialog.d.ts

@@ -1,19 +1,25 @@
 interface DialogFormElement {
-	label: string
+	type: 'text' | 'number' | 'range' | 'checkbox' | 'select' | 'radio' | 'textarea' | 'vector' | 'color' | 'file' | 'folder' | 'save' | 'info' | 'buttons'
+	label?: string
 	description?: string
-	type: 'text' | 'number' | 'range' | 'checkbox' | 'select' | 'radio' | 'textarea' | 'vector' | 'color' | 'file' | 'folder' | 'save' | 'info'
 	nocolon?: boolean
 	full_width?: boolean
+	/** Set the input to read-only */
 	readonly?: boolean
+	/** Add buttons to allow copying and sharing the text or link */
+	share_text?: boolean
 	value?: any
 	placeholder?: string
 	text?: string
+	editable_range_label?: boolean
 	colorpicker?: any
 	min?: number
 	max?: number
 	step?: number
 	height?: number
 	options?: object
+	buttons?: string[]
+	click?: (button_index: number) => void
 }
 
 type FormResultValue = string|number|boolean|[]
@@ -23,7 +29,7 @@ interface ActionInterface {
 	description?: string
 	icon: string,
 	click: (event: Event) => void
-	condition: Condition
+	condition: ConditionResolvable
 }
 interface DialogOptions {
 	title: string
@@ -43,7 +49,7 @@ interface DialogOptions {
 	/**
 	 * Function to execute when the user cancels the dialog
 	 */
-	onCancel?: () => void
+	onCancel?(): void
 	/**
 	 * Triggered when the user presses a specific button
 	 */
@@ -93,50 +99,30 @@ interface DialogOptions {
 	cancel_on_click_outside?: boolean
 }
 
-interface DialogSidebarOptions {
-	pages?: {
-		[key: string]: string | {label: string, icon: IconString, color?: string}
-	}
-	page?: string
-	actions?: (Action|ActionInterface|string)[],
-	onPageSwitch?: (page: string) => void
-}
-declare class DialogSidebar {
-	constructor(options: DialogSidebarOptions)
-
-	pages: {
-		[key: string]: string
-	}
-	page: string
-	actions: (Action|string)[]
-	onPageSwitch(page: string): void
-	build(): void
-	toggle(state?: boolean): void
-	setPage(page: string): void
-}
-
 declare class Dialog {
-	constructor (options: DialogOptions)
+	constructor(id: string, options: DialogOptions)
+	constructor(options: DialogOptions)
 
 	id: string
 	component: Vue.Component
 	sidebar: DialogSidebar | null
+	content_vue: Vue | null
 
 
-	show: () => Dialog
-	hide: () => Dialog
+	show(): this
+	hide(): this
 	/**
 	 * Triggers the confirm event of the dialog.
 	 */
-	confirm: (event?: Event) => void
+	confirm(event?: Event): void
 	/**
 	 * Triggers the cancel event of the dialog.
 	 */
-	cancel: (event?: Event) => void
+	cancel(event?: Event): void
 	/**
 	 * Closes the dialog using the index of the pressed button
 	 */
-	close: (button: number, event?: Event) => void
+	close(button: number, event?: Event): void
 	/**
 	 * If the dialog contains a form, return the current values of the form
 	 */
@@ -156,4 +142,95 @@ declare class Dialog {
 	 * Currently opened dialog
 	 */
 	static open: Dialog | null
+	static stack: Dialog[]
+}
+
+interface ShapelessDialogOptions {
+	title: string
+	/**
+	 * Default button to press to confirm the dialog. Defaults to the first button.
+	 */
+	confirmIndex?: number
+	/**
+	 * Default button to press to cancel the dialog. Defaults to the last button.
+	 */
+	cancelIndex?: number
+	/**
+	 *  Function to execute when the user confirms the dialog
+	 */
+	onConfirm?: (formResult: object) => void
+	/**
+	 * Function to execute when the user cancels the dialog
+	 */
+	onCancel?(): void
+	/**
+	 * Triggered when the user presses a specific button
+	 */
+	onClose?: (button_index: number, event?: Event) => void
+	/**
+	 * Vue component
+	 */
+	component?: Vue.Component
+	/**
+	 * Unless set to false, clicking on the darkened area outside of the dialog will cancel the dialog.
+	 */
+	cancel_on_click_outside?: boolean
+}
+declare class ShapelessDialog extends Dialog {
+	constructor (id: string, options: ShapelessDialogOptions)
+
+	id: string
+	component: Vue.Component
+
+
+	show(): this
+	hide(): this
+	/**
+	 * Triggers the confirm event of the dialog.
+	 */
+	confirm(event?: Event): void
+	/**
+	 * Triggers the cancel event of the dialog.
+	 */
+	cancel(event?: Event): void
+	/**
+	 * Closes the dialog using the index of the pressed button
+	 */
+	close(button: number, event?: Event): void
+	/**
+	 * If the dialog contains a form, return the current values of the form
+	 */
+	getFormResult(): {
+		[key: string]: FormResultValue
+	}
+	/**
+	 * Set the values of the dialog form inputs
+	 */
+	setFormValues(values: {[key: string]: FormResultValue}): void
+	/**
+	 * Delete the dialog object, causing it to be re-build from scratch on next open
+	 */
+	delete(): void
+}
+
+interface DialogSidebarOptions {
+	pages?: {
+		[key: string]: string | {label: string, icon: IconString, color?: string}
+	}
+	page?: string
+	actions?: (Action|ActionInterface|string)[],
+	onPageSwitch?: (page: string) => void
+}
+declare class DialogSidebar {
+	constructor(options: DialogSidebarOptions)
+
+	pages: {
+		[key: string]: string
+	}
+	page: string
+	actions: (Action|string)[]
+	onPageSwitch(page: string): void
+	build(): void
+	toggle(state?: boolean): void
+	setPage(page: string): void
 }