blockbench-types 5.0.6 → 5.1.0-beta.0-next.1

package/custom/action.d.ts

@@ -523,18 +523,18 @@ declare global {
 		get(): number
 	}
 	interface BarSelectOptions<T> extends WidgetOptions {
-		value?: T
+		value?: string
 		options: Record<string, T>
 	}
 	class BarSelect<T> extends Widget {
 		constructor(id: string, options: BarSelectOptions<T>)
 		open(event: Event): void
 		trigger(event: Event): boolean | undefined
-		change(value: T, event: Event): this
+		change(value: string, event: Event): this
 		getNameFor(key: string): string
 		set(key: string): this
 		get(): string
-		value: T
+		value: string
 	}
 	class BarText extends Widget {
 		constructor(

package/custom/animation.d.ts

@@ -71,6 +71,7 @@ declare class _Animation extends AnimationItem {
 	 * Returns (if necessary creates) the animator of a specific outliner node of this animation
 	 */
 	getBoneAnimator(node?: OutlinerNode): BoneAnimator
+	removeAnimator(id: string): void
 	/**
 	 * Adds the animation to the current project and to the interface
 	 * @param undo If true, the addition of the animation will be registered as an edit

package/custom/cube.d.ts

@@ -82,7 +82,7 @@ declare class Cube extends OutlinerElement {
 	 */
 	size(axis: number, floored?: boolean): number
 	rotationAxis(): string
-	getUndoCopy(aspects?: any): void
+	getUndoCopy(aspects?: any): any
 	getSaveCopy(): Cube
 	/**
 	 * Rotate the cube around axis in 90 degree steps
@@ -124,25 +124,6 @@ declare class Cube extends OutlinerElement {
 interface FaceOptions {
 	texture?: Texture | UUID | false
 }
-declare class Face {
-	constructor()
-	texture: UUID | false | undefined
-
-	getTexture(): Texture | undefined
-	/**
-	 * Returns a 2D rectangle around the UV face
-	 */
-	getBoundingRect(): any
-	reset(): void
-	/**
-	 * Returns a save copy of the face, ready for serialization
-	 */
-	getSaveCopy(): any
-	/**
-	 * Get a copy for undo tracking
-	 */
-	getUndoCopy(): Face
-}
 
 type CubeFaceDirection = 'north' | 'south' | 'east' | 'west' | 'up' | 'down'
 interface CubeFaceOptions extends FaceOptions {

package/custom/group.d.ts

@@ -66,7 +66,7 @@ declare class Group extends OutlinerNode {
 	cem_attach?: boolean
 	cem_model?: string
 	cem_scale?: number
-	mesh: THREE.Mesh
+	mesh: THREE.Object3D
 
 	[key: string]: any
 

package/custom/mesh.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="./blockbench"/>
+
 type OccupationMatrix = {
 	[x: number]: {
 		[y: number]: boolean

package/custom/misc.d.ts

@@ -37,6 +37,8 @@ type EventName =
 	| 'process_chat_message'
 	| 'loaded_plugin'
 	| 'unloaded_plugin'
+	| 'installed_plugin'
+	| 'uninstalled_plugin'
 	| 'update_settings'
 	| 'update_project_settings'
 	| 'save_project'
@@ -137,7 +139,7 @@ declare function updateSelection(): void
 
 declare var LZUTF8: any
 
-declare function unselectAllElements(): void
+declare function unselectAllElements(exceptions?: OutlinerNode[]): void
 declare function updateCubeHighlights(hover_cube: Cube, force_off: boolean): void
 declare function getRescalingFactor(angle: number): number
 

package/custom/molang.d.ts

@@ -1,7 +1,8 @@
-declare class Molang {
-	parse(expression: string | number, variables?: Record<string, number>): number
-	global_variables: Record<string, string | number | ((...args: number[]) => number)>
-	variableHandler: (variable: string, variables?: Record<string, number>) => number
+import MolangParser from "molangjs"
+
+type MolangParserClass = typeof MolangParser
+declare global {
+	const MolangParser: MolangParserClass
 }
 
 declare interface MolangExpression {

package/custom/outliner.d.ts

@@ -12,105 +12,138 @@ declare const elements: OutlinerNode[]
 /**
  * @private
  */
-declare class OutlinerNode {
-	static properties: Record<string, Property<any>>
-	constructor(uuid: UUID)
-	type: string
-	name: string
-	uuid: UUID
-	export: boolean
-	locked: boolean
-	parent?: (OutlinerNode & OutlinerNodeParentTraits) | 'root'
-	selected: boolean
-	menu?: Menu
-
-	public preview_controller: NodePreviewController
-	static preview_controller: NodePreviewController
-	readonly scene_object: THREE.Object3D
-
+declare abstract class OutlinerNode {
+	name: string;
+	uuid: UUID;
+	export: boolean;
+	locked: boolean;
+	parent: (OutlinerNode & OutlinerNodeParentTraits) | 'root';
+	selected: boolean;
+	menu?: Menu;
+	old_name?: string;
+	children?: OutlinerNode[];
+	name_regex: ((element?: OutlinerNode) => string | boolean) | undefined;
+	static animator?: BoneAnimator;
+	static isParent: false;
+	static all: OutlinerNode[];
+	static selected: OutlinerNode[];
+	static preview_controller: NodePreviewController;
+	static properties: Record<string, Property<any>>;
+	static behavior: Record<string, any>;
+	get preview_controller(): NodePreviewController;
 	/**
-	 * Initializes the node. This should always be called when creating nodes that will be used in the outliner.
+	 * Mark the element as selected
 	 */
-	init(): this
-	extend(data: any): void
-	addTo(target?: OutlinerNode | 'root'): this
-	sortInBefore(target?: OutlinerNode, index_modifier?: number): this
-	select(event?: any, isOutlinerClick?: boolean): this
+	markAsSelected(descendants?: boolean): void;
 	/**
-	 * Mark the element as selected
+	 * Displays the context menu of the element
+	 * @param event Mouse event, determines where the context menu spawns.
+	 */
+	showContexMenu(event: Event | HTMLElement): this;
+	getSaveCopy?(...args: any[]): Record<string, any>;
+	extend?(data: any): void;
+	constructor(uuid: UUID);
+	/**
+	 * Initializes the node. This should always be called when creating nodes that will be used in the outliner.
 	 */
-	markAsSelected(descendants?: boolean): void
-	getParentArray(): OutlinerNode[]
+	init(): this;
+	select(event?: Event, outliner_click?: boolean): false | this;
+	unselect(unselect_parent?: boolean): void;
+	clickSelect(event: MouseEvent, outliner_click?: boolean): void;
+	getTypeBehavior(flag: string): boolean | string | any;
+	sortInBefore(element?: OutlinerNode, index_modifier?: number): this;
+	addTo(target?: OutlinerNode | 'root', index?: number): this;
+	removeFromParent(): this;
+	getParentArray(): OutlinerNode[];
+	showContextMenu(event: any): this;
 	/**
 	 * Unfolds the outliner and scrolls up or down if necessary to show the group or element.
 	 */
-	showInOutliner(): this
+	showInOutliner(): void;
 	/**
 	 * Updates the Vue node of the element. This is only necessary in some rare situations
 	 */
-	updateElement(): this
+	updateElement(): this;
+	get mesh(): import("three").Object3D;
+	get scene_object(): THREE.Object3D;
+	getDepth(): number;
+	duplicate(): OutlinerNode;
 	/**
-	 * Removes the element.
+	 * Removes the node.
 	 */
-	remove(undo?: boolean): void
+	remove(remove_children?: boolean): void;
 	/**
 	 * Marks the name of the group or element in the outliner for renaming.
 	 */
-	rename(): this
+	rename(): this;
 	/**
 	 * Saves the changed name of the element by creating an undo point and making the name unique if necessary.
 	 */
-	saveName(save?: boolean): this
+	saveName(save?: boolean): this;
+	sanitizeName(): string;
 	/**
 	 * Create a unique name for the group or element by adding a number at the end or increasing it.
 	 */
-	createUniqueName(others?: OutlinerNode[]): this
+	createUniqueName(others?: OutlinerNode[]): string | false;
+	isIconEnabled(toggle: any): any;
+	matchesFilter(search_term_lowercase: any): any;
 	/**
 	 * Checks of the group or element is a child of `group`.
 	 * @param max_levels The maximum number of generations that can be between the element and the group
 	 */
-	isChildOf(node: OutlinerNode, max_levels: number): boolean
-	/**
-	 * Displays the context menu of the element
-	 * @param event Mouse event, determines where the context menu spawns.
-	 */
-	showContexMenu(event: Event | HTMLElement): this
-	getSaveCopy?(...args: any[]): Record<string, any>
-	sanitizeName(): string
-
-	getTypeBehavior(flag: string): boolean | string | any
-
-	static addBehaviorOverride(override_options: {condition: ConditionResolvable, priority?: number, behavior: Record<string, any>}): Deletable
-	static behavior_overrides = [];
-
+	isChildOf(node: OutlinerNode, max_levels: number): boolean;
+	static addBehaviorOverride(override_options: {
+		condition: ConditionResolvable;
+		priority?: number;
+		behavior: Record<string, any>;
+	}): Deletable;
+	static behavior_overrides: any[];
 	static uuids: {
-		[uuid: UUID]: OutlinerNode
-	}
+		[uuid: UUID]: OutlinerNode;
+	};
+	type: string;
 }
 
+
 /**
  * @private
  */
-declare class OutlinerElement extends OutlinerNode {
-	static animator?: BoneAnimator
-
-	constructor(data: any, uuid: string)
-	selected: boolean
-	allow_mirror_modeling?: boolean
-	mesh: THREE.Object3D | THREE.Mesh
-	static fromSave(data: any, keep_uuid?: boolean): OutlinerElement
-	static isParent: false
-	static types: Record<string, typeof OutlinerElement>
-	static all: OutlinerElement[]
-	static selected: OutlinerElement[]
-	static registerType(constructor: any, id: string): void
-	select(event?: any, isOutlinerClick?: boolean): this
-	unselect(...args: any[]): this
-
+type ElementTypeConstructor = {
+	new (...args: any[]): OutlinerElement;
+	init?(): void;
+	behavior: any;
+	properties: Record<string, Property<any>>
+	selected: OutlinerElement[]
+};
+interface OutlinerElementData {
+	name?: string;
+}
+declare abstract class OutlinerElement extends OutlinerNode {
+	allow_mirror_modeling?: boolean;
+	static animator?: BoneAnimator;
+	static isParent: false;
+	static all: OutlinerElement[];
+	static selected: OutlinerElement[];
+	constructor(data: OutlinerElementData, uuid?: string);
+	init(): this;
+	remove(): this;
+	showContextMenu(event: MouseEvent): this;
+	forSelected(fc: (element: OutlinerElement) => void, undo_tag?: string, selection_method?: 'all_selected' | 'all_in_group'): OutlinerElement[];
+	duplicate(): OutlinerElement;
+	select(event?: Event, is_outliner_click?: boolean): false | this;
+	clickSelect(event: any, outliner_click?: boolean): void;
+	markAsSelected(select_children?: boolean): this;
+	unselect(unselect_parent?: boolean): this;
+	getUndoCopy(): OutlinerElement;
+	getSaveCopy(): any;
+	static fromSave(obj: any, keep_uuid?: boolean): OutlinerElement;
+	static isTypePermitted(type: string): boolean;
 	/**Check if any elements of the type are in the project */
-	static hasAny: () => boolean
+	static hasAny(): boolean;
 	/**Check if any elements of the type are currently selected */
-	static hasSelected: () => boolean
+	static hasSelected(): boolean;
+	static types: Record<string, ElementTypeConstructor>;
+	static registerType(constructor: ElementTypeConstructor, id: string): void;
 }
 
 interface LocatorOptions {

package/custom/preview_scene.d.ts

@@ -41,7 +41,7 @@ declare class PreviewModel extends Deletable {
 	constructor(id: string, options: PreviewModelOptions)
 
 	static models: {
-		(id: string): PreviewModel
+		[id: string]: PreviewModel
 	}
 	static getActiveModels(): PreviewModel[]
 
@@ -72,6 +72,7 @@ declare class PreviewModel extends Deletable {
 interface PreviewSceneOptions {
 	name?: string
 	description?: string
+	category?: string
 	light_color?: string
 	light_side?: number
 	condition?: ConditionResolvable
@@ -102,6 +103,7 @@ declare class PreviewScene extends Deletable {
 	id: string
 	name: string
 	description: string
+	category?: string
 	light_color: string
 	light_side: number
 	condition?: ConditionResolvable

package/custom/util.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="./blockbench"/>
-type ConditionResolvable =
+type ConditionResolvable<Context extends any = any> =
 	| undefined
 	| boolean
-	| any
-	| ((context: any) => any)
+	| ((context: Context) => boolean)
 	| Partial<{
 			modes: string[]
 			formats: string[]
@@ -23,21 +22,18 @@ type ConditionResolvable =
 				null_any?: boolean
 				texture_mesh?: boolean
 				outliner?: boolean
+				spline?: boolean
 			}
 			project: boolean
-			method(context: any): boolean
+			method(context: Context): boolean
 	  }>
 
 /**
- * Tests if a condition is truthy of falsy. Returns true if the condition is unspecified
+ * Tests if a condition is truthy or falsy. Returns true if the condition is unspecified
  * @param condition Boolean, function, any or anything else
  */
-declare function Condition(condition: ConditionResolvable): boolean
+declare function Condition<Context extends any = any>(condition: ConditionResolvable<Context>, context?: Context): boolean
 
-/**
- * Wrapper for anys that tells the custom JSON exporter to write in one line
- */
-const oneLiner: new <T>(data?: T) => T
 
 /**
  * If the input event is a touch event, convert touch event to a compatible mouse event
@@ -72,7 +68,7 @@ declare function convertTouchEvent(event: TouchEvent | MouseEvent): MouseEvent
 declare function guid(): string
 declare function isUUID(s: any): any
 declare function bbuid(l: any): string
-declare function trimFloatNumber(value: number): string
+declare function trimFloatNumber(value: number, decimal_places: number = 4): string
 declare function getAxisLetter(axisNumber: number): string
 declare function getAxisNumber(axisLetter: string): number
 declare function limitNumber(number: any, min: any, max: any): any
@@ -98,7 +94,6 @@ declare function get(options: any, name: any, defaultValue: any): any
 declare function getKeyByValue(any: any, value: any): any
 declare function onVueSetup(func: any): void
 declare function capitalizeFirstLetter(string: any): any
-declare function autoStringify(any: any): string
 declare function pluralS(arr: any): '' | 's'
 declare function pathToName(path: string, extension: boolean = false): string | ''
 declare function pathToExtension(path: string): string | ''

package/generated/animations/timeline_animators.d.ts

@@ -41,7 +41,7 @@ declare global {
         select(group_is_selected: any): this;
         fillValues(keyframe: any, values: any, allow_expression: any, round?: boolean): void;
         pushKeyframe(keyframe: any): this;
-        doRender(): any;
+        doRender(): import("three").Euler;
         displayRotation(arr: any, multiplier?: number): this;
         displayPosition(arr: any, multiplier?: number): this;
         displayScale(arr: any, multiplier?: number): this;
@@ -78,6 +78,7 @@ declare global {
         getElement(): OutlinerNode;
         element: OutlinerNode;
         select(element_is_selected: any): this;
+        doRender(): import("three").Object3D;
         displayPosition(arr: any, multiplier?: number): this;
         displayIK(get_samples: any): {};
         channels: {

package/generated/api.d.ts

@@ -101,12 +101,90 @@ declare global {
         findFileFromContent: typeof Filesystem.findFileFromContent;
         addDragHandler: typeof Filesystem.addDragHandler;
         removeDragHandler: typeof Filesystem.removeDragHandler;
-        queries: {};
-        ModelFormat: typeof ModelFormat;
-        settings: typeof import("./interface/settings").settings;
-        Setting: typeof import("./interface/settings").Setting;
-        SettingsProfile: typeof import("./interface/settings").SettingsProfile;
-        Settings: typeof import("./interface/settings").Settings;
     };
 }
+declare const global: {
+    LastVersion: string;
+    Blockbench: {
+        isWeb: boolean;
+        isMobile: boolean;
+        isLandscape: boolean;
+        isTouch: boolean;
+        isPWA: boolean;
+        version: string;
+        operating_system: string;
+        platform: string;
+        flags: any[];
+        drag_handlers: {};
+        events: {};
+        openTime: Date;
+        setup_successful: null | true;
+        argv: string[];
+        /**
+         * @deprecated Use Undo.initEdit and Undo.finishEdit instead
+         */
+        edit(aspects: UndoAspects, cb: () => void): void;
+        reload(): void;
+        isNewerThan(version: string): boolean;
+        isOlderThan(version: string): boolean;
+        registerEdit(): void;
+        getIconNode(icon: IconString | boolean | HTMLElement | (() => (IconString | boolean | HTMLElement)), color?: string): any;
+        showQuickMessage(message: any, time?: number): void;
+        showToastNotification(options: ToastNotificationOptions): any;
+        setCursorTooltip(text?: string): void;
+        setProgress(progress: number, time?: number, bar?: string): void;
+        showStatusMessage(message: string, time?: number): void;
+        setStatusBarText(text?: string): void;
+        showMessage(message: any, location: any): void;
+        showMessageBox(options: MessageBoxOptions, cb?: (button: number | string, result?: Record<string, boolean>, event?: Event) => void): import("./interface/dialog").MessageBox;
+        /**
+         *
+         * @param {*} title
+         * @param {*} value
+         * @param {*} callback
+         * @param {object} options Options
+         * @param {string} options.info Info text
+         * @param {string} options.description Description for the text input
+         * @returns {Promise<string>} Input value
+         */
+        textPrompt(title: string, value: string, callback: (text: string) => void, options?: {
+            placeholder?: string;
+            description?: string;
+            info?: string;
+        }): Promise<unknown>;
+        addMenuEntry(name: string, icon: IconString, click: any): void;
+        removeMenuEntry(name: string): void;
+        openLink(link: string): void;
+        notification(title: string, text: string, icon?: string): void;
+        addCSS(css: string, layer?: string): Deletable;
+        addFlag(flag: string): void;
+        removeFlag(flag: string): void;
+        hasFlag(flag: string): boolean | undefined;
+        dispatchEvent(event_name: EventName, data: any): any[];
+        on(event_name: EventName, cb: any): any;
+        once(event_name: EventName, cb: any): any;
+        addListener(event_name: EventName, cb: any): any;
+        removeListener(event_name: EventName, cb: any): any;
+        onUpdateTo(version: any, callback: any): void;
+        Format: (ModelFormat | number);
+        Project: (ModelProject | number);
+        Undo: UndoSystem;
+        import: typeof Filesystem.importFile;
+        importFile: typeof Filesystem.importFile;
+        pickDirectory: typeof Filesystem.pickDirectory;
+        read: typeof Filesystem.readFile;
+        readFile: typeof Filesystem.readFile;
+        export: typeof Filesystem.exportFile;
+        exportFile: typeof Filesystem.exportFile;
+        writeFile: typeof Filesystem.writeFile;
+        findFileFromContent: typeof Filesystem.findFileFromContent;
+        addDragHandler: typeof Filesystem.addDragHandler;
+        removeDragHandler: typeof Filesystem.removeDragHandler;
+    };
+    isApp: boolean;
+};
+declare global {
+    const LastVersion: typeof global.LastVersion;
+    const Blockbench: typeof global.Blockbench;
+}
 export {};

package/generated/auto_backup.d.ts

@@ -0,0 +1,48 @@
+declare global {
+    const AutoBackup: {
+        /**
+         * IndexedDB Database
+         */
+        db: (null | IDBDatabase);
+        initialize(): void;
+        backupOpenProject(): Promise<void>;
+        /**
+         * Test if saved backups exist
+         */
+        hasBackups(): Promise<boolean>;
+        /**
+         * Recover all saved backups
+         */
+        recoverAllBackups(confirm_selection?: boolean): Promise<void>;
+        removeBackup(uuid: string): Promise<unknown>;
+        removeAllBackups(): Promise<unknown>;
+        loop_timeout: any;
+        backupProjectLoop(run_save?: boolean): void;
+    };
+}
+declare const global: {
+    AutoBackup: {
+        /**
+         * IndexedDB Database
+         */
+        db: (null | IDBDatabase);
+        initialize(): void;
+        backupOpenProject(): Promise<void>;
+        /**
+         * Test if saved backups exist
+         */
+        hasBackups(): Promise<boolean>;
+        /**
+         * Recover all saved backups
+         */
+        recoverAllBackups(confirm_selection?: boolean): Promise<void>;
+        removeBackup(uuid: string): Promise<unknown>;
+        removeAllBackups(): Promise<unknown>;
+        loop_timeout: any;
+        backupProjectLoop(run_save?: boolean): void;
+    };
+};
+declare global {
+    const AutoBackup: typeof global.AutoBackup;
+}
+export {};

package/generated/file_system.d.ts

@@ -157,5 +157,10 @@ declare global {
         export {};
     }
 }
-
+declare const global: {
+    Filesystem: typeof import("./file_system").Filesystem;
+};
+declare global {
+    const Filesystem: typeof global.Filesystem;
+}
 export {};

package/generated/interface/dialog.d.ts

@@ -386,4 +386,20 @@ declare global {
         close(): void;
     }
 }
+declare const global: {
+    DialogSidebar: typeof import("./dialog").DialogSidebar;
+    Dialog: typeof import("./dialog").Dialog;
+    ShapelessDialog: typeof import("./dialog").ShapelessDialog;
+    MessageBox: typeof import("./dialog").MessageBox;
+    ConfigDialog: typeof import("./dialog").ConfigDialog;
+    ToolConfig: typeof import("./dialog").ToolConfig;
+};
+declare global {
+    const Dialog: typeof global.Dialog;
+    const ConfigDialog: typeof global.ConfigDialog;
+    const DialogSidebar: typeof global.DialogSidebar;
+    const MessageBox: typeof global.MessageBox;
+    const ShapelessDialog: typeof global.ShapelessDialog;
+    const ToolConfig: typeof global.ToolConfig;
+}
 export {};

package/generated/interface/form.d.ts

@@ -187,4 +187,12 @@ declare global {
         static registerType(id: string, type_class: typeof FormElement): void;
     }
 }
+declare const global: {
+    InputForm: typeof import("./form").InputForm;
+    FormElement: typeof import("./form").FormElement;
+};
+declare global {
+    const InputForm: typeof global.InputForm;
+    const FormElement: typeof global.FormElement;
+}
 export {};

package/generated/interface/panels.d.ts

@@ -155,4 +155,24 @@ declare global {
     function setActivePanel(panel_id: string): void;
     function setupMobilePanelSelector(): void;
 }
+declare const global: {
+    Panel: typeof import("./panels").Panel;
+    Panels: Record<string, Panel>;
+    setupPanels: typeof import("./panels").setupPanels;
+    updateInterfacePanels: typeof import("./panels").updateInterfacePanels;
+    updateSidebarOrder: typeof import("./panels").updateSidebarOrder;
+    updatePanelSelector: typeof import("./panels").updatePanelSelector;
+    setActivePanel: typeof import("./panels").setActivePanel;
+    setupMobilePanelSelector: typeof import("./panels").setupMobilePanelSelector;
+};
+declare global {
+    const Panel: typeof global.Panel;
+    const Panels: typeof global.Panels;
+    const setupPanels: typeof global.setupPanels;
+    const updateInterfacePanels: typeof global.updateInterfacePanels;
+    const updateSidebarOrder: typeof global.updateSidebarOrder;
+    const updatePanelSelector: typeof global.updatePanelSelector;
+    const setActivePanel: typeof global.setActivePanel;
+    const setupMobilePanelSelector: typeof global.setupMobilePanelSelector;
+}
 export {};