blockbench-types 5.1.0 → 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/texturing/layers.d.ts

@@ -0,0 +1,140 @@
+import { Property } from "../util/property";
+interface TextureLayerData {
+    name?: string;
+    in_limbo?: boolean;
+    offset?: ArrayVector2;
+    scale?: ArrayVector2;
+    width?: number;
+    height?: number;
+    opacity?: number;
+    visible?: boolean;
+    blend_mode?: LayerBlendMode;
+    image_data?: ImageData;
+    data_url?: string;
+}
+type LayerBlendMode = 'default' | 'set_opacity' | 'color' | 'multiply' | 'add' | 'darken' | 'lighten' | 'screen' | 'overlay' | 'difference' | 'alpha_mask';
+/**
+ * Texture layers always belong to a texture and represent the layers of the texture. Each layer has its own HTML canvas and canvas context
+ */
+export declare class TextureLayer {
+    name: string;
+    uuid: UUID;
+    texture: Texture;
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    in_limbo: boolean;
+    img: HTMLImageElement;
+    menu?: Menu;
+    /**
+     * Layer offset from the top left corner of the texture to the top left corner of the layer
+     */
+    offset: ArrayVector2;
+    /**
+     * Layer scale. This is only used by the layer transform tool and should be applied and reset to 1x1 before doing further changes
+     */
+    scale: ArrayVector2;
+    opacity: number;
+    visible: boolean;
+    blend_mode: LayerBlendMode;
+    static properties: Record<string, Property<any>>;
+    constructor(data: TextureLayerData, texture?: Texture, uuid?: UUID);
+    get width(): number;
+    get height(): number;
+    get scaled_width(): number;
+    get scaled_height(): number;
+    get size(): number[];
+    get selected(): boolean;
+    extend(data: TextureLayerData): void;
+    /**
+     * Selects the layer
+     */
+    select(): void;
+    clickSelect(event: any): void;
+    showContextMenu(event: MouseEvent): void;
+    /**
+     * Remove the layer
+     * @param undo Create an undo point and update the texture
+     */
+    remove(undo?: boolean): void;
+    getUndoCopy(image_data: boolean): any;
+    getSaveCopy(): any;
+    /**
+     * Set the layer into a limbo state, where clicking Place or clicking next to the layer will place it on the layer below
+     */
+    setLimbo(): void;
+    /**
+     * Resolves the limbo state by turning the limbo layer into a full layer, or merging it into the layer below
+     * @param keep_separate If true, the layer is kept as a separate layer
+     */
+    resolveLimbo(keep_separate: boolean): void;
+    /**
+     * Set the layer size. This resizes the canvas, which discards the layer content
+     */
+    setSize(width: number, height: number): this;
+    /**
+     * Toggle layer visibility. This creates an undo point
+     */
+    toggleVisibility(): this;
+    /**
+     * Scroll the layer panel list to
+     */
+    scrollTo(): this;
+    /**
+     * Add the layer to the associated texture above the previously selected layer, select this layer, and scroll the layer panel list to it
+     */
+    addForEditing(): this;
+    /**
+     * Merge this texture onto the texture below
+     * @param undo Create an undo entry
+     */
+    mergeDown(undo?: boolean): void;
+    /**
+     * Expand the layer to include the listed pixels
+     * @param points
+     */
+    expandTo(...points: ArrayVector2[]): void;
+    /**
+     * Flip the texture along an axis
+     * @param axis Flip axis, where 0 is X and 1 is Y
+     * @param undo Create an undo entry
+     */
+    flip(axis: 0 | 1, undo: boolean): void;
+    /**
+     * Rotate the layer around itself in 90 degree steps
+     * @param angle Angle in degrees
+     * @param undo Create an undo entry
+     */
+    rotate(angle: number, undo: boolean): void;
+    /**
+     * Centers the layer on the texture
+     */
+    center(): void;
+    /**
+     * Open the properties dialog
+     */
+    propertiesDialog(): void;
+    /**
+     * Get all layers of the active texture
+     */
+    static all: TextureLayer[];
+    /**
+     * Get the selected layer
+     */
+    static selected: TextureLayer | null;
+}
+declare global {
+    interface BarItemRegistry {
+        layer_opacity: NumSlider;
+        layer_blend_mode: BarSelect;
+        selection_tool: Tool;
+        create_empty_layer: Action;
+        import_layer: Action;
+        enable_texture_layers: Action;
+        disable_texture_layers: Action;
+        layer_to_texture_size: Action;
+        merge_layer_down: Action;
+        crop_layer_to_selection: Action;
+        opacity_slider: NumSlider;
+    }
+}
+export {};

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: {
         /**
@@ -20,5 +12,5 @@ declare const global: {
     };
 };
 declare global {
-    const StateMemory: typeof global.StateMemory;
+    const StateMemory: (typeof global.StateMemory) & Record<string, any>;
 }

package/index.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="./custom/blockbench"/>
-/// <reference types="./generated/main"/>
+/// <reference types="./custom/blockbench"/>
+/// <reference types="./generated/main"/>

package/package.json

@@ -1,39 +1,39 @@
-{
-	"name": "blockbench-types",
-	"version": "5.1.0",
-	"description": "Blockbench typescript types",
-	"main": "",
-	"types": "./index.d.ts",
-	"typeScriptVersion": "5.8",
-	"keywords": [
-		"blockbench"
-	],
-	"author": "JannisX11",
-	"bugs": {
-		"url": "https://github.com/JannisX11/blockbench/issues"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/JannisX11/blockbench"
-	},
-	"homepage": "https://blockbench.net",
-	"dependencies": {
-		"@babel/types": "^7.20.7",
-		"@types/dompurify": "^3.0.5",
-		"@types/jquery": "^3.5.32",
-		"@types/prismjs": "^1.26.0",
-		"@types/three": "^0.129.2",
-		"@types/tinycolor2": "^1.4.6",
-		"dompurify": "^3.0.1",
-		"electron": "^40.8.0",
-		"prismjs": "^1.29.0",
-		"tinycolor2": "^1.6.0",
-		"typescript": "^5.8.3",
-		"vue": "2.7.14",
-		"wintersky": "^1.3.0"
-	},
-	"devDependencies": {
-		"@types/node": "^18.14.6",
-		"prettier": "^2.8.3"
-	}
-}
+{
+	"name": "blockbench-types",
+	"version": "5.2.0-beta.0-next.2",
+	"description": "Blockbench typescript types",
+	"main": "",
+	"types": "./index.d.ts",
+	"typeScriptVersion": "5.8",
+	"keywords": [
+		"blockbench"
+	],
+	"author": "JannisX11",
+	"bugs": {
+		"url": "https://github.com/JannisX11/blockbench/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/JannisX11/blockbench"
+	},
+	"homepage": "https://blockbench.net",
+	"dependencies": {
+		"@babel/types": "^7.20.7",
+		"@types/dompurify": "^3.0.5",
+		"@types/jquery": "^3.5.32",
+		"@types/prismjs": "^1.26.0",
+		"@types/three": "^0.129.2",
+		"@types/tinycolor2": "^1.4.6",
+		"dompurify": "^3.0.1",
+		"electron": "^40.8.0",
+		"prismjs": "^1.29.0",
+		"tinycolor2": "^1.6.0",
+		"typescript": "^5.8.3",
+		"vue": "2.7.14",
+		"wintersky": "^1.3.0"
+	},
+	"devDependencies": {
+		"@types/node": "^18.14.6",
+		"prettier": "^2.8.3"
+	}
+}

package/tsconfig.json

@@ -1,19 +1,19 @@
-{
-	"include": [
-		"custom/**/*",
-		"generated/**/*",
-	],
-  "compilerOptions": {
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "module": "ES2022",
-    "moduleResolution": "Node",
-    "jsx": "preserve",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "lib": ["ES2023", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
-    "noEmit": true
-  }
-}
+{
+	"include": [
+		"custom/**/*",
+		"generated/**/*",
+	],
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ES2022",
+    "moduleResolution": "Node",
+    "jsx": "preserve",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "noEmit": true
+  }
+}

package/type_config.json

@@ -1,47 +1,44 @@
-{
-	"exclude": [
-		"interface/action_control",
-		"animations/animation_controllers",
-		"animations/animation",
-		"animations/keyframe",
-		"animations/molang",
-		"animations/timeline",
-		"interface/menu",
-		"interface/setup_settings",
-		"desktop",
-		"util/math_util",
-		"display_mode/display_references",
-		"display_mode/display_mode",
-		"interface/interface",
-		"outliner/cube",
-		"outliner/group",
-		"outliner/locator",
-		"outliner/mesh",
-		"outliner/null_object",
-		"outliner/outliner",
-		"outliner/texture_mesh",
-		"preview/preview_scenes",
-		"preview/preview",
-		"preview/canvas",
-		"io/codec",
-		"io/io",
-		"preview/screenshot",
-		"texturing/painter",
-		"texturing/texture_groups",
-		"texturing/textures",
-		"texturing/layers",
-		"undo",
-		"web",
-		"copy_paste",
-		"uv/uv",
-		"validator",
-		"native_apis_web",
-		"util/util",
-		"lib/fik",
-		"lib/gif",
-		"lib/fik",
-		"lib/lzutf8",
-		"lib/VuePrismEditor",
-		"lib/VuePrismEditor.min"
-	]
+{
+	"exclude": [
+		"interface/action_control",
+		"animations/animation_controllers",
+		"animations/animation",
+		"animations/keyframe",
+		"animations/molang",
+		"animations/timeline",
+		"interface/setup_settings",
+		"desktop",
+		"util/math_util",
+		"display_mode/display_references",
+		"display_mode/display_mode",
+		"interface/interface",
+		"outliner/cube",
+		"outliner/group",
+		"outliner/locator",
+		"outliner/mesh",
+		"outliner/null_object",
+		"outliner/outliner",
+		"outliner/texture_mesh",
+		"preview/preview_scenes",
+		"preview/canvas",
+		"io/codec",
+		"io/io",
+		"preview/screenshot",
+		"texturing/painter",
+		"texturing/texture_groups",
+		"texturing/textures",
+		"undo",
+		"web",
+		"copy_paste",
+		"uv/uv",
+		"validator",
+		"native_apis_web",
+		"util/util",
+		"lib/fik",
+		"lib/gif",
+		"lib/fik",
+		"lib/lzutf8",
+		"lib/VuePrismEditor",
+		"lib/VuePrismEditor.min"
+	]
 }