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

package/custom/keyframe.d.ts

@@ -1,94 +1,94 @@
-/// <reference types="./blockbench"/>
-
-/**
- * Keyframes are used in animations to specify transformation or other data at specific points in the timeline
- * @module
- */
-
-interface KeyframeDataPointData {
-	[key: string]: any
-}
-declare class KeyframeDataPoint extends Object {
-	static properties: Record<string, Property<any>>
-	constructor(keyframe: _Keyframe)
-	readonly keyframe: Keyframe
-	extend(data: KeyframeDataPointData): void
-	getUndoCopy(): {
-		[key: string]: any
-	}
-	[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'
-type axisNumber = 0 | 1 | 2
-
-declare class _Keyframe {
-	constructor(options: KeyframeOptions, uuid: any)
-	static selected: _Keyframe[]
-	data_points: KeyframeDataPoint[]
-	animator: GeneralAnimator
-	channel: string
-	time: number
-	uuid: string
-	color: number
-	uniform: boolean
-	interpolation: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
-	cooldown?: boolean
-	bezier_linked: boolean
-	bezier_left_time: ArrayVector3
-	bezier_right_time: ArrayVector3
-	bezier_left_value: ArrayVector3
-	bezier_right_value: ArrayVector3
-	selected: boolean
-	transform: boolean
-	has_expressions: boolean
-
-	extend(data: KeyframeOptions): this
-	get(axis: axisLetter, data_point?: number): number | string
-	calc(axis: axisLetter, data_point?: number): number
-	set(axis: axisLetter, value: any, data_point?: number): this
-	offset(axis: axisLetter, amount: any, data_point?: number): void
-	flip(axis: axisLetter): this
-	getLerp(other: _Keyframe, axis: axisLetter, amount: number, allow_expression?: boolean): number
-	getCatmullromLerp(
-		before_plus: _Keyframe,
-		before: _Keyframe,
-		after: _Keyframe,
-		after_plus: _Keyframe,
-		axis: axisLetter,
-		alpha: number
-	): number
-	getArray(data_point?: number): (number | string)[]
-	getFixed(
-		data_point?: number,
-		get_quaternion?: boolean
-	): THREE.Vector3 | THREE.Euler | THREE.Quaternion
-	getTimecodeString(): string
-	compileBedrockKeyframe(): any
-	replaceOthers(save: any): void
-	select(event?: any): this
-	callPlayhead(): this
-	showContextMenu(event: Event): this
-	remove(): void
-	forSelected(callback: (keyframe: _Keyframe) => void, undo_tag: any): this[]
-	getUndoCopy(save: any): {
-		animator: any
-		channel?: string | null
-		data_points: KeyframeDataPoint[]
-	}
-}
-
-declare function updateKeyframeSelection(): void
+/// <reference types="./blockbench"/>
+
+/**
+ * Keyframes are used in animations to specify transformation or other data at specific points in the timeline
+ * @module
+ */
+
+interface KeyframeDataPointData {
+	[key: string]: any
+}
+declare class KeyframeDataPoint extends Object {
+	static properties: Record<string, Property<any>>
+	constructor(keyframe: _Keyframe)
+	readonly keyframe: Keyframe
+	extend(data: KeyframeDataPointData): void
+	getUndoCopy(): {
+		[key: string]: any
+	}
+	[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'
+type axisNumber = 0 | 1 | 2
+
+declare class _Keyframe {
+	constructor(options: KeyframeOptions, uuid: any)
+	static selected: _Keyframe[]
+	data_points: KeyframeDataPoint[]
+	animator: GeneralAnimator
+	channel: string
+	time: number
+	uuid: string
+	color: number
+	uniform: boolean
+	interpolation: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
+	cooldown?: boolean
+	bezier_linked: boolean
+	bezier_left_time: ArrayVector3
+	bezier_right_time: ArrayVector3
+	bezier_left_value: ArrayVector3
+	bezier_right_value: ArrayVector3
+	selected: boolean
+	transform: boolean
+	has_expressions: boolean
+
+	extend(data: KeyframeOptions): this
+	get(axis: axisLetter, data_point?: number): number | string
+	calc(axis: axisLetter, data_point?: number): number
+	set(axis: axisLetter, value: any, data_point?: number): this
+	offset(axis: axisLetter, amount: any, data_point?: number): void
+	flip(axis: axisLetter): this
+	getLerp(other: _Keyframe, axis: axisLetter, amount: number, allow_expression?: boolean): number
+	getCatmullromLerp(
+		before_plus: _Keyframe,
+		before: _Keyframe,
+		after: _Keyframe,
+		after_plus: _Keyframe,
+		axis: axisLetter,
+		alpha: number
+	): number
+	getArray(data_point?: number): (number | string)[]
+	getFixed(
+		data_point?: number,
+		get_quaternion?: boolean
+	): THREE.Vector3 | THREE.Euler | THREE.Quaternion
+	getTimecodeString(): string
+	compileBedrockKeyframe(): any
+	replaceOthers(save: any): void
+	select(event?: any): this
+	callPlayhead(): this
+	showContextMenu(event: Event): this
+	remove(): void
+	forSelected(callback: (keyframe: _Keyframe) => void, undo_tag: any): this[]
+	getUndoCopy(save: any): {
+		animator: any
+		channel?: string | null
+		data_points: KeyframeDataPoint[]
+	}
+}
+
+declare function updateKeyframeSelection(): void

package/custom/libs.d.ts

@@ -1,13 +1,13 @@
-import three from 'three'
-
-declare module 'three' {
-	interface Object3D {
-		/**The outline mesh of the mesh */
-		outline?: three.Object3D | three.Mesh
-		fix_rotation?: three.Euler
-		fix_position?: three.Vector3
-		no_export?: boolean
-		isElement?: boolean
-		isGroup?: boolean
-	}
-}
+import three from 'three'
+
+declare module 'three' {
+	interface Object3D {
+		/**The outline mesh of the mesh */
+		outline?: three.Object3D | three.Mesh
+		fix_rotation?: three.Euler
+		fix_position?: three.Vector3
+		no_export?: boolean
+		isElement?: boolean
+		isGroup?: boolean
+	}
+}

package/custom/menu_bar.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="./blockbench"/>
+
+
+declare interface BarMenuOptions {
+	name?: string
+	icon?: IconString
+	condition?: ConditionResolvable
+}
+
+/**
+ * Creates a new menu in the menu bar
+ */
+declare class BarMenu extends Menu {
+	constructor(id: string, structure: MenuItem[], options?: BarMenuOptions)
+	type: 'bar_menu'
+	id: string
+	condition?: ConditionResolvable
+	name: string
+	label: HTMLElement
+	structure: MenuItem[]
+	/**
+	 * Visually highlights an action within the menu, until the user opens the menu
+	 */
+	highlight(action: Action): void
+}
+
+declare namespace MenuBar {
+	const mode_switcher_button: null | HTMLDivElement
+	const menus: {
+		file: Menu
+		edit: Menu
+		transform: Menu
+		uv: Menu
+		texture: Menu
+		animation: Menu
+		keyframe: Menu
+		display: Menu
+		tools: Menu
+		view: Menu
+		help: Menu
+		[id: string]: Menu
+	}
+	const keys: string[]
+	let open: Menu | null
+	/**
+	 * Add a new menu to the menu bar
+	 * @param menu The BarMenu to add
+	 * @param position Specify the position in the menu list where to add insert the menu. Can either be an index in the list of all menus, or the ID of the menu to insert right from.
+	 */
+	function addMenu(menu: BarMenu, position?: number | string): void
+	/**
+	 * 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 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 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): void
+	/**
+	 * Update the menu bar
+	 */
+	function update(): void
+}

package/custom/mesh.d.ts

@@ -1,196 +1,196 @@
-/// <reference types="./blockbench"/>
-
-type OccupationMatrix = {
-	[x: number]: {
-		[y: number]: boolean
-	}
-}
-type MeshEdge = [string, string]
-
-type MeshSeamValue = 'auto' | 'divide' | 'join'
-interface MeshOptions {
-	name?: string
-	color?: number
-	visibility?: boolean
-	rotation?: ArrayVector3
-	origin?: ArrayVector3
-	vertices?: {
-		[vkey: string]: ArrayVector3
-	}
-}
-
-interface MeshFaceOptions extends FaceOptions {
-	vertices?: string[]
-	uv?: { [vkey: string]: ArrayVector2 }
-}
-declare class MeshFace extends Face {
-	constructor(mesh: Mesh, data: MeshFaceOptions)
-	/**
-	 * The vertices that make up the face, as vertex keys. The vertices go around the face counter-clockwise when looking at the front side of the face. That also means that reversing the vertex order reverses the face direction.
-	 */
-	vertices: string[]
-	mesh: Mesh
-	uv: {
-		[vertex: string]: ArrayVector2
-	}
-	extend(data: MeshFaceOptions): this
-	/**
-	 * 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 = false, alt_tri?: boolean): ArrayVector3
-	/**
-	 * Calculates which pixels the UV face occupies, and returns them as a map
-	 */
-	getOccupationMatrix(
-		texture_space?: boolean,
-		start_offset?: ArrayVector2,
-		matrix?: OccupationMatrix
-	): OccupationMatrix
-	/**
-	 * Get the keys of this face and all faces that are connected with it on the UV map
-	 */
-	getUVIsland(): string[]
-	/**
-	 * Returns the angle between two faces in degrees
-	 */
-	getAngleTo(other_face: MeshFace): number
-	/**
-	 * Inverts the direction of the face
-	 */
-	invert(): void
-	/**
-	 * Returns whether the face is selected
-	 * @param face_key Optional face key of the face, the method runs faster if this is provided
-	 */
-	isSelected(face_key?: string): boolean
-	/**
-	 * Returns true if the face is concave
-	 */
-	isConcave(): boolean
-	/**
-	 * Returns the vertices of a quad in an order that creates a convex quad shape if possible. If the face has less than 4 vertices, it just returns the vertices in original order.
-	 */
-	getSortedVertices(): string[]
-	/**
-	 * Get the adjacent face in the specified side
-	 */
-	getAdjacentFace(
-		side_index: number
-	): { face: MeshFace; key: string; edge: MeshEdge; index: number } | null
-	/**
-	 * Return all edges of the face
-	 */
-	getEdges(): [string, string][]
-	/**
-	 * Returns the face key
-	 */
-	getFaceKey(): string
-	/**
-	 * Takes a UV coordinate and turns it into a 3D space coordinate in local space of the mesh. On quads, the first triangle is used for calculation, so the coordinates on warped quads may be inaccurate.
-	 */
-	UVToLocal(uv: ArrayVector2): THREE.Vector3
-	/**
-	 * Takes a 3D coordinate in local space of the mesh, and turns it into a coordinate on the UV map using barycentric coordinates. On quads, the first triangle is used for calculation, so the coordinates on warped quads may be inaccurate.
-	 */
-	localToUV(vector: THREE.Vector3): ArrayVector2
-	/**
-	 * Get the face center by weight in local space
-	 */
-	getCenter(): ArrayVector3
-}
-
-interface MeshOptions {
-	name?: string
-	color?: number
-	visibility?: boolean
-	shading?: 'flat' | 'smooth'
-	rotation?: ArrayVector3
-	origin?: ArrayVector3
-	vertices?: {
-		[vkey: string]: ArrayVector3
-	}
-}
-declare class Mesh extends OutlinerElement {
-	constructor(options: Partial<MeshOptions>, uuid?: string)
-
-	shading: 'flat' | 'smooth'
-	visibility: boolean
-	color: number
-	origin: ArrayVector3
-	rotation: ArrayVector3
-
-	vertices: {
-		[vkey: string]: ArrayVector3
-	}
-	faces: {
-		[fkey: string]: MeshFace
-	}
-	seams: {
-		[vkey: string]: MeshSeamValue
-	}
-	vertice_list: ArrayVector3[]
-	armature: string
-
-	extend(options: Partial<MeshOptions>): this
-
-	/**
-	 * Get selected vertices as vertex keys
-	 * @param can_write If true, the array can safely be modified to update the selection
-	 */
-	getSelectedVertices(can_write?: boolean): string[]
-	/**
-	 * Get selected edges as vertex key pairs
-	 * @param can_write If true, the array can safely be modified to update the selection
-	 */
-	getSelectedEdges(can_write?: boolean): [string, string][]
-	/**
-	 * Get selected faces as face keys
-	 * @param can_write If true, the array can safely be modified to update the selection
-	 */
-	getSelectedFaces(can_write?: boolean): string[]
-
-	/**
-	 * Get the armature if one is attached to the mesh
-	 */
-	getArmature() : Armature | undefined
-	/**
-	 * Vertex lists of quads are generally in arbitrary order, the order is calculated when calling getSortedVertices() to account for dfiferent face geometries. Calling this method pre-sorts all faces to allow optimizing subsequent processing
-	 */
-	sortAllFaceVertices(): void
-	calculateNormals(): Record<string, ArrayVector3>
-
-	setSeam(edge: MeshEdge, value: any): void
-	getSeam(edge: MeshEdge): MeshSeamValue
-	getWorldCenter(ignore_mesh_selection?: boolean): THREE.Vector3
-	addVertices(...ArrayVector3: ArrayVector3[]): string[]
-	addFaces(...MeshFace: MeshFace[]): string[]
-	extend(data: MeshOptions): void
-	getUndoCopy(aspects?: any): any
-	getSelectionRotation(): THREE.Euler
-	getCenter(global: boolean): THREE.Vector3
-	forAllFaces(callback: (face: MeshFace, key: string) => void): void
-	transferOrigin(origin: ArrayVector3, update?: boolean): void
-	setColor(color: number): void
-	roll(axis: number, steps: number, origin?: ArrayVector3): void
-	flip(axis: number): void
-	moveVector(offset: ArrayVector3, axis: number, update?: boolean): void
-	resize(
-		val: number,
-		axis: number,
-		negative: boolean,
-		allow_negative: boolean,
-		bidirectional?: boolean
-	): void
-	applyTexture(texture: Texture, faces?: true | undefined | string[]): void
-
-	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 {}
+/// <reference types="./blockbench"/>
+
+type OccupationMatrix = {
+	[x: number]: {
+		[y: number]: boolean
+	}
+}
+type MeshEdge = [string, string]
+
+type MeshSeamValue = 'auto' | 'divide' | 'join'
+interface MeshOptions {
+	name?: string
+	color?: number
+	visibility?: boolean
+	rotation?: ArrayVector3
+	origin?: ArrayVector3
+	vertices?: {
+		[vkey: string]: ArrayVector3
+	}
+}
+
+interface MeshFaceOptions extends FaceOptions {
+	vertices?: string[]
+	uv?: { [vkey: string]: ArrayVector2 }
+}
+declare class MeshFace extends Face {
+	constructor(mesh: Mesh, data: MeshFaceOptions)
+	/**
+	 * The vertices that make up the face, as vertex keys. The vertices go around the face counter-clockwise when looking at the front side of the face. That also means that reversing the vertex order reverses the face direction.
+	 */
+	vertices: string[]
+	mesh: Mesh
+	uv: {
+		[vertex: string]: ArrayVector2
+	}
+	extend(data: MeshFaceOptions): this
+	/**
+	 * 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 = false, alt_tri?: boolean): ArrayVector3
+	/**
+	 * Calculates which pixels the UV face occupies, and returns them as a map
+	 */
+	getOccupationMatrix(
+		texture_space?: boolean,
+		start_offset?: ArrayVector2,
+		matrix?: OccupationMatrix
+	): OccupationMatrix
+	/**
+	 * Get the keys of this face and all faces that are connected with it on the UV map
+	 */
+	getUVIsland(): string[]
+	/**
+	 * Returns the angle between two faces in degrees
+	 */
+	getAngleTo(other_face: MeshFace): number
+	/**
+	 * Inverts the direction of the face
+	 */
+	invert(): void
+	/**
+	 * Returns whether the face is selected
+	 * @param face_key Optional face key of the face, the method runs faster if this is provided
+	 */
+	isSelected(face_key?: string): boolean
+	/**
+	 * Returns true if the face is concave
+	 */
+	isConcave(): boolean
+	/**
+	 * Returns the vertices of a quad in an order that creates a convex quad shape if possible. If the face has less than 4 vertices, it just returns the vertices in original order.
+	 */
+	getSortedVertices(): string[]
+	/**
+	 * Get the adjacent face in the specified side
+	 */
+	getAdjacentFace(
+		side_index: number
+	): { face: MeshFace; key: string; edge: MeshEdge; index: number } | null
+	/**
+	 * Return all edges of the face
+	 */
+	getEdges(): [string, string][]
+	/**
+	 * Returns the face key
+	 */
+	getFaceKey(): string
+	/**
+	 * Takes a UV coordinate and turns it into a 3D space coordinate in local space of the mesh. On quads, the first triangle is used for calculation, so the coordinates on warped quads may be inaccurate.
+	 */
+	UVToLocal(uv: ArrayVector2): THREE.Vector3
+	/**
+	 * Takes a 3D coordinate in local space of the mesh, and turns it into a coordinate on the UV map using barycentric coordinates. On quads, the first triangle is used for calculation, so the coordinates on warped quads may be inaccurate.
+	 */
+	localToUV(vector: THREE.Vector3): ArrayVector2
+	/**
+	 * Get the face center by weight in local space
+	 */
+	getCenter(): ArrayVector3
+}
+
+interface MeshOptions {
+	name?: string
+	color?: number
+	visibility?: boolean
+	shading?: 'flat' | 'smooth'
+	rotation?: ArrayVector3
+	origin?: ArrayVector3
+	vertices?: {
+		[vkey: string]: ArrayVector3
+	}
+}
+declare class Mesh extends OutlinerElement {
+	constructor(options: Partial<MeshOptions>, uuid?: string)
+
+	shading: 'flat' | 'smooth'
+	visibility: boolean
+	color: number
+	origin: ArrayVector3
+	rotation: ArrayVector3
+
+	vertices: {
+		[vkey: string]: ArrayVector3
+	}
+	faces: {
+		[fkey: string]: MeshFace
+	}
+	seams: {
+		[vkey: string]: MeshSeamValue
+	}
+	vertice_list: ArrayVector3[]
+	armature: string
+
+	extend(options: Partial<MeshOptions>): this
+
+	/**
+	 * Get selected vertices as vertex keys
+	 * @param can_write If true, the array can safely be modified to update the selection
+	 */
+	getSelectedVertices(can_write?: boolean): string[]
+	/**
+	 * Get selected edges as vertex key pairs
+	 * @param can_write If true, the array can safely be modified to update the selection
+	 */
+	getSelectedEdges(can_write?: boolean): [string, string][]
+	/**
+	 * Get selected faces as face keys
+	 * @param can_write If true, the array can safely be modified to update the selection
+	 */
+	getSelectedFaces(can_write?: boolean): string[]
+
+	/**
+	 * Get the armature if one is attached to the mesh
+	 */
+	getArmature() : Armature | undefined
+	/**
+	 * Vertex lists of quads are generally in arbitrary order, the order is calculated when calling getSortedVertices() to account for dfiferent face geometries. Calling this method pre-sorts all faces to allow optimizing subsequent processing
+	 */
+	sortAllFaceVertices(): void
+	calculateNormals(): Record<string, ArrayVector3>
+
+	setSeam(edge: MeshEdge, value: any): void
+	getSeam(edge: MeshEdge): MeshSeamValue
+	getWorldCenter(ignore_mesh_selection?: boolean): THREE.Vector3
+	addVertices(...ArrayVector3: ArrayVector3[]): string[]
+	addFaces(...MeshFace: MeshFace[]): string[]
+	extend(data: MeshOptions): void
+	getUndoCopy(aspects?: any): any
+	getSelectionRotation(): THREE.Euler
+	getCenter(global: boolean): THREE.Vector3
+	forAllFaces(callback: (face: MeshFace, key: string) => void): void
+	transferOrigin(origin: ArrayVector3, update?: boolean): void
+	setColor(color: number): void
+	roll(axis: number, steps: number, origin?: ArrayVector3): void
+	flip(axis: number): void
+	moveVector(offset: ArrayVector3, axis: number, update?: boolean): void
+	resize(
+		val: number,
+		axis: number,
+		negative: boolean,
+		allow_negative: boolean,
+		bidirectional?: boolean
+	): void
+	applyTexture(texture: Texture, faces?: true | undefined | string[]): void
+
+	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 {}