@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tasks/DataLoader/Broswer/WorldDataBase.d.ts

@@ -1,26 +0,0 @@
-import type { DataBase, ObjectStore } from "@amodx/indexdb/";
-import type { DVEDDataTypes } from "../Types/DVED.types";
-import { WorldDataTool } from "./WorldDataTool";
-export declare class WorldDataBase {
-    database: DataBase;
-    dimension: string;
-    typeStores: Record<DVEDDataTypes, ObjectStore<any>>;
-    worldDataTool: WorldDataTool;
-    constructor(database: DataBase);
-    setDimension(dimensionId: string): Promise<void>;
-    regionHeader: {
-        set: (key: string, type: DVEDDataTypes, data: ArrayBuffer) => Promise<void>;
-        get: (key: string, type: DVEDDataTypes) => Promise<ArrayBuffer | false>;
-        getKey(key: string, type: DVEDDataTypes): string;
-    };
-    column: {
-        set: (key: string, type: DVEDDataTypes, data: ArrayBuffer) => Promise<void>;
-        get: (key: string, type: DVEDDataTypes) => Promise<false | ArrayBuffer>;
-        getKey(key: string, type: DVEDDataTypes): string;
-    };
-    columnTimestamp: {
-        set: (key: string, type: DVEDDataTypes, timeStamp: number) => Promise<void>;
-        get: (key: string, type: DVEDDataTypes) => Promise<number | false>;
-        getKey: (key: string, type: DVEDDataTypes) => string;
-    };
-}

package/Tasks/DataLoader/Broswer/WorldDataBase.js

@@ -1,81 +0,0 @@
-import { WorldDataTool } from "./WorldDataTool";
-export class WorldDataBase {
-    database;
-    dimension = "";
-    typeStores;
-    worldDataTool;
-    constructor(database) {
-        this.database = database;
-        this.worldDataTool = new WorldDataTool(this);
-    }
-    async setDimension(dimensionId) {
-        if (this.dimension != dimensionId) {
-            const worldDataId = `${dimensionId}-world-data`;
-            const richDataId = `${dimensionId}-rich-data`;
-            const entitiesId = `${dimensionId}-entities`;
-            const dboId = `${dimensionId}-dbo`;
-            this.database.close();
-            await this.database.addObjectStore({
-                name: worldDataId,
-                schema: [],
-            }, {
-                name: richDataId,
-                schema: [],
-            }, {
-                name: entitiesId,
-                schema: [],
-            }, {
-                name: dboId,
-                schema: [],
-            });
-            this.typeStores = {};
-            this.typeStores["world-data"] = await this.database.getObjectStore(worldDataId);
-            this.typeStores["rich-data"] = await this.database.getObjectStore(richDataId);
-            this.typeStores["entities"] = await this.database.getObjectStore(entitiesId);
-            this.typeStores["dbo"] = await this.database.getObjectStore(dboId);
-        }
-        this.dimension = dimensionId;
-    }
-    regionHeader = {
-        set: async (key, type, data) => {
-            await this.typeStores[type].set(this.regionHeader.getKey(key, type), data);
-        },
-        get: async (key, type) => {
-            const buffer = (await this.typeStores[type].get(this.regionHeader.getKey(key, type)));
-            if (!buffer)
-                return false;
-            return buffer;
-        },
-        getKey(key, type) {
-            return `${key}_${type}_region_header`;
-        },
-    };
-    column = {
-        set: async (key, type, data) => {
-            await this.typeStores[type].set(this.column.getKey(key, type), data);
-        },
-        get: async (key, type) => {
-            const buffer = (await this.typeStores[type].get(this.column.getKey(key, type)));
-            if (!buffer)
-                return false;
-            return await buffer;
-        },
-        getKey(key, type) {
-            return `${key}_${type}_column`;
-        },
-    };
-    columnTimestamp = {
-        set: async (key, type, timeStamp) => {
-            await this.typeStores[type].set(this.columnTimestamp.getKey(key, type), timeStamp);
-        },
-        get: async (key, type) => {
-            const timeStamp = (await this.typeStores[type].get(this.columnTimestamp.getKey(key, type)));
-            if (!timeStamp)
-                return false;
-            return Number(timeStamp);
-        },
-        getKey: (key, type) => {
-            return `${key}_${type}_column_timestamp`;
-        },
-    };
-}

package/Tasks/DataLoader/Broswer/WorldDataBaseManager.d.ts

@@ -1,6 +0,0 @@
-import { WorldDataBase } from "./WorldDataBase";
-export declare class WorldDataBaseManager {
-    static init(): Promise<void>;
-    static getWorldDataBase(dbName: string, dimension?: string): Promise<WorldDataBase>;
-    static deleteWorldDataBase(dbName: string): Promise<void>;
-}

package/Tasks/DataLoader/Broswer/WorldDataBaseManager.js

@@ -1,30 +0,0 @@
-import { IndexDB } from "@amodx/indexdb/";
-import { WorldDataBase } from "./WorldDataBase";
-export class WorldDataBaseManager {
-    static async init() {
-        await IndexDB.init();
-    }
-    static async getWorldDataBase(dbName, dimension = "main") {
-        let db;
-        const existanceCheck = await IndexDB.databaseExists(dbName);
-        if (!existanceCheck) {
-            db = await IndexDB.createDatabase({
-                databaseName: dbName,
-                objectStores: [
-                    {
-                        name: "world-meta",
-                        schema: [],
-                    },
-                ],
-            });
-            return new WorldDataBase(db);
-        }
-        else {
-            db = await IndexDB.getDatabase(dbName);
-            return new WorldDataBase(db);
-        }
-    }
-    static async deleteWorldDataBase(dbName) {
-        await IndexDB.deleteDatabase(dbName);
-    }
-}

package/Tasks/DataLoader/Broswer/WorldDataTool.d.ts

@@ -1,16 +0,0 @@
-import { WorldDataBase } from "./WorldDataBase";
-import { LocationData } from "../../../Math";
-import { DataLoaderSegments } from "Tasks/DataLoader/Types/DVEDataHandler";
-export declare class WorldDataTool {
-    worldDataBase: WorldDataBase;
-    setPath(id: string): Promise<boolean>;
-    constructor(worldDataBase: WorldDataBase);
-    dataType: DataLoaderSegments;
-    setType(data: DataLoaderSegments): void;
-    columnExists(location: LocationData): Promise<boolean>;
-    columnExistsBatch(locations: LocationData[]): Promise<Record<string, boolean>>;
-    columnTimestamp(location: LocationData): Promise<number>;
-    loadRegionHeader(location: LocationData): Promise<ArrayBuffer>;
-    loadColumn(location: LocationData): Promise<ArrayBufferLike>;
-    saveColumn(location: LocationData, buffer: ArrayBuffer): Promise<boolean>;
-}

package/Tasks/DataLoader/Broswer/WorldDataTool.js

@@ -1,64 +0,0 @@
-import { WorldSpaces } from "../../../Data/World/WorldSpaces";
-import { Compressor } from "@amodx/core/Compression/Compression";
-export class WorldDataTool {
-    worldDataBase;
-    async setPath(id) {
-        return true;
-    }
-    constructor(worldDataBase) {
-        this.worldDataBase = worldDataBase;
-    }
-    dataType = "world-data";
-    setType(data) {
-        this.dataType = data;
-    }
-    async columnExists(location) {
-        await this.worldDataBase.setDimension(location[0]);
-        return (await this.columnTimestamp(location)) > 0;
-    }
-    async columnExistsBatch(locations) {
-        await this.worldDataBase.setDimension(locations[0][0]);
-        const existsRecord = {};
-        const transication = await this.worldDataBase.database.getTransaction("readonly", this.worldDataBase.typeStores["world-data"].id);
-        const proms = [];
-        const keys = [];
-        for (const location of locations) {
-            const key = location.toString();
-            keys.push(key);
-            proms.push(transication.get(this.worldDataBase.columnTimestamp.getKey(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType)));
-        }
-        const resolved = await Promise.all(proms);
-        for (let i = 0; i < keys.length; i++) {
-            existsRecord[keys[i]] = resolved[i] !== undefined;
-        }
-        return existsRecord;
-    }
-    async columnTimestamp(location) {
-        await this.worldDataBase.setDimension(location[0]);
-        const stamp = await this.worldDataBase.columnTimestamp.get(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType);
-        if (!stamp)
-            return 0;
-        return stamp;
-    }
-    async loadRegionHeader(location) {
-        await this.worldDataBase.setDimension(location[0]);
-        const buffer = await this.worldDataBase.regionHeader.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), this.dataType);
-        if (!buffer)
-            return new ArrayBuffer(0);
-        return buffer;
-    }
-    async loadColumn(location) {
-        await this.worldDataBase.setDimension(location[0]);
-        const buffer = await this.worldDataBase.column.get(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType);
-        if (!buffer)
-            return new ArrayBuffer(0);
-        return await (await Compressor.decompressArray(buffer, "Uint8")).buffer;
-    }
-    async saveColumn(location, buffer) {
-        const compressed = await Compressor.compressArray(new Uint8Array(buffer));
-        await this.worldDataBase.setDimension(location[0]);
-        await this.worldDataBase.column.set(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType, compressed.buffer);
-        await this.worldDataBase.columnTimestamp.set(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType, Date.now());
-        return true;
-    }
-}

package/Tasks/DataLoader/Broswer/index.d.ts

@@ -1 +0,0 @@
-export * from "./DataHandler";

package/Tasks/DataLoader/Broswer/index.js

@@ -1 +0,0 @@
-export * from "./DataHandler";

package/Tasks/DataLoader/Constructor/DataLoaderTasks.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineDataLoaderConstructor } from "./DivineVoxelEngineDataLoaderConstructor.js";
-export default function (DVEDL: DivineVoxelEngineDataLoaderConstructor): void;

package/Tasks/DataLoader/Constructor/DataLoaderTasks.js

@@ -1,14 +0,0 @@
-;
-import { Threads } from "@amodx/threads/";
-export default function (DVEDL) {
-    Threads.registerTasks("serialize-column", async (location, onDone) => {
-        const seralized = DVEDL.serializer.serializeColumn(location);
-        if (!seralized)
-            return onDone ? onDone(false) : false;
-        return onDone ? onDone(seralized, [seralized]) : seralized;
-    }, "deferred");
-    Threads.registerTasks("deserialize-column", async (columnData, onDone) => {
-        const deSeralized = DVEDL.serializer.deSerializeColumn(columnData);
-        return onDone ? onDone(deSeralized) : deSeralized;
-    }, "deferred");
-}

package/Tasks/DataLoader/Constructor/DivineVoxelEngineDataLoaderConstructor.d.ts

@@ -1,9 +0,0 @@
-import { WorldDataSerializer } from "./WorldDataSerializer.js";
-export type DivineVoxelEngineDataLoaderConstructorInitData = {};
-export declare class DivineVoxelEngineDataLoaderConstructor {
-    static instance: DivineVoxelEngineDataLoaderConstructor;
-    environment: "node" | "browser";
-    serializer: WorldDataSerializer;
-    constructor(data: DivineVoxelEngineDataLoaderConstructorInitData);
-    init(): Promise<void>;
-}

package/Tasks/DataLoader/Constructor/DivineVoxelEngineDataLoaderConstructor.js

@@ -1,17 +0,0 @@
-//functions
-import DataLoaderTasks from "./DataLoaderTasks.js";
-import { WorldDataSerializer } from "./WorldDataSerializer.js";
-export class DivineVoxelEngineDataLoaderConstructor {
-    static instance;
-    environment = "browser";
-    serializer;
-    constructor(data) {
-        if (DivineVoxelEngineDataLoaderConstructor.instance)
-            return DivineVoxelEngineDataLoaderConstructor.instance;
-        DivineVoxelEngineDataLoaderConstructor.instance = this;
-        this.serializer = new WorldDataSerializer();
-    }
-    async init() {
-        DataLoaderTasks(this);
-    }
-}

package/Tasks/DataLoader/Constructor/WorldDataSerializer.d.ts

@@ -1,15 +0,0 @@
-import type { ColumnData } from "../../../Data/World/Classes/Column.js";
-import type { LocationData } from "../../../Math";
-import { RegionDataTool } from "../../../Tools/Data/WorldData/RegionDataTool.js";
-import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
-import { ChunkDataTool } from "../../../Tools/Data/WorldData/ChunkDataTool.js";
-export declare class WorldDataSerializer {
-    regions: RegionDataTool;
-    columns: ColumnDataTool;
-    chunks: ChunkDataTool;
-    serializeRegion(location: LocationData): false | [location: LocationData, buffer: ArrayBuffer][];
-    serializeColumn(location: LocationData): false | ArrayBuffer;
-    deSerializeRegion(regionBuffers: ArrayBuffer[] | SharedArrayBuffer[]): void;
-    deSerializeColumn(columnBuffer: ArrayBuffer | SharedArrayBuffer): ColumnData;
-    _readDataIntoBuffer(offset: number, target: Uint8Array, source: ArrayBuffer | SharedArrayBuffer, sourceOffset?: number, sourceLength?: number): number;
-}

package/Tasks/DataLoader/Constructor/WorldDataSerializer.js

@@ -1,54 +0,0 @@
-//objects
-import { RegionDataTool } from "../../../Tools/Data/WorldData/RegionDataTool.js";
-import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
-import { ChunkDataTool } from "../../../Tools/Data/WorldData/ChunkDataTool.js";
-import { BinaryObject } from "@amodx/binary";
-export class WorldDataSerializer {
-    regions = new RegionDataTool();
-    columns = new ColumnDataTool();
-    chunks = new ChunkDataTool();
-    serializeRegion(location) {
-        if (!this.regions
-            .setDimension(location[0])
-            .loadInAt(location[1], location[2], location[3]))
-            return false;
-        const region = this.regions.getRegion();
-        const columnBuffers = [];
-        region.columns.forEach((column, index) => {
-            this.columns.setColumn(column);
-            const position = region.getColumnPosition(index);
-            const columnLocation = [location[0], ...position];
-            const columnBuffer = this.serializeColumn(columnLocation);
-            if (columnBuffer)
-                columnBuffers.push([[...columnLocation], columnBuffer]);
-        });
-        return columnBuffers;
-    }
-    serializeColumn(location) {
-        if (!this.columns.setLocation(location).loadIn())
-            return false;
-        const column = this.columns.getColumn();
-        const columnData = column.toJSON();
-        const columnArray = BinaryObject.objectToBuffer(columnData);
-        return columnArray;
-    }
-    deSerializeRegion(regionBuffers) {
-        for (const buffer of regionBuffers) {
-            this.deSerializeColumn(buffer);
-        }
-    }
-    deSerializeColumn(columnBuffer) {
-        BinaryObject.setUseSharedMemory(true);
-        const columnData = BinaryObject.bufferToObject(columnBuffer);
-        BinaryObject.setUseSharedMemory(false);
-        return columnData;
-    }
-    _readDataIntoBuffer(offset, target, source, sourceOffset = 0, sourceLength = -1) {
-        const bufferArray = new Uint8Array(source, sourceOffset, sourceLength == -1 ? source.byteLength : sourceLength);
-        let i = bufferArray.length;
-        while (i--) {
-            target[i + offset] = bufferArray[i];
-        }
-        return bufferArray.length;
-    }
-}

package/Tasks/DataLoader/Constructor/index.d.ts

@@ -1 +0,0 @@
-export * from "./DivineVoxelEngineDataLoaderConstructor.js";

package/Tasks/DataLoader/Constructor/index.js

@@ -1 +0,0 @@
-export * from "./DivineVoxelEngineDataLoaderConstructor.js";

package/Tasks/DataLoader/Node/DivineVoxelEngineData.d.ts

@@ -1,48 +0,0 @@
-import type * as FileSystem from "fs";
-import { NodeRegionTool } from "./Tools/NodeRegionTool.js";
-import { VoxelSpaces } from "../../../Math/Spaces/VoxelSpaces.js";
-import { BinaryStruct } from "@amodx/binary/";
-type Vector3 = {
-    x: number;
-    y: number;
-    z: number;
-};
-export declare const DVED: {
-    spaces: VoxelSpaces;
-    regionTags: BinaryStruct;
-    system: {
-        fs: typeof FileSystem;
-        $INIT(fs: typeof FileSystem): void;
-        updateFolder(folder: string): void;
-        mkdirs(paths: string[]): void;
-        sync: {
-            createFile(path: string, size?: number, mode?: number): boolean;
-            createAndOpenFile(path: string, size?: number): false | import("../Types/DVED.types.js").DVEDSyncFile;
-            openFile(filePath: string, showErrors?: boolean): import("../Types/DVED.types.js").DVEDSyncFile | false;
-        };
-    };
-    path: {
-        _dataPath: string;
-        _dataFolder: string;
-        _folder: string;
-        _tempPath: string;
-        setFolder(folder: string): void;
-        getDataPath(): string;
-        getDataDirectory(fileName?: string): string;
-        getDirecoty(fileName?: string): string;
-        getTempPath(fileName?: string): string;
-        $INIT(): void;
-    };
-    $INIT(data: {
-        fs: typeof FileSystem;
-        dataDirecotry: string;
-        sectorSize: number;
-        spaceBounds: {
-            regions: Vector3;
-            columns: Vector3;
-            chunks: Vector3;
-        };
-    }): void;
-    getRegionTool(): NodeRegionTool;
-};
-export {};

package/Tasks/DataLoader/Node/DivineVoxelEngineData.js

@@ -1,47 +0,0 @@
-import { NodeRegionTool } from "./Tools/NodeRegionTool.js";
-import { RegionData, RegionTagIds, SecotrData } from "./Util/DVED.util.js";
-import { VoxelSpaces } from "../../../Math/Spaces/VoxelSpaces.js";
-import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
-import { System } from "./System/System.js";
-import { SystemPath } from "./System/SystemPath.js";
-const voxelSpaces = new VoxelSpaces();
-const regionTagManager = new BinaryStruct("region-tagsx");
-export const DVED = {
-    spaces: voxelSpaces,
-    regionTags: regionTagManager,
-    system: System,
-    path: SystemPath,
-    $INIT(data) {
-        SystemPath.setFolder(data.dataDirecotry);
-        this.spaces = voxelSpaces;
-        SecotrData.byteSize = data.sectorSize;
-        SystemPath._dataFolder = data.dataDirecotry;
-        System.$INIT(data.fs);
-        this.spaces.setDimensions(data.spaceBounds);
-        const numberColumns = this.spaces.region.getColumnVolume();
-        regionTagManager.registerProperty({
-            id: RegionTagIds.sectorIndex,
-            type: "typed-number-array",
-            numberType: BinaryNumberTypes.Uint16,
-            length: numberColumns,
-        });
-        regionTagManager.registerProperty({
-            id: RegionTagIds.columnLength,
-            type: "typed-number-array",
-            numberType: BinaryNumberTypes.Uint16,
-            length: numberColumns,
-        });
-        regionTagManager.registerProperty({
-            id: RegionTagIds.timeStamp,
-            type: "typed-number-array",
-            numberType: BinaryNumberTypes.Uint32,
-            length: numberColumns,
-        });
-        regionTagManager.init();
-        RegionData.headByteSize = regionTagManager.structSize;
-        RegionData.numColumns = numberColumns;
-    },
-    getRegionTool() {
-        return new NodeRegionTool();
-    },
-};

package/Tasks/DataLoader/Node/System/RegionSystem.d.ts

@@ -1,28 +0,0 @@
-import type { DVEDSyncFile } from "../../Types/DVED.types";
-import type { LocationData } from "../../../../Math/";
-export declare const RegionSystem: {
-    _processInput(buffer: ArrayBuffer | string): ArrayBufferLike;
-    _getTagIndex(id: string, index: number): number;
-    _getIndex(index: number | LocationData): number;
-    timeStamp: {
-        get(file: DVEDSyncFile, index: number): number | false;
-        set(file: DVEDSyncFile, index: number, timeStamp?: number): boolean;
-    };
-    sectorIndex: {
-        get(file: DVEDSyncFile, index: number): number | false;
-        set(file: DVEDSyncFile, index: number, sectorIndex: number): boolean;
-    };
-    columnLength: {
-        get(file: DVEDSyncFile, index: number): number | false;
-        set(file: DVEDSyncFile, index: number, length: number): boolean;
-    };
-    sectors: {
-        get(file: DVEDSyncFile, sectorIndex: number, length: number): false | ArrayBuffer;
-        set(file: DVEDSyncFile, sectorIndex: number, data: ArrayBuffer): boolean;
-    };
-    getHeader(file: DVEDSyncFile): false | ArrayBuffer;
-    _rebuild(file: DVEDSyncFile, swapFile: DVEDSyncFile, newColumnIndex: number, newColumnData: ArrayBuffer): void;
-    _getAllColumns(file: DVEDSyncFile): IterableIterator<[number, ArrayBuffer]>;
-    loadColumn(file: DVEDSyncFile, index: number | LocationData): false | ArrayBuffer;
-    saveColumn(file: DVEDSyncFile, index: number | LocationData, data: ArrayBuffer | string): void;
-};

package/Tasks/DataLoader/Node/System/RegionSystem.js

@@ -1,147 +0,0 @@
-import { RegionData, RegionTagIds, SecotrData } from "../Util/DVED.util.js";
-import { DVED } from "../DivineVoxelEngineData.js";
-import { System } from "./System.js";
-import { SystemPath } from "./SystemPath.js";
-export const RegionSystem = {
-    _processInput(buffer) {
-        if (buffer instanceof ArrayBuffer)
-            return buffer;
-        if (ArrayBuffer.isView(buffer))
-            return buffer.buffer;
-        let newBuf = new ArrayBuffer(buffer.length);
-        const array = new Uint8Array(newBuf);
-        let i = newBuf.byteLength;
-        while (i--) {
-            array[i] = buffer.charCodeAt(i);
-        }
-        return newBuf;
-    },
-    _getTagIndex(id, index) {
-        return DVED.regionTags.getArrayPropertyValue(id, index);
-    },
-    _getIndex(index) {
-        if (Array.isArray(index)) {
-            index = DVED.spaces.column.getIndexXYZ(index[1], index[2], index[3]);
-        }
-        return index;
-    },
-    timeStamp: {
-        get(file, index) {
-            const timeStampData = file.read(RegionSystem._getTagIndex(RegionTagIds.timeStamp, index), 4);
-            if (!timeStampData)
-                return false;
-            return new Uint32Array(timeStampData)[0];
-        },
-        set(file, index, timeStamp = Date.now()) {
-            return file.write(RegionSystem._getTagIndex(RegionTagIds.timeStamp, index), new Uint32Array([timeStamp]).buffer);
-        },
-    },
-    sectorIndex: {
-        get(file, index) {
-            const sectorIndexData = file.read(RegionSystem._getTagIndex(RegionTagIds.sectorIndex, index), 2);
-            if (!sectorIndexData)
-                return false;
-            return new Uint16Array(sectorIndexData)[0] + 1;
-        },
-        set(file, index, sectorIndex) {
-            return file.write(RegionSystem._getTagIndex(RegionTagIds.sectorIndex, index), new Uint16Array([sectorIndex - 1]).buffer);
-        },
-    },
-    columnLength: {
-        get(file, index) {
-            const columnLengthData = file.read(RegionSystem._getTagIndex(RegionTagIds.columnLength, index), 2);
-            if (!columnLengthData)
-                return false;
-            return new Uint16Array(columnLengthData)[0];
-        },
-        set(file, index, length) {
-            return file.write(RegionSystem._getTagIndex(RegionTagIds.columnLength, index), new Uint16Array([length]).buffer);
-        },
-    },
-    sectors: {
-        get(file, sectorIndex, length) {
-            return file.read(SecotrData.getSectorByteIndex(sectorIndex - 1), length);
-        },
-        set(file, sectorIndex, data) {
-            const sectorByteIndex = SecotrData.getSectorByteIndex(sectorIndex - 1);
-            file.clear(sectorByteIndex, SecotrData.getTotalBytesNeeded(data.byteLength));
-            return file.write(sectorByteIndex, data);
-        },
-    },
-    getHeader(file) {
-        return file.read(0, RegionData.headByteSize);
-    },
-    _rebuild(file, swapFile, newColumnIndex, newColumnData) {
-        const columns = this._getAllColumns(file);
-        for (const column of columns) {
-            let [index, data] = column;
-            if (data.byteLength == 0)
-                continue;
-            if (index == newColumnIndex)
-                data = newColumnData;
-            this.saveColumn(swapFile, index, data);
-        }
-    },
-    _getAllColumns(file) {
-        return (function* generator() {
-            for (let i = 0; i < RegionData.numColumns; i++) {
-                let data = RegionSystem.loadColumn(file, i);
-                data = data ? data : new ArrayBuffer(0);
-                yield [i, data];
-            }
-        })();
-    },
-    loadColumn(file, index) {
-        let realIndex;
-        if (Array.isArray(index)) {
-            realIndex = this._getIndex(index);
-        }
-        else {
-            realIndex = index;
-        }
-        const sectorIndex = this.sectorIndex.get(file, realIndex);
-        if (typeof sectorIndex == "boolean")
-            return false;
-        const columnLength = this.columnLength.get(file, realIndex);
-        if (typeof columnLength == "boolean" || columnLength === 0)
-            return false;
-        return this.sectors.get(file, sectorIndex, columnLength);
-    },
-    saveColumn(file, index, data) {
-        index = this._getIndex(index);
-        data = this._processInput(data);
-        let timeStamp = this.timeStamp.get(file, index);
-        let sectorIndex = this.sectorIndex.get(file, index);
-        if (!sectorIndex)
-            throw new Error("error");
-        if (!timeStamp) {
-            const currentFileSize = file.getSize();
-            sectorIndex = SecotrData.getTotalSectorsInFile(currentFileSize) + 1;
-            this.sectorIndex.set(file, index, sectorIndex);
-        }
-        let currentColumnLegnth = this.columnLength.get(file, index);
-        if (currentColumnLegnth) {
-            const currentSectors = SecotrData.getSectorsNeeded(currentColumnLegnth);
-            const newSectors = SecotrData.getSectorsNeeded(data.byteLength);
-            if (currentSectors != newSectors) {
-                const swapFilePath = SystemPath.getDirecoty(file.getPath()) +
-                    "/" +
-                    Date.now() +
-                    "-temp.dved";
-                const oldPath = file.getPath();
-                file.move(swapFilePath);
-                //  file.reOpen();
-                const swapFile = System.sync.createAndOpenFile(oldPath, RegionData.headByteSize);
-                if (swapFile) {
-                    this._rebuild(file, swapFile, index, data);
-                    file.delete();
-                    swapFile.close();
-                    return;
-                }
-            }
-        }
-        this.sectors.set(file, sectorIndex, data);
-        this.columnLength.set(file, index, data.byteLength);
-        this.timeStamp.set(file, index);
-    },
-};

package/Tasks/DataLoader/Node/System/System.d.ts

@@ -1,13 +0,0 @@
-import type * as FileSystem from "fs";
-import type { DVEDSyncFile } from "../../Types/DVED.types";
-export declare const System: {
-    fs: typeof FileSystem;
-    $INIT(fs: typeof FileSystem): void;
-    updateFolder(folder: string): void;
-    mkdirs(paths: string[]): void;
-    sync: {
-        createFile(path: string, size?: number, mode?: number): boolean;
-        createAndOpenFile(path: string, size?: number): false | DVEDSyncFile;
-        openFile(filePath: string, showErrors?: boolean): DVEDSyncFile | false;
-    };
-};