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

package/generated/preview/preview.d.ts

@@ -0,0 +1,280 @@
+import { ConfigDialog } from '../interface/dialog';
+interface AnglePreset {
+    name?: string;
+    id?: string;
+    color?: string;
+    condition?: ConditionResolvable;
+    default?: true;
+    position: ArrayVector3;
+    target?: ArrayVector3;
+    rotation?: ArrayVector3;
+    projection: 'unset' | 'orthographic' | 'perspective';
+    zoom?: number;
+    focal_length?: number;
+    fov?: number;
+    aspect_ratio?: number;
+    locked_angle?: number;
+}
+type PreviewAnnotation = {
+    node: HTMLElement;
+    object: THREE.Object3D;
+};
+export type RaycastResult = {
+    type: 'element' | 'keyframe' | 'vertex' | 'cube' | 'line' | 'none';
+    event: PointerEvent | MouseEvent | TouchEvent;
+    cube?: Cube;
+    intersects?: THREE.Intersection[];
+    intersect?: THREE.Intersection;
+    face?: string;
+    vertex?: any;
+    vertices?: [string, string];
+    keyframe?: _Keyframe;
+    vertex_index?: number;
+    element?: OutlinerElement;
+};
+type SplitScreenMode = 'single' | 'double_horizontal' | 'double_vertical' | 'quad' | 'triple_left' | 'triple_right' | 'triple_top' | 'triple_bottom';
+export declare const three_grid: import("three").Object3D;
+export declare const gizmo_colors: {
+    r: import("three").Color;
+    g: import("three").Color;
+    b: import("three").Color;
+    grid: import("three").Color;
+    solid: import("three").Color;
+    outline: import("three").Color;
+    gizmo_hover: import("three").Color;
+    spline_handle_aligned: import("three").Color;
+    spline_handle_mirrored: import("three").Color;
+    spline_handle_free: import("three").Color;
+    u: import("three").Color;
+    v: import("three").Color;
+    w: import("three").Color;
+};
+export declare const DefaultCameraPresets: AnglePreset[];
+interface PreviewOptions {
+    id: string;
+    antialias?: boolean;
+    offscreen?: boolean;
+}
+/**
+ * Previews are 3D viewports, that can either be used as a viewport for the user, or as an offscreen view to record media.
+ */
+export declare class Preview {
+    id: string;
+    canvas: HTMLCanvasElement;
+    height: number;
+    width: number;
+    aspect_ratio?: number;
+    node: HTMLElement;
+    label: HTMLLabelElement;
+    /**
+     * True if the preview is in orthographic camera mode
+     */
+    isOrtho: boolean;
+    /**
+     * Angle, when in a specific side view
+     */
+    angle: null | string;
+    default_angle: AnglePreset;
+    camPers: THREE.PerspectiveCamera;
+    camOrtho: THREE.OrthographicCamera & {
+        axis: string;
+        backgroundHandle: any;
+    };
+    controls: any;
+    annotations: Record<string, PreviewAnnotation>;
+    offscreen?: boolean;
+    renderer: THREE.WebGLRenderer;
+    background: {
+        name: string;
+        image: any;
+        size: number;
+        x: number;
+        y: number;
+        lock: boolean;
+    };
+    side_view_target: THREE.Vector3;
+    raycaster: THREE.Raycaster;
+    orbit_gizmo?: OrbitGizmo;
+    selection: {
+        box: HTMLElement;
+        frustum: THREE.Frustum;
+        activated: boolean;
+        start_x: number;
+        start_y: number;
+        client_x: number;
+        client_y: number;
+        sr_move_f?: any;
+        sr_stop_f?: any;
+        click_target?: RaycastResult;
+        old_selected?: OutlinerElement[];
+        old_mesh_selection?: any;
+        old_spline_selection?: any;
+    };
+    static_rclick: boolean;
+    rclick_cooldown: any;
+    event_start?: ArrayVector2;
+    mouse: THREE.Vector2;
+    constructor(options: PreviewOptions);
+    /**
+     * Set a size of the preview in pixels. With no arguments, and if the preview node is connected to the DOM, it will adjust to the size of the parent element
+     */
+    resize(width?: number, height?: number): this;
+    updateToneMapping(): void;
+    raycast(event: MouseEvent, options?: {
+        edges?: boolean;
+        vertices?: boolean;
+    }): false | RaycastResult;
+    render(): void;
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    setProjectionMode(orthographic: boolean, toggle?: boolean): this;
+    setFOV(fov: number): void;
+    setNormalCamera(): this;
+    setLockedAngle(angle?: number): this;
+    setDefaultAnglePreset(preset: AnglePreset): this;
+    loadAnglePreset(preset: AnglePreset): this;
+    /**
+     * Opens a dialog to create and save a new angle preset
+     */
+    newAnglePreset(): this;
+    getFacingDirection(): 'north' | 'south' | 'east' | 'west';
+    getFacingHeight(): 'up' | 'middle' | 'down';
+    click(event?: PointerEvent): boolean;
+    mousemove(event: MouseEvent): void;
+    mouseup(event: MouseEvent): this;
+    raycastMouseCoords(x: number, y: number): import("three").Vector3;
+    vectorToScreenPosition(vector: any): {
+        x: any;
+        y: any;
+    };
+    showContextMenu(event: MouseEvent): this;
+    occupyTransformer(event?: MouseEvent | TouchEvent): this;
+    calculateControlScale(position: any): number;
+    updateAnnotations(): void;
+    addAnnotation(key: string, tag: PreviewAnnotation): void;
+    removeAnnotation(key: any): void;
+    startSelRect(event: PointerEvent): void;
+    moveSelRect(event: MouseEvent): void;
+    stopSelRect(event: any): void;
+    loadBackground(): void;
+    updateBackground(): void;
+    copyView(preview: Preview): void;
+    /**
+     * Take a screenshot of the current view of the preview
+     */
+    screenshot(options: ScreenshotOptions, callback: ScreenshotReturn): void;
+    fullscreen(): this;
+    toggleFullscreen(): void;
+    delete(): void;
+    /**
+     * The last used preview
+     */
+    static selected: any;
+    /**
+     * List of all previews
+     */
+    static all: Preview[];
+    /**
+     * Utility regarding split screen preview mode
+     */
+    static split_screen: {
+        /**
+         * Whether the split screen is enabled
+         */
+        enabled: boolean;
+        /**
+         * The current split screen mode
+         */
+        mode: string;
+        before: any;
+        previews: Preview[];
+        lazyLoadPreview(index: number, camera_preset?: AnglePreset): Preview;
+        /**
+         * Set a split screen mode
+         */
+        setMode(mode?: SplitScreenMode): void;
+        /**
+         * Update the size of the split screens
+         */
+        updateSize(): void;
+    };
+    menu: Menu;
+}
+export declare const ViewOptionsDialog: ConfigDialog;
+export declare function editCameraPreset(preset: any, presets: any): void;
+export declare class OrbitGizmo {
+    preview: Preview;
+    node: HTMLDivElement;
+    lines: Record<axisLetter, SVGPathElement>;
+    sides: Record<string, {
+        opposite: string;
+        axis: axisLetter;
+        sign: 1 | -1;
+        label?: string;
+        node?: HTMLDivElement;
+    }>;
+    constructor(preview: Preview, options?: {});
+    update(): void;
+    hide(): void;
+    unhide(): void;
+}
+export declare function setupPreviews(): void;
+export declare function animate(): void;
+declare const global: {
+    main_preview: import("./preview").Preview;
+    three_grid: import("three").Object3D;
+    gizmo_colors: {
+        r: import("three").Color;
+        g: import("three").Color;
+        b: import("three").Color;
+        grid: import("three").Color;
+        solid: import("three").Color;
+        outline: import("three").Color;
+        gizmo_hover: import("three").Color;
+        spline_handle_aligned: import("three").Color;
+        spline_handle_mirrored: import("three").Color;
+        spline_handle_free: import("three").Color;
+        u: import("three").Color;
+        v: import("three").Color;
+        w: import("three").Color;
+    };
+    DefaultCameraPresets: AnglePreset[];
+    Preview: typeof import("./preview").Preview;
+    ViewOptionsDialog: ConfigDialog;
+    editCameraPreset: typeof import("./preview").editCameraPreset;
+    OrbitGizmo: typeof import("./preview").OrbitGizmo;
+};
+declare global {
+    type Preview = import('./preview').Preview;
+    const Preview: typeof global.Preview;
+    type OrbitGizmo = import('./preview').OrbitGizmo;
+    const OrbitGizmo: typeof global.OrbitGizmo;
+    const three_grid: typeof global.three_grid;
+    const gizmo_colors: typeof global.gizmo_colors;
+    const DefaultCameraPresets: typeof global.DefaultCameraPresets;
+    const ViewOptionsDialog: typeof global.ViewOptionsDialog;
+    const editCameraPreset: typeof global.editCameraPreset;
+    const updateShading: () => void;
+    let MediaPreview: Preview;
+    function animate(): void;
+    interface BarItemRegistry {
+        view_mode: BarSelect;
+        preview_checkerboard: Toggle;
+        uv_checkerboard: Toggle;
+        toggle_shading: Toggle;
+        toggle_all_grids: Toggle;
+        toggle_ground_plane: Toggle;
+        toggle_motion_trails: Toggle;
+        pixel_grid: Toggle;
+        split_screen: BarSelect;
+        focus_on_selection: Action;
+        toggle_camera_projection: Action;
+        camera_initial: Action;
+        camera_top: Action;
+        camera_bottom: Action;
+        camera_south: Action;
+        camera_north: Action;
+        camera_east: Action;
+        camera_west: Action;
+    }
+}
+export {};

package/generated/preview/reference_images.d.ts

@@ -68,7 +68,7 @@ declare global {
         changeScope(new_scope: any): this;
         enableBlueprintMode(): void;
         propertiesDialog(): this;
-        menu: Menu;
+        menu: import("../interface/menu").Menu;
     }
     namespace ReferenceImage {
         let selected: any;

package/generated/util/gif.d.ts

@@ -1,6 +1,15 @@
 declare global {
-    function quantize(data: any, opts: any): number[][];
-    function applyPalette(data: any, palette: any, opts: any): Uint8Array<ArrayBuffer>;
+    interface QuantizeOptions {
+        has_transparency?: boolean;
+        /**
+         * If true, prioritize color accuracy
+         */
+        prio_color_accuracy?: boolean;
+    }
+}
+type GIFPalette = [number, number, number][];
+declare global {
+    function quantize(data: Uint8ClampedArray<ArrayBuffer>, opts: QuantizeOptions): GIFPalette;
+    function applyPalette(data: Uint8ClampedArray<ArrayBuffer>, palette: GIFPalette, opts: QuantizeOptions): Uint8Array;
 }
-
 export {};

package/generated/util/state_memory.d.ts

@@ -1,13 +1,5 @@
-declare const StateMemory: {
-    /**
-     * Initialize a memorized property
-     */
-    init(key: string, type: "string" | "number" | "boolean" | "object" | "array"): void;
-    set(key: string, value: any): void;
-    save(key: string): void;
-    get(key: string): string | number | [] | boolean | any;
-};
-export default StateMemory;
+declare const _default: (typeof global.StateMemory) & Record<string, any>;
+export default _default;
 declare const global: {
     StateMemory: {
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blockbench-types",
-	"version": "5.2.0-beta.0-next.1",
+	"version": "5.2.0-beta.0-next.2",
 	"description": "Blockbench typescript types",
 	"main": "",
 	"types": "./index.d.ts",

package/type_config.json

@@ -6,7 +6,6 @@
 		"animations/keyframe",
 		"animations/molang",
 		"animations/timeline",
-		"interface/menu",
 		"interface/setup_settings",
 		"desktop",
 		"util/math_util",
@@ -21,7 +20,6 @@
 		"outliner/outliner",
 		"outliner/texture_mesh",
 		"preview/preview_scenes",
-		"preview/preview",
 		"preview/canvas",
 		"io/codec",
 		"io/io",

package/custom/menu.d.ts

@@ -1,137 +0,0 @@
-/// <reference types="./blockbench"/>
-interface CustomMenuItem {
-	name: string
-	id?: string
-	icon: IconString | boolean | ((context: any) => (IconString|boolean))
-	color?: string
-	description?: string
-	condition?: ConditionResolvable
-	/**
-	 * 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[] | ((context: any) => MenuItem[])
-	click?(context?: any, event?: Event): void
-}
-type MenuItem = CustomMenuItem | Action | BarSelect<string> | MenuSeparator | string
-interface MenuOptions {
-	onOpen?(position: MouseEvent | HTMLElement, context?: any): void
-	onClose?(): void
-	keep_open?: boolean
-	searchable?: boolean
-	class?: string
-}
-/**
- * Use the Menu class to create a context menu. Menus can contain custom entries and hierarchy, or existing actions and tools.
- */
-declare class Menu extends Deletable {
-	/**
-	 * Creates a new context menu
-	 */
-	constructor(
-		id: string,
-		template: MenuItem[] | ((context?: any) => MenuItem[]),
-		options?: MenuOptions
-	)
-	constructor(template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions)
-
-	/**
-	 * Opens the menu somewhere
-	 * @param position Position where to open the menu. Can be a mouse event, or a node that the menu is spawned below.
-	 * @param context Context for the click events inside the menu
-	 */
-	open(position: MouseEvent | HTMLElement | 'mouse', context?: any): this
-	/**
-	 * Alias for .open()
-	 */
-	show(position: MouseEvent | HTMLElement | 'mouse', context?: any): this
-	/**
-	 * Closes the menu if it's open
-	 */
-	hide(): this
-	/**
-	 * 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 within a level, separated by a point. For example, `export.0` places the action at the top position of the Export submenu.
-	 */
-	addAction(action: Action | CustomMenuItem | '_', path?: string | number): void
-	/**
-	 *
-	 * @param path Path pointing to the location. Use the ID of each level of the menu, or index 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.
-	 */
-	removeAction(path: string | Action): void
-	/**
-	 * @deprecated
-	 */
-	deleteItem(rm_item: Action): void
-	hover(node: HTMLElement, event: Event, expand?: boolean): void
-	structure: MenuItem[]
-	node: HTMLUListElement
-	static open: Menu | null
-	static closed_in_this_click?: string
-}
-
-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
-	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
-	}
-	/**
-	 * 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/preview.d.ts

@@ -1,147 +0,0 @@
-/// <reference types="./blockbench"/>
-interface AnglePreset {
-	position: ArrayVector3
-	target?: ArrayVector3
-	rotation?: ArrayVector3
-	projection: 'unset' | 'orthographic' | 'perspective'
-	zoom?: number
-	focal_length?: number
-	fov?: number
-	aspect_ratio?: number
-	lockedAngle?: number
-}
-
-interface PreviewOptions {
-	id: string
-	antialias?: boolean
-}
-
-type RaycastResult = {
-	type: 'element' | 'keyframe' | 'vertex' | 'cube' | 'line' | 'none'
-	event: PointerEvent | MouseEvent | TouchEvent
-	cube?: Cube
-	intersects?: any[]
-	face?: string
-	vertex?: any
-	keyframe?: _Keyframe
-	element?: OutlinerElement
-}
-
-type SplitScreenMode = 'single'|'double_horizontal'|'double_vertical'|'quad'|'triple_left'|'triple_right'|'triple_top'|'triple_bottom'
-
-/**
- * Previews are 3D viewports, that can either be used as a viewport for the user, or as an offscreen view to record media.
- */
-declare class Preview extends Deletable {
-	constructor(options: PreviewOptions)
-
-	id: string
-	canvas: HTMLCanvasElement
-	height: number
-	width: number
-	aspect_ratio?: number
-	node: HTMLElement
-	label: HTMLLabelElement
-	/**
-	 * True if the preview is in orthographic camera mode
-	 */
-	isOrtho: boolean
-	/**
-	 * Angle, when in a specific side view
-	 */
-	angle: null | number
-	default_angle?: AnglePreset
-	readonly camera: THREE.PerspectiveCamera | THREE.OrthographicCamera
-	camPers: THREE.PerspectiveCamera
-	camOrtho: THREE.OrthographicCamera
-	controls: any
-	annotations: any
-	renderer: THREE.WebGLRenderer
-	background: {
-		name: string
-		image: any
-		size: number
-		x: number
-		y: number
-		lock: boolean
-	}
-	raycaster: THREE.Raycaster
-
-	mouse: THREE.Vector2
-
-	split_screen: {
-		before: undefined | null
-		enabled: boolean
-		lazyLoadPreview: () => void
-		mode: string
-		previews: Preview[]
-		setMode(mode: string): void
-		updateSize(): void
-	}
-
-	raycast(event: MouseEvent): false | RaycastResult
-	render(): void
-	/**
-	 * Set a size of the preview in pixels. With no arguments, and if the preview node is connected to the DOM, it will adjust to the size of the parent element
-	 */
-	resize(width?: number, height?: number): void
-	setProjectionMode(orthographic: boolean): this
-	setFOV(fov: number): void
-	setLockedAngle(angle: number): this
-
-	loadAnglePreset(angle_preset: AnglePreset): this
-	/**
-	 * Opens a dialog to create and save a new angle preset
-	 */
-	newAnglePreset(): this
-
-	getFacingDirection(): 'north' | 'south' | 'east' | 'west'
-	getFacingHeight(): 'up' | 'middle' | 'down'
-
-	occupyTransformer(): this
-	showContextMenu(event: Event | HTMLElement): this
-	loadBackground(): void
-	/**
-	 * Take a screenshot of the current view of the preview
-	 */
-	screenshot(options: ScreenshotOptions, callback: ScreenshotReturn): void
-
-	/**
-	 * List of all previews
-	 */
-	static all: Preview[]
-	/**
-	 * The last used preview
-	 */
-	static selected: Preview
-
-	/**
-	 * Utility regarding split screen preview mode
-	 */
-	static split_screen: {
-		/**
-		 * Whether the split screen is enabled
-		 */
-		enabled: boolean
-		/**
-		 * The current split screen mode
-		 */
-		mode: SplitScreenMode
-		previews: Preview[]
-		lazyLoadPreview(index: number, camera_preset): Preview
-		/**
-		 * Set a split screen mode
-		 */
-		setMode(mode: SplitScreenMode = 'single')
-		/**
-		 * Update the size of the split screens
-		 */
-		updateSize()
-	}
-}
-
-declare const DefaultCameraPresets: AnglePreset[]
-
-declare const MediaPreview: Preview
-
-declare function animate(): void