blockbench-types 3.8.0 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockbench-types",
-  "version": "3.8.0",
+  "version": "4.2.0",
   "description": "Blockbench typescript types",
   "main": "",
   "types": "types/index.d.ts",
@@ -19,8 +19,8 @@
   "homepage": "https://github.com/JannisX11/blockbench-types#readme",
   "dependencies": {
     "@types/jquery": "^3.5.4",
-    "three": "^0.120.0",
-    "vue": "^2.6.12",
-    "wintersky": "^0.2.0"
+    "three": "^0.129.0",
+    "vue": "^2.6.14",
+    "wintersky": "^1.1.0"
   }
 }

package/types/animation.d.ts

@@ -8,7 +8,7 @@ interface AnimationOptions {
     snapping?: number
 }
 
-class Animation {
+declare class Animation {
     constructor(data: AnimationOptions);
     extend(data: AnimationOptions): this;
     getUndoCopy(options: any, save: any): {
@@ -62,3 +62,65 @@ namespace Animator {
 
 
 }
+
+interface AddChannelOptions {
+    name?: string
+    transform?: boolean
+    mutable?: boolean
+    max_data_points?: number
+}
+declare class GeneralAnimator {
+    constructor(uuid: string, animation: Animation)
+    keyframes: Keyframe[]
+    select(): this
+    addToTimeline(): this
+    addKeyframe(data: KeyframeOptions, uuid: string): Keyframe
+    createKeyframe(): Keyframe
+    getOrMakeKeyframe(): {before: Keyframe, result: Keyframe}
+    toggleMuted(channel: string): this
+    scrollTo(): this
+
+    static addChannel(channel: string, options: AddChannelOptions)
+}
+
+declare class BoneAnimator extends GeneralAnimator {
+    name: string
+    uuid: string
+    rotations: Keyframe[]
+    position: Keyframe[]
+    scale: Keyframe[]
+    getGroup(): Group
+    select
+    fillValues
+    pushKeyframe
+    doRender
+    displayRotation
+    displayPosition
+    displayScale
+    interpolate
+    displayFrame
+}
+declare class NullObjectAnimator extends GeneralAnimator {
+    name: string
+    uuid: string
+    rotations: Keyframe[]
+    position: Keyframe[]
+    scale: Keyframe[]
+    getElement(): NullObject
+    select
+    doRender
+    displayPosition
+    displayIK
+    displayFrame
+}
+declare class EffectAnimator extends GeneralAnimator {
+    name: string
+    uuid: string
+    rotations: Keyframe[]
+    position: Keyframe[]
+    scale: Keyframe[]
+    pushKeyframe(keyframe): this
+    displayFrame(in_loop): this
+    startPreviousSounds
+}
+

package/types/canvas.d.ts

@@ -1,12 +1,52 @@
+interface UpdateViewOptions {
+    /**
+     * List of elements to update
+     */
+    elements?: OutlinerElement[]
+    /**
+     * Which aspects of the elements to update
+     */
+    element_aspects?: {
+        /**
+         * Update visibility of elements
+         */
+        visibility?: boolean
+        /**
+         * Update the position and geometry
+         */
+        geometry?: boolean
+        /**
+         * Update the mesh faces
+         */
+        faces?: boolean
+        /**
+         * Update the UV mapping
+         */
+        uv?: boolean
+        /**
+         * Update the painting grid
+         */
+        painting_grid?: boolean
+    }
+    /**
+     * Groups to update
+     */
+    groups?: Group[]
+    /**
+     * Whether to update the selection (updates the selection outlines and interface)
+     */
+    selection?: boolean
+}
+
 declare const Canvas: {
     materials: {
-        [uuid: string]: THREE.Material
+        [uuid: UUID]: THREE.Material
     };
     meshes: {
-        [uuid: string]: THREE.Mesh
+        [uuid: UUID]: THREE.Mesh
     };
     bones: {
-        [uuid: string]: THREE.Object3D
+        [uuid: UUID]: THREE.Object3D
     };
     /**
      * The material used for all selection outlines
@@ -34,6 +74,11 @@ declare const Canvas: {
      * Clear all elements from the scene
      */
     clear(): void;
+    /**
+     * Updates selected aspects of the preview
+     * @param options 
+     */
+    updateView(options: UpdateViewOptions): void; 
     /**
      * Regenerate all elements in the scene. Very unoptimized, use with care
      */
@@ -138,4 +183,4 @@ declare const TickUpdates: {
     keyframes: undefined | true
     keyframe_selection: undefined | true
     keybind_conflicts: undefined | true
-}
+}

package/types/format.d.ts

@@ -13,12 +13,17 @@ interface FormatOptions {
 	centered_grid?: boolean
 	rotate_cubes?: boolean
 	integer_size?: boolean
+	meshes?: boolean
+	texture_meshes?: boolean
 	locators?: boolean
 	canvas_limit?: boolean
 	rotation_limit?: boolean
 	uv_rotation?: boolean
 	display_mode?: boolean
 	animation_mode?: boolean
+	animation_files?: boolean
+	pose_mode?: boolean
+	texture_folder?: boolean
 
 	codec?: Codec
 	onActivation?(): void

package/types/index.d.ts

@@ -7,22 +7,29 @@
 /// <reference types="./animation" />
 /// <reference types="./canvas" />
 /// <reference types="./codec" />
+/// <reference types="./file_system" />
 /// <reference types="./format" />
+/// <reference types="./global" />
 /// <reference types="./interface" />
+/// <reference types="./panel" />
 /// <reference types="./keyframe" />
 /// <reference types="./legacy" />
 /// <reference types="./menu" />
 /// <reference types="./outliner" />
+/// <reference types="./plugin" />
 /// <reference types="./preview" />
+/// <reference types="./project" />
 /// <reference types="./settings" />
 /// <reference types="./textures" />
 /// <reference types="./timeline" />
+/// <reference types="./undo" />
 /// <reference types="./util" />
 
 
 declare class Deletable {
 	delete: () => void
 }
+type UUID = string
 
 /**
  * True if Blockbench runs as a native app
@@ -199,25 +206,6 @@ declare class Plugin {
 
 type Condition = any
 
-interface PanelOptions {
-	id: string
-	icon: string
-	menu?: any
-	growable?: boolean
-	name: string
-	selection_only?: boolean
-	condition?: Condition
-	onResize: () => void
-	toolbars: object
-	component: Vue.Component
-	default_side: any
-	insert_before: any
-	insert_after: any
-}
-declare class Panel {
-	constructor (options: PanelOptions)
-}
-
 
 interface PropertyOptions {
 	default?: any
@@ -268,3 +256,22 @@ declare function updateSelection(): void
  * @param arguments Array of arguments that replace anchors (%0, etc.) in the translation. Items can be strings or anything that can be converted to strings
  */
 declare function tl(key: string, arguments?: any[]): string
+
+declare namespace Language {
+	/**
+	 * Translation data for the current language
+	 */
+	const data: {
+		[key: string]: string
+	}
+	/**
+	 * Two letter code indicating the currently selected language
+	 */
+	const code: string
+	/**
+	 * Add translations for custom translation strings
+	 * @param language Two letter language code, e. G. 'en'
+	 * @param strings Object listing the translation keys and values
+	 */
+	function addTranslations(language: string, strings: {[key: string]: string})
+}

package/types/interface.d.ts

@@ -1,7 +1,7 @@
 interface DialogFormElement {
 	label: string
 	description?: string
-	type: 'text' | 'number' | 'checkbox' | 'select' | 'radio' | 'textarea' | 'vector' | 'color' | 'file' | 'folder' | 'save' | 'info' 
+	type: 'text' | 'number' | 'checkbox' | 'select' | 'radio' | 'textarea' | 'vector' | 'color' | 'file' | 'folder' | 'save' | 'info'
 	nocolon?: boolean
 	readonly?: boolean
 	value?: any
@@ -14,29 +14,47 @@ interface DialogFormElement {
 	height?: number
 	options?: object
 }
+
+type FormResultValue = string|number|boolean|[]
+
+interface ActionInterface {
+	name: string
+	description?: string
+	icon: string,
+	click: (event: Event) => void
+	condition: Condition
+}
 interface DialogOptions {
 	title: string
 	id: string
 	/**
-	 * Array of HTML object strings for each line of content in the dialog.
-	 */
-	lines: string[]
-	/**
-	 *  If false, the confirm button of the dialog is disabled
+	 * Default button to press to confirm the dialog. Defaults to the first button.
 	 */
-	confirmEnabled?: boolean
+	confirmIndex?: number
 	/**
-	 *  If false, the cancel button of the dialog is disabled
+	 * Default button to press to cancel the dialog. Defaults to the last button.
 	 */
-	cancelEnabled?: boolean
+	cancelIndex?: number
 	/**
 	 *  Function to execute when the user confirms the dialog
 	 */
 	onConfirm?: (formResult: object) => void
 	/**
-	 *  Function to execute when the user cancels the dialog
+	 * Function to execute when the user cancels the dialog
 	 */
 	onCancel?: () => void
+	/**
+	 * Triggered when the user presses a specific button
+	 */
+	onButton?: (button_index: number, event?: Event) => void
+	/**
+	 * Function to run when anything in the form is changed
+	 */
+	onFormChange?: (form_result: {[key: string]: FormResultValue}) => void
+	/**
+	 * Array of HTML object strings for each line of content in the dialog.
+	 */
+	lines?: (string|HTMLElement)[]
 	/**
 	 * Creates a form in the dialog
 	 */
@@ -46,20 +64,91 @@ interface DialogOptions {
 	/**
 	 * Vue component
 	 */
-	component: Vue.Component
+	component?: Vue.Component
+	/**
+	 * Order that the different interface types appear in the dialog. Default is 'form', 'lines', 'component'.
+	 */
+	part_order?: string[]
+	form_first?: boolean
+	/**
+	 * Creates a dialog sidebar
+	 */
+	sidebar?: DialogSidebarOptions
+	/**
+	 * Menu in the handle bar
+	 */
+	title_menu?: Menu
+	/**
+	 * If true, the dialog will only have one button to close it
+	 */
+	singleButton?: boolean
+	/**
+	 * List of buttons
+	 */
+	buttons?: string[]
+}
+
+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)
+
+	id: string
+	component: Vue.Component
+	sidebar: DialogSidebar | null
+
+
 	show: () => Dialog
 	hide: () => Dialog
 	/**
 	 * Triggers the confirm event of the dialog.
 	 */
-	confirm: () => void
+	confirm: (event?: Event) => void
 	/**
 	 * Triggers the cancel event of the dialog.
 	 */
-	cancel: () => void
+	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
 
+	/**
+	 * Currently opened dialog
+	 */
+	static open: Dialog | null
 }

package/types/menu.d.ts

@@ -1,7 +1,21 @@
 interface CustomMenuItem {
     name: string
+    id: string
+    icon: IconString
+    color?: string
+    description?: string
+    /**
+     * Keybind or string to display in the menu, won't work as an actual keybinding by default
+     */
+    keybind?: Keybind | string
+    /**
+     * Adds a search bar to the menu or submenu
+     */
+    searchable?: boolean
+    children?: MenuItem[] | (() => MenuItem[])
+    click?: (context?: any, event: Event)
 }
-type MenuItem = CustomMenuItem | Action | string;
+type MenuItem = CustomMenuItem | Action | BarSelect | string;
 
 /**
  * Creates a new context menu
@@ -37,6 +51,10 @@ declare class Menu extends Deletable {
  */
 declare class BarMenu extends Menu {
     constructor(id: string, structure: MenuItem[], condition?: any)
+    /**
+     * Visually highlights an action within the menu, until the user opens the menu
+     */
+    highlight(action: Action): void
 }
 
 declare namespace MenuBar {

package/types/outliner.d.ts

@@ -7,7 +7,7 @@ type ArrayVector2 = [number, number]
  */
 declare class OutlinerNode {
 	constructor ()
-	uuid: string
+	uuid: UUID
 	export: boolean
 	locked: boolean
 	parent: Group | 'root'

package/types/panel.d.ts

@@ -0,0 +1,54 @@
+interface PanelOptions {
+	id: string
+	name: string
+	icon: string
+	menu?: any
+	growable?: boolean
+	selection_only?: boolean
+	condition?: Condition
+	display_condition?: Condition
+	expand_button: boolean
+	toolbars: {
+		[id: string]: Toolbar
+	}
+	default_position: {
+		slot: string
+		float_position: [number, number]
+		float_size: [number, number]
+		height: number
+		folded: boolean
+	}
+	component: Vue.Component
+	default_side: 'right' | 'left'
+	insert_before: string
+	insert_after: string
+	onResize: () => void
+	onFold: () => void
+}
+type PanelEvent = 'drag' | 'fold' | 'change_zindex' | 'move_to' | 'moved_to' | 'update'
+
+declare class Panel {
+	constructor (id: string, options: PanelOptions)
+	constructor (options: PanelOptions)
+	isVisible(): boolean
+	isInSidebar(): boolean
+	slot: string
+	folded: boolean
+	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
+	update(dragging?: boolean): this
+	dispatchEvent(event_name: PanelEvent, data?: any): void
+	/**
+	 * Add an event listener
+	 */
+	on(event_name: PanelEvent, callback: (data?) => void): void
+	removeListener(event_name: PanelEvent, callback: (data?) => void): void
+	delete(): void
+}
+
+declare function updateInterfacePanels(): void
+declare function setActivePanel(panel_id: string): void

package/types/plugin.d.ts

@@ -10,19 +10,43 @@ interface PluginOptions {
 	 */
 	about?: string
 	icon: string
+	/**
+	 * Plugin tags that will show up in the plugin store. You can provide up to 3 tags.
+	 */
+	tags?: [string, string?, string?]
+	/**
+	 * Where the plugin can be installed. Desktop refers to the electron app, web refers to the web app and PWA
+	 */
 	variant: 'both' | 'desktop' | 'web'
+	/**
+	 * Minimum Blockbench version in which the plugin can be installed
+	 */
 	min_version?: string
+	/**
+	 * Maximum Blockbench version in which the plugin can be installed
+	 */
 	max_version?: string
+	/**
+	 * Set to true if the plugin must finish loading before a project is opened, i. e. because it adds a format
+	 */
+	await_loading?: string
+	/**
+	 * Runs when the plugin loads
+	 */
 	onload?(): void
+	/**
+	 * Runs when the plugin unloads
+	 */
 	onunload?(): void
+	/**
+	 * Runs when the user manually installs the plugin
+	 */
 	oninstall?(): void
+	/**
+	 * Runs when the user manually uninstalls the plugin
+	 */
 	onuninstall?(): void
 }
-
-/**
- * Blockbench Plugin
- * @deprecated This won't work in 3.8.4 or earlier
- */
 declare class BBPlugin {
 	constructor(id: string, options: PluginOptions)
 
@@ -44,6 +68,7 @@ declare class BBPlugin {
 	variant: 'both' | 'desktop' | 'web'
 	min_version: string
 	max_version: string
+	tags: string[]
 	onload(): void
 	onunload(): void
 	oninstall(): void

package/types/project.d.ts

@@ -0,0 +1,118 @@
+interface ModelProjectOptions {
+	format: ModelFormat
+}
+
+declare class ModelProject {
+	constructor(options: ModelProjectOptions)
+
+	box_uv: boolean
+	texture_width: number
+	texture_height: number
+	name: string
+	uuid: UUID
+	selected: boolean
+	/**
+	 * When set to true, the project tab can no longer be selected or unselected
+	 */
+	locked: boolean
+	thumbnail: string
+	saved: boolean
+	/**
+	 * The path under which a project file is saved, if available
+	 */
+	save_path: string
+	/**
+	 * The path under which an exported file is saved, if available
+	 */
+	export_path: string
+	added_models: number
+	undo: UndoSystem
+	BedrockEntityManager?: {}
+	format: ModelFormat
+	mode: string
+	view_mode: string
+	display_uv: string
+	previews: {
+		[key: string]: {}
+	}
+	EditSession: EditSession
+
+	elements: OutlinerElement[]
+	groups: Group[]
+	selected_elements: OutlinerElement[]
+	selected_group: Group | null;
+	selected_vertices: {
+		[element_key: string]: string[]
+	};
+	selected_faces: []
+	textures: Texture[]
+	selected_texture: Texture | null;
+	outliner: OutlinerNode[]
+	animations: Animation[]
+	timeline_animators: []
+	display_settings: {
+		[slot: string]: {
+			translation: [number, number, number]
+			rotation: [number, number, number]
+			scale: [number, number, number]
+			mirror: [boolean, boolean, boolean]
+		}
+	};
+
+	get model_3d(): THREE.Object3D;
+    get materials(): {
+		[uuid: UUID]: THREE.ShaderMaterial
+	};
+    get nodes_3d(): {
+		[uuid: UUID]: THREE.Object3D
+	};
+
+    getDisplayName(): string;
+    openSettings(): void;
+    whenNextOpen(callback: () => void): void;
+    select(): boolean;
+    unselect(): void;
+    close(force: any): Promise<boolean>;
+
+	static all: ModelProject[]
+}
+
+declare const Project: ModelProject | null
+
+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;
+
+declare class EditSession {
+	constructor()
+
+	active: boolean
+	hosting: boolean
+	clients: {}
+	client_count: number
+	data_queue: []
+	chat_history: []
+	Project: ModelProject | null
+
+	updateClientCound(): void
+	start(username?: string): void
+	join(username: string, token: string)
+	quit(): void
+	setState(active: boolean): void
+	copyToken(): void;
+    initNewModel(force?: boolean): void;
+    initConnection(conn: any): void;
+    sendAll(type: string, data: any): void;
+    sendEdit(entry: UndoEntry): void;
+    receiveData(tag: object): void;
+    processData(tag: object): void;
+    catchUp(): void;
+	/**
+	 * Send a chat message
+	 * @param text Text to send. If omitted, the current text in the chat panel input is sent
+	 */
+    sendChat(text?: string): void;
+    addChatMessage(message: any): any;
+    processChatMessage(data: any): void;
+}

package/types/undo.d.ts

@@ -0,0 +1,60 @@
+interface UndoAspects {
+    selection?: boolean
+    elements?: OutlinerElement[]
+    outliner?: boolean
+    group?: Group
+    textures?: Texture[]
+    texture_order?: boolean
+    selected_texture?: boolean
+    settings?: {}
+    uv_mode?: boolean
+    animations?: Animation[]
+    keyframes?: Keyframe[]
+    display_slots?: string[]
+    exploded_view?: boolean
+}
+type UndoSave = {
+    aspects: UndoAspects
+    selection?: []
+    selection_group?: UUID
+    elements?: {}
+    outliner?: []
+    group?: {}
+    textures?: {}
+    texture_order?: UUID[]
+    selected_texture?: UUID | null
+    settings?: {}
+    uv_mode?: {
+        box_uv: boolean
+        width: number
+        height: number
+    }
+    animations?: {}
+    keyframes?: {}
+    display_slots?: {}
+    exploded_views?: boolean
+}
+type UndoEntry = {
+    before: UndoSave
+    post: UndoSave
+    action: string
+    time: number
+}
+
+declare class UndoSystem {
+    constructor();
+    initEdit(aspects: UndoAspects): any;
+    finishEdit(action: string, aspects?: UndoAspects): {
+        before: any;
+        post: any;
+        action: any;
+        time: number;
+    };
+    cancelEdit(): void;
+    addKeyframeCasualties(keyframes: Keyframe[]): void;
+    undo(remote?: boolean): void;
+    redo(remote?: boolean): void;
+    remoteEdit(entry: UndoEntry): void;
+    loadSave(save: UndoSave, reference: UndoSave, mode?: string): void;
+}
+declare let Undo: UndoSystem;

package/types/util.d.ts

@@ -19,7 +19,6 @@ declare class oneLiner {
 }
 
 declare const templog: (...args: any) => void
-}
 
 /**
  * If the input event is a touch event, convert touch event to a compatible mouse event