@divinevoxel/vlox 0.0.4 → 0.0.6

package/Contexts/Constructor/Tasks/DVEConstructorTasksQueues.d.ts

@@ -1,27 +0,0 @@
-import { ThreadPool } from "@amodx/threads";
-import { QueueManager } from "@amodx/threads/Queue/QueueManager";
-import { Observable } from "@amodx/core/Observers/Observable.js";
-export declare class DVEConstructorTasksQueues {
-    constructors: ThreadPool;
-    static instance: DVEConstructorTasksQueues;
-    static onCreated: Observable<DVEConstructorTasksQueues>;
-    constructor(constructors: ThreadPool);
-    _queueMap: Map<string | number, number>;
-    addQueue(queueKey: string | number): boolean;
-    removeQueue(queueKey: string | number): boolean;
-    /**# Filter Queues
-     * ---
-     * Go through each current queue. IF the passed fucntion returns false it will remove that queue.
-     * @param filter
-     */
-    filterQueues(filter: (queueKey: string | number) => boolean): void;
-    /**# Filter Old Queues
-     * ---
-     * Will remove queues older then 10 minutes.
-     * @param maxTime Max time in miliseconds.
-     */
-    filterOldQueues(maxTime?: number): void;
-    registerTasks(id: string, tasksId: number | string): void;
-    getTasks(id: string): QueueManager<any>;
-    _tasks: Map<string, QueueManager<any>>;
-}

package/Contexts/Constructor/Tasks/DVEConstructorTasksQueues.js

@@ -1,72 +0,0 @@
-import { Observable } from "@amodx/core/Observers/Observable.js";
-import { TasksIds } from "../../../Tasks/TasksIds";
-export class DVEConstructorTasksQueues {
-    constructors;
-    static instance;
-    static onCreated = new Observable();
-    constructor(constructors) {
-        this.constructors = constructors;
-        if (!DVEConstructorTasksQueues.instance)
-            DVEConstructorTasksQueues.instance = this;
-        this.registerTasks("build-chunk", TasksIds.BuildChunk);
-        DVEConstructorTasksQueues.onCreated.notify(this);
-        this.addQueue("main");
-    }
-    _queueMap = new Map();
-    addQueue(queueKey) {
-        if (this._queueMap.has(queueKey)) {
-            this._queueMap.set(queueKey, Date.now());
-            return false;
-        }
-        for (const [key, queue] of this._tasks) {
-            queue.addQueue(queueKey);
-        }
-        this._queueMap.set(queueKey, Date.now());
-        return true;
-    }
-    removeQueue(queueKey) {
-        if (!this._queueMap.has(queueKey))
-            return false;
-        for (const [key, queue] of this._tasks) {
-            queue.removeQueue(queueKey);
-        }
-        this._queueMap.delete(queueKey);
-        return true;
-    }
-    /**# Filter Queues
-     * ---
-     * Go through each current queue. IF the passed fucntion returns false it will remove that queue.
-     * @param filter
-     */
-    filterQueues(filter) {
-        this._queueMap.forEach((v, key) => {
-            if (!filter(key)) {
-                this.removeQueue(key);
-            }
-        });
-    }
-    /**# Filter Old Queues
-     * ---
-     * Will remove queues older then 10 minutes.
-     * @param maxTime Max time in miliseconds.
-     */
-    filterOldQueues(maxTime = 600000) {
-        const t = Date.now();
-        this._queueMap.forEach((v, key) => {
-            if (t - v > maxTime) {
-                this.removeQueue(key);
-            }
-        });
-    }
-    registerTasks(id, tasksId) {
-        const newTasks = this.constructors.addQueue(id, tasksId);
-        this._tasks.set(id, newTasks);
-    }
-    getTasks(id) {
-        const tasks = this._tasks.get(id);
-        if (!tasks)
-            throw new Error(`The queue with the ${id} does not exist`);
-        return tasks;
-    }
-    _tasks = new Map();
-}

package/Contexts/Render/Scene/MeshRegister.d.ts

@@ -1,39 +0,0 @@
-import { type LocationData } from "../../../Math/index.js";
-import { MushRegisterRegion } from "../../../Renderer/Classes/MushRegisterRegion.js";
-import { MeshRegisterColumn } from "../../../Renderer/Classes/MeshRegisterColumn.js";
-import { ChunkMesh } from "../../../Renderer/Classes/ChunkMesh.js";
-import { ChunkMeshInterface } from "../../../Renderer/DVEChunkMeshInterface.js";
-export type MeshRegisterDimensions = Map<string, Map<string, MushRegisterRegion>>;
-declare class Chunk {
-    static addMesh(location: LocationData, mesh: ChunkMeshInterface, substance: string): ChunkMesh;
-    static add(location: LocationData): ChunkMesh;
-    static removeMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
-    static getMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
-    static remove(location: LocationData): false | ChunkMesh;
-    static get(location: LocationData): false | ChunkMesh;
-}
-declare class Column {
-    static add(location: LocationData): MeshRegisterColumn;
-    static remove(location: LocationData): false | MeshRegisterColumn;
-    static get(location: LocationData): false | MeshRegisterColumn | undefined;
-}
-declare class Region {
-    static add(location: LocationData): MushRegisterRegion;
-    static remove(location: LocationData): boolean;
-    static get(location: LocationData): false | MushRegisterRegion;
-}
-declare class Dimensions {
-    static add(id: string): Map<any, any>;
-    static get(id: string): Map<string, MushRegisterRegion> | undefined;
-    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: ChunkMeshInterface]>;
-    static remove(id: string): boolean;
-}
-export declare class MeshRegister {
-    static _dimensions: MeshRegisterDimensions;
-    static dimensions: typeof Dimensions;
-    static region: typeof Region;
-    static column: typeof Column;
-    static chunk: typeof Chunk;
-    static clearAll(): void;
-}
-export {};

package/Contexts/Render/Scene/MeshRegister.js

@@ -1,218 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
-import { MushRegisterRegion } from "../../../Renderer/Classes/MushRegisterRegion.js";
-import { MeshRegisterColumn } from "../../../Renderer/Classes/MeshRegisterColumn.js";
-import { ChunkMesh } from "../../../Renderer/Classes/ChunkMesh.js";
-class Chunk {
-    static addMesh(location, mesh, substance) {
-        let column = MeshRegister.column.get(location);
-        if (!column) {
-            column = MeshRegister.column.add(location);
-        }
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        let chunk = column.chunks.get(index);
-        if (!chunk) {
-            chunk = new ChunkMesh([location[1], location[2], location[3]]);
-            column.chunks.set(index, chunk);
-        }
-        chunk?.meshes.set(substance, mesh);
-        return chunk;
-    }
-    static add(location) {
-        let column = MeshRegister.column.get(location);
-        if (!column) {
-            column = MeshRegister.column.add(location);
-        }
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        let chunk = column.chunks.get(index);
-        if (!chunk) {
-            chunk = new ChunkMesh([location[1], location[2], location[3]]);
-            column.chunks.set(index, chunk);
-        }
-        return chunk;
-    }
-    static removeMesh(location, substance) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        const chunk = column.chunks.get(index);
-        if (!chunk)
-            return false;
-        const chunkMesh = chunk.meshes.get(substance);
-        if (!chunkMesh)
-            return false;
-        chunk.meshes.delete(substance);
-        if (chunk.meshes.size == 0) {
-            column.chunks.delete(index);
-        }
-        return chunkMesh;
-    }
-    static getMesh(location, substance) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-        if (!chunk)
-            return false;
-        const chunkMesh = chunk.meshes.get(substance);
-        if (!chunkMesh)
-            return false;
-        return chunkMesh;
-    }
-    static remove(location) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        const chunk = column.chunks.get(index);
-        if (!chunk)
-            return false;
-        column.chunks.delete(index);
-        return chunk;
-    }
-    static get(location) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-        if (!chunk)
-            return false;
-        return chunk;
-    }
-}
-class Column {
-    static add(location) {
-        let region = MeshRegister.region.get(location);
-        if (!region) {
-            region = MeshRegister.region.add(location);
-        }
-        const column = new MeshRegisterColumn([
-            location[0],
-            ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
-        ]);
-        region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
-        return column;
-    }
-    static remove(location) {
-        const region = MeshRegister.region.get(location);
-        if (!region)
-            return false;
-        const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
-        const column = region.columns.get(index);
-        if (!column)
-            return false;
-        region.columns.delete(index);
-        if (region.columns.size == 0) {
-            MeshRegister.region.remove(location);
-        }
-        return column;
-    }
-    static get(location) {
-        const region = MeshRegister.region.get(location);
-        if (!region)
-            return false;
-        return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
-    }
-}
-class Region {
-    static add(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension) {
-            dimension = MeshRegister.dimensions.add(location[0]);
-        }
-        const region = new MushRegisterRegion();
-        dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
-        return region;
-    }
-    static remove(location) {
-        const region = this.get(location);
-        if (!region)
-            return false;
-        const dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension)
-            return false;
-        dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-        region.columns.forEach((column) => {
-            column.chunks.forEach((chunk) => {
-                chunk.meshes.forEach((chunkMeshes) => {
-                    chunkMeshes.dispose();
-                });
-            });
-        });
-        return true;
-    }
-    static get(location) {
-        const dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension)
-            return false;
-        const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-        if (!region)
-            return false;
-        return region;
-    }
-}
-class Dimensions {
-    static add(id) {
-        const dimension = new Map();
-        MeshRegister._dimensions.set(id, dimension);
-        return dimension;
-    }
-    static get(id) {
-        return MeshRegister._dimensions.get(id);
-    }
-    static *getAllMeshes(id) {
-        const dimension = MeshRegister._dimensions.get(id);
-        if (!dimension)
-            return;
-        for (const [key, region] of dimension) {
-            for (const [columnKey, column] of region.columns) {
-                for (const [chunkKey, chunk] of column.chunks) {
-                    for (const [substance, mesh] of chunk.meshes) {
-                        yield [
-                            [
-                                column.location[0],
-                                column.location[1],
-                                column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
-                                column.location[3],
-                            ],
-                            substance,
-                            mesh,
-                        ];
-                    }
-                }
-            }
-        }
-    }
-    static remove(id) {
-        const dimension = MeshRegister._dimensions.get(id);
-        if (!dimension)
-            return false;
-        dimension.forEach((region) => {
-            region.columns.forEach((column) => {
-                column.chunks.forEach((chunk) => {
-                    chunk.meshes.forEach((chunkMeshes) => {
-                        chunkMeshes.dispose();
-                    });
-                });
-            });
-        });
-        MeshRegister._dimensions.delete(id);
-        return true;
-    }
-}
-export class MeshRegister {
-    // Main dimensions data store
-    static _dimensions = new Map([["main", new Map()]]);
-    static dimensions = Dimensions;
-    static region = Region;
-    static column = Column;
-    static chunk = Chunk;
-    static clearAll() {
-        for (const [dkey, dim] of this._dimensions) {
-            this.dimensions.remove(dkey);
-        }
-        this._dimensions.clear();
-        this._dimensions.set("main", new Map());
-    }
-}

package/Contexts/Render/Tasks/RenderTasks.d.ts

@@ -1,7 +0,0 @@
-export declare const RenderTasks: {
-    setChunk: void;
-    removeChunk: void;
-    removeColumn: void;
-    clearAll: void;
-    removeColumnsOutsideRadius: void;
-};

package/Contexts/Render/Tasks/RenderTasks.js

@@ -1,20 +0,0 @@
-import { Threads } from "@amodx/threads/";
-import { MeshManager } from "../../../Renderer/MeshManager.js";
-import { MeshRegister } from "../../../Renderer/MeshRegister.js";
-export const RenderTasks = {
-    setChunk: Threads.registerTasks("set-chunk", (data) => {
-        MeshManager.update(data);
-    }),
-    removeChunk: Threads.registerTasks("remove-chunk", (data) => {
-        MeshManager.remove(data);
-    }),
-    removeColumn: Threads.registerTasks("remove-column", (data) => {
-        MeshManager.removeColumn(data);
-    }),
-    clearAll: Threads.registerTasks("clear-all", (data) => {
-        MeshRegister.clearAll();
-    }),
-    removeColumnsOutsideRadius: Threads.registerTasks("remove-column-outside-radius", (data) => {
-        MeshManager.removeColumnsOutsideRadius(data[0], data[1]);
-    }),
-};

package/Contexts/Render/Tasks/RenderTasks.types.d.ts

@@ -1,21 +0,0 @@
-import { CompactMeshData } from "../../../Mesher/Types/Mesher.types";
-import type { LocationData } from "../../../Math/index.js";
-export type SetChunkMeshTask = [
-    location: LocationData,
-    meshes: CompactMeshData,
-    effects: ChunkEffectData[],
-    priority: number
-];
-export type ChunkEffectData = [id: string, data: any];
-export type ChunkMeshData = [
-    substanceType: string,
-    meshData: [location: LocationData, mesh: CompactMeshData]
-];
-export type RemoveChunkMeshTasks = [
-    location: LocationData,
-    substanceType: string
-];
-export type RemoveChunksOutsideDistance = [
-    location: LocationData,
-    distance: number
-];

package/Contexts/World/Data/DataSync.d.ts

@@ -1,29 +0,0 @@
-import type { Thread, ThreadPool } from "@amodx/threads/";
-import { CommSyncOptions } from "./DataSyncNode.js";
-import { DataSyncNode } from "./DataSyncNode.js";
-import { Pipeline } from "@amodx/core/Pipelines/";
-import type { LocationData } from "../../../Math/index.js";
-import type { DimensionData } from "../../../Data/Types/DimensionData.types.js";
-import { Chunk, Column, Region } from "../../../Data/World/Classes/index.js";
-import { DivineVoxelEngineWorld } from "../index.js";
-import { WorldDataSync } from "../../Base/Remote/Sync/DataSync.types.js";
-export declare class DataSync {
-    commMap: Map<string, Thread | ThreadPool>;
-    comms: (Thread | ThreadPool)[];
-    commOptions: WeakMap<any, CommSyncOptions>;
-    _ready: boolean;
-    pipelines: {
-        init: Pipeline<DataSync>;
-    };
-    init(world: DivineVoxelEngineWorld): Promise<void>;
-    isReady(): boolean;
-    registerComm(comm: Thread | ThreadPool, data?: Partial<CommSyncOptions>): void;
-    loopThroughComms(func: (comm: Thread | ThreadPool, options: CommSyncOptions) => void): void;
-    worldData: {
-        dimesnion: DataSyncNode<string | number, DimensionData, string | number, boolean>;
-        chunk: DataSyncNode<LocationData, [LocationData, Chunk], LocationData, LocationData>;
-        column: DataSyncNode<LocationData, [LocationData, Column], LocationData, LocationData>;
-        region: DataSyncNode<LocationData, [LocationData, Region], LocationData, LocationData>;
-        regionHeader: DataSyncNode<LocationData, WorldDataSync, LocationData, boolean>;
-    };
-}

package/Contexts/World/Data/DataSync.js

@@ -1,110 +0,0 @@
-import { DataSyncNode } from "./DataSyncNode.js";
-import { Pipeline } from "@amodx/core/Pipelines/";
-//objects
-import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { RegionHeaderRegister } from "../../../Data/World/RegionHeaderRegister.js";
-import { DimensionsRegister } from "../../../Data/World/DimensionsRegister.js";
-import { DVEFDataSyncIds } from "../../../Data/Constants/DVEFDataSyncIds.js";
-export class DataSync {
-    commMap = new Map();
-    comms = [];
-    commOptions = new WeakMap();
-    _ready = false;
-    pipelines = {
-        init: new Pipeline(),
-    };
-    async init(world) {
-        for (const comm of world.threads.comms) {
-            if (!comm.isReady())
-                continue;
-            this.registerComm(comm);
-        }
-        this.loopThroughComms((comm) => {
-            this.commMap.set(comm.name, comm);
-        });
-        await this.pipelines.init.pipeAsync(this);
-        this._ready = true;
-    }
-    isReady() {
-        return this._ready;
-    }
-    registerComm(comm, data = {}) {
-        this.comms.push(comm);
-        this.commOptions.set(comm, {
-            worldData: data.worldData !== undefined ? data.worldData : true,
-            voxelPalette: data.voxelPalette !== undefined ? data.voxelPalette : true,
-            voxelTags: data.voxelTags !== undefined ? data.voxelTags : true,
-            materials: data.materials !== undefined ? data.materials : true,
-            colliders: data.colliders !== undefined ? data.colliders : true,
-            worldDataTags: data.worldDataTags !== undefined ? data.worldDataTags : true,
-        });
-    }
-    loopThroughComms(func) {
-        for (const comm of this.comms) {
-            const options = this.commOptions.get(comm);
-            if (!comm.isReady())
-                continue;
-            func(comm, options);
-        }
-    }
-    worldData = {
-        dimesnion: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.Dimesnion,
-            commCheck: (options) => options.worldData,
-            getSyncData: (input) => {
-                const dimensionData = DimensionsRegister.instance.getDimension(input);
-                if (!dimensionData)
-                    return false;
-                return dimensionData;
-            },
-            getUnSyncData: () => true,
-        }, this),
-        chunk: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.Chunk,
-            commCheck: (options) => options.worldData,
-            getSyncData: (input) => {
-                WorldRegister.instance.setDimension(input[0]);
-                const chunk = WorldRegister.instance.chunk.get(input[1], input[2], input[3]);
-                if (!chunk)
-                    return false;
-                return [input, chunk];
-            },
-            getUnSyncData: (input) => input,
-        }, this),
-        column: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.Column,
-            commCheck: (options) => options.worldData,
-            getSyncData: (input) => {
-                WorldRegister.instance.setDimension(input[0]);
-                const column = WorldRegister.instance.column.get(input[1], input[2], input[3]);
-                if (!column)
-                    return false;
-                return [input, column];
-            },
-            getUnSyncData: (input) => input,
-        }, this),
-        region: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.Region,
-            commCheck: (options) => options.worldData,
-            getSyncData: (input) => {
-                WorldRegister.instance.setDimension(input[0]);
-                const region = WorldRegister.instance.region.get(input[1], input[2], input[3]);
-                if (!region)
-                    return false;
-                return [input, region];
-            },
-            getUnSyncData: (input) => input,
-        }, this),
-        regionHeader: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.RegionHeader,
-            commCheck: (options) => options.worldData,
-            getSyncData: (input) => {
-                const regionHeader = RegionHeaderRegister.get(input);
-                if (!regionHeader)
-                    return false;
-                return [input, regionHeader.buffer];
-            },
-            getUnSyncData: () => true,
-        }, this),
-    };
-}

package/Contexts/World/Data/DataSyncNode.d.ts

@@ -1,28 +0,0 @@
-import { DataSync } from "./DataSync";
-export type CommSyncOptions = {
-    worldData: boolean;
-    worldDataTags: boolean;
-    voxelPalette: boolean;
-    voxelTags: boolean;
-    materials: boolean;
-    colliders: boolean;
-};
-export declare class DataSyncNode<SyncInput, SyncOutput, UnSyncInput, UnSyncOutput> {
-    data: {
-        dataSyncType: number | string;
-        commCheck: (options: CommSyncOptions, threadId?: string) => boolean;
-        getSyncData: (data: SyncInput, threadId?: string) => SyncOutput | false;
-        getUnSyncData: (data: UnSyncInput, threadId?: string) => UnSyncOutput | false;
-    };
-    dataSync: DataSync;
-    constructor(data: {
-        dataSyncType: number | string;
-        commCheck: (options: CommSyncOptions, threadId?: string) => boolean;
-        getSyncData: (data: SyncInput, threadId?: string) => SyncOutput | false;
-        getUnSyncData: (data: UnSyncInput, threadId?: string) => UnSyncOutput | false;
-    }, dataSync: DataSync);
-    unSync(input: UnSyncInput): false | undefined;
-    unSyncInThread(commName: string, input: UnSyncInput): false | undefined;
-    sync(input: SyncInput): false | undefined;
-    syncInThread(commName: string, input: SyncInput): false | undefined;
-}

package/Contexts/World/Data/DataSyncNode.js

@@ -1,54 +0,0 @@
-export class DataSyncNode {
-    data;
-    dataSync;
-    constructor(data, dataSync) {
-        this.data = data;
-        this.dataSync = dataSync;
-    }
-    unSync(input) {
-        const output = this.data.getUnSyncData(input);
-        if (!output)
-            return false;
-        this.dataSync.loopThroughComms((comm, options) => {
-            if (options && !this.data.commCheck(options))
-                return false;
-            comm.unSyncData(this.data.dataSyncType, output);
-        });
-    }
-    unSyncInThread(commName, input) {
-        const comm = this.dataSync.commMap.get(commName);
-        if (!comm) {
-            console.warn("Could not find thread when trying to sync data", commName);
-            return;
-        }
-        const output = this.data.getUnSyncData(input);
-        if (!output)
-            return false;
-        if (!this.data.commCheck(this.dataSync.commOptions.get(comm)))
-            return false;
-        comm.unSyncData(this.data.dataSyncType, output);
-    }
-    sync(input) {
-        const output = this.data.getSyncData(input);
-        if (!output)
-            return false;
-        this.dataSync.loopThroughComms((comm, options) => {
-            if (!this.data.commCheck(options))
-                return false;
-            comm.syncData(this.data.dataSyncType, output);
-        });
-    }
-    syncInThread(commName, input) {
-        const comm = this.dataSync.commMap.get(commName);
-        if (!comm) {
-            console.warn("Could not find thread when trying to sync data", commName);
-            return;
-        }
-        const output = this.data.getSyncData(input);
-        if (!output)
-            return false;
-        if (!this.data.commCheck(this.dataSync.commOptions.get(comm)))
-            return false;
-        comm.syncData(this.data.dataSyncType, output);
-    }
-}

package/Contexts/World/Lock/WorldLock.d.ts

@@ -1,12 +0,0 @@
-import type { WorldLockTasks } from "../../../Tasks/Tasks.types";
-import type { LocationData } from "../../../Math";
-import { DataLoaderTool } from "../../../Tasks/DataLoader/World/Tools/DataLoaderTool.js";
-export declare const WorldLock: {
-    locks: Map<string, WorldLockTasks>;
-    dataLoader: DataLoaderTool;
-    init(dataLoaderTool: DataLoaderTool): void;
-    _loadMap: Map<string, boolean>;
-    addLock(taskData: WorldLockTasks): Promise<unknown>;
-    removeLock(data: WorldLockTasks): void;
-    isLocked([sdim, x, y, z]: LocationData): boolean;
-};

package/Contexts/World/Tasks/WorldTasks.d.ts

@@ -1,11 +0,0 @@
-import type { LocationData } from "../../../Math/index.js";
-import { ColumnData } from "../../../Data/World/Classes/Column.js";
-import { DivineVoxelEngineWorld } from "../index.js";
-export declare class WorldTasks {
-    DVEW: DivineVoxelEngineWorld;
-    constructor(DVEW: DivineVoxelEngineWorld);
-    loadColumn(location: LocationData, column: ColumnData): void;
-    unLoadColumn(location: LocationData): boolean;
-    loadRegionHeader(location: LocationData, data: SharedArrayBuffer): void;
-}
-export default function (DVEW: DivineVoxelEngineWorld): void;