@divinevoxel/vlox 0.0.73 → 0.0.75

package/World/Archive/Functions/Sector/CreateArchivedSection.js

@@ -0,0 +1,147 @@
+import { BinaryBuffer, BinaryBufferFormat, } from "../../../../Util/BinaryBuffer/index";
+import { getLightBuffer, lightSegments } from "../Shared/LightSegments";
+export function CreateArchivedSection(archiveSection, sectorPalettes) {
+    const palettes = {};
+    if (archiveSection.voxels.remapped) {
+        palettes.id = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            buffer: Uint16Array.from(archiveSection.palettes.voxels._palette).buffer,
+        });
+    }
+    if (archiveSection.level.remapped) {
+        palettes.level = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            buffer: Uint8Array.from(archiveSection.palettes.level._palette).buffer,
+        });
+    }
+    for (const segment of lightSegments) {
+        if (archiveSection.light[segment].remapped) {
+            palettes.light ??= {};
+            palettes.light[segment] = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                buffer: Uint8Array.from(archiveSection.palettes.light[segment]._palette)
+                    .buffer,
+            });
+        }
+    }
+    if (archiveSection.secondaryVoxels.remapped) {
+        palettes.secondary = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            buffer: Uint16Array.from(archiveSection.palettes.secondaryVoxels._palette)
+                .buffer,
+        });
+    }
+    const buffers = {};
+    //id
+    if (archiveSection.voxels.allTheSame) {
+        if (archiveSection.voxels.buffer[0] !== 0) {
+            buffers.id = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: archiveSection.original.ids.length,
+                buffer: archiveSection.voxels.buffer[0],
+            });
+        }
+    }
+    else if (archiveSection.voxels.isPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.voxels.remapped
+            ? archiveSection.palettes.voxels.size
+            : sectorPalettes.voxels.size);
+        buffers.id = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.voxels.buffer, BinaryBufferFormat.Uint16, type).buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.id = BinaryBuffer.Create({
+            buffer: archiveSection.voxels.buffer.buffer,
+            format: BinaryBufferFormat.Uint16,
+        });
+    }
+    //level
+    if (archiveSection.level.allTheSame) {
+        if (archiveSection.level.buffer[0] !== 0) {
+            buffers.level = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                byteLength: archiveSection.original.level.length,
+                buffer: archiveSection.voxels.buffer[0],
+            });
+        }
+    }
+    else if (archiveSection.level.isPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.level.remapped
+            ? archiveSection.palettes.level.size
+            : sectorPalettes.level.size);
+        buffers.level = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.level.buffer, BinaryBufferFormat.Uint8, type).buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.level = BinaryBuffer.Create({
+            buffer: archiveSection.original.level.slice().buffer,
+            byteLength: archiveSection.original.level.length,
+            format: BinaryBufferFormat.Uint8,
+        });
+    }
+    for (const semgnet of lightSegments) {
+        if (archiveSection.light[semgnet].allTheSame) {
+            if (archiveSection.light[semgnet].value !== 0) {
+                buffers.light ??= {};
+                buffers.light[semgnet] = BinaryBuffer.Create({
+                    format: BinaryBufferFormat.NibbleArray,
+                    buffer: archiveSection.light[semgnet].value,
+                    byteLength: archiveSection.original.light.length,
+                });
+            }
+        }
+        else if (archiveSection.light[semgnet].isPaletted) {
+            const type = BinaryBuffer.DetermineSubByteArray(archiveSection.light[semgnet].remapped
+                ? archiveSection.palettes.light[semgnet].size
+                : sectorPalettes.light[semgnet].size);
+            buffers.light ??= {};
+            buffers.light[semgnet] = BinaryBuffer.Create({
+                buffer: BinaryBuffer.Convert(archiveSection.light[semgnet].buffer, BinaryBufferFormat.Uint8, type).buffer,
+                format: type,
+            });
+        }
+        else {
+            buffers.light ??= {};
+            buffers.light[semgnet] = BinaryBuffer.Create({
+                buffer: getLightBuffer(semgnet, archiveSection.original.light).buffer,
+                format: BinaryBufferFormat.NibbleArray,
+                byteLength: archiveSection.original.light.length,
+            });
+        }
+    }
+    if (archiveSection.secondaryVoxels.allTheSame) {
+        if (archiveSection.secondaryVoxels.buffer[0] !== 0) {
+            buffers.secondary = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: archiveSection.original.level.length,
+                buffer: archiveSection.secondaryVoxels.buffer[0],
+            });
+        }
+    }
+    else if (archiveSection.secondaryVoxels.isPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.secondaryVoxels.remapped
+            ? archiveSection.palettes.secondaryVoxels.size
+            : sectorPalettes.voxels.size);
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.secondaryVoxels.buffer, BinaryBufferFormat.Uint16, type).buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: archiveSection.secondaryVoxels.buffer.buffer,
+            format: BinaryBufferFormat.Uint16,
+            byteLength: archiveSection.original.secondary.length,
+        });
+    }
+    const flags = archiveSection.original.storeFlags();
+    return {
+        ...(Object.keys(flags).length ? { flags } : {}),
+        ...(Object.keys(palettes).length ? { palettes } : {}),
+        buffers,
+    };
+}

package/World/Archive/Functions/Sector/ImportSector.d.ts

@@ -0,0 +1,7 @@
+import { SectorData } from "../../../index";
+import { ArchivedSectorData } from "../../Types/index";
+type RunData = {
+    version?: number;
+};
+export default function ImportSector(archivedSector: ArchivedSectorData, archiveData: RunData): SectorData;
+export {};

package/World/Archive/Functions/Sector/ImportSector.js

@@ -0,0 +1,32 @@
+import { WorldSpaces } from "../../../WorldSpaces";
+import { Sector } from "../../../index";
+import { ImportedSector } from "../../Classes/ImportedSector";
+import { Vector3Like } from "@amodx/math";
+export default function ImportSector(archivedSector, archiveData) {
+    const sector = new Sector();
+    sector.setBuffer(Sector.CreateNewBuffer());
+    sector.position[0] = archivedSector.position.x;
+    sector.position[1] = archivedSector.position.y;
+    sector.position[2] = archivedSector.position.z;
+    sector.loadFlags(archivedSector.flags);
+    sector.loadTimestamps(archivedSector.timestamps);
+    const importedSector = new ImportedSector(archivedSector);
+    const position = Vector3Like.Create();
+    for (const importedSection of importedSector.sections) {
+        const archivedSection = importedSection.section;
+        const section = sector.sections[importedSection.sectionIndex];
+        archivedSection.flags && section.loadFlags(archivedSection.flags);
+        section.dirtyMap.fill(0xff);
+        for (let i = 0; i < section.ids.length; i++) {
+            section.ids[i] = importedSection.getId(i);
+            section.level[i] = importedSection.getLevel(i);
+            section.light[i] = importedSection.getLight(i);
+            section.secondary[i] = importedSection.getSecondary(i);
+            if (section.ids[i] !== 0 || section.secondary[i] !== 0) {
+                section.setHasVoxel(WorldSpaces.voxel.getPositionFromIndex(i, position).y - 1, true);
+            }
+        }
+    }
+    sector.setBitFlag(Sector.FlagIds.stored, true);
+    return sector;
+}

package/World/Archive/Functions/Sector/RemoveDuplicateSections.d.ts

@@ -0,0 +1,2 @@
+import { ArchivedSectorData } from "../../Types/index";
+export declare function RemoveDuplicateSections(sector: ArchivedSectorData): void;

package/World/Archive/Functions/Sector/RemoveDuplicateSections.js

@@ -0,0 +1,137 @@
+import { BinaryBuffer } from "../../../../Util/BinaryBuffer";
+import { uint16To4CharString } from "../Shared/IntToString";
+import { lightSegments } from "../Shared";
+function compareSection(section1, section2) {
+    if (Object.keys(section1).length != Object.keys(section2).length)
+        return false;
+    if (Object.keys(section1.buffers).length != Object.keys(section2.buffers).length)
+        return false;
+    if (section1.palettes &&
+        section2.palettes &&
+        Object.keys(section1.palettes).length !=
+            Object.keys(section2.palettes).length)
+        return false;
+    if (section1.palettes && !section2.palettes)
+        return false;
+    if (!section1.palettes && section2.palettes)
+        return false;
+    if (section1.palettes) {
+        if (section1.palettes.id && section2.palettes?.id) {
+            if (!BinaryBuffer.Compare(section1.palettes.id, section2.palettes.id))
+                return false;
+        }
+        else if ((!section1.palettes.id && section2.palettes?.id) ||
+            (section1.palettes.id && !section2.palettes?.id))
+            return false;
+        if (section1.palettes.secondary && section2.palettes?.secondary) {
+            if (!BinaryBuffer.Compare(section1.palettes.secondary, section2.palettes.secondary))
+                return false;
+        }
+        else if ((!section1.palettes.secondary && section2.palettes?.secondary) ||
+            (section1.palettes.secondary && !section2.palettes?.secondary))
+            return false;
+        if (section1.palettes.level && section2.palettes?.level) {
+            if (!BinaryBuffer.Compare(section1.palettes.level, section2.palettes.level))
+                return false;
+        }
+        else if ((!section1.palettes.level && section2.palettes?.level) ||
+            (section1.palettes.level && !section2.palettes?.level))
+            return false;
+        if (section1.palettes.light && section2.palettes?.light) {
+            for (const segment of lightSegments) {
+                if (section1.palettes.light?.[segment] &&
+                    section2.palettes.light?.[segment]) {
+                    if (!BinaryBuffer.Compare(section1.palettes.light[segment], section2.palettes.light[segment]))
+                        return false;
+                }
+                else if ((!section1.palettes.light[segment] &&
+                    section2.palettes.light[segment]) ||
+                    (section1.palettes.light[segment] &&
+                        !section2.palettes.light[segment]))
+                    return false;
+            }
+        }
+        else if (!section1.palettes.light && section2.palettes?.light)
+            return false;
+    }
+    if (section1.buffers.id && section2.buffers.id) {
+        if (!BinaryBuffer.Compare(section1.buffers.id, section2.buffers.id))
+            return false;
+    }
+    else if ((!section1.buffers.id && section2.buffers.id) ||
+        (section1.buffers.id && !section2.buffers.id))
+        return false;
+    if (section1.buffers.secondary && section2.buffers.secondary) {
+        if (!BinaryBuffer.Compare(section1.buffers.secondary, section2.buffers.secondary))
+            return false;
+    }
+    else if ((!section1.buffers.secondary && section2.buffers.secondary) ||
+        (section1.buffers.secondary && !section2.buffers.secondary))
+        return false;
+    if (section1.buffers.light && section2.buffers?.light) {
+        for (const segment of lightSegments) {
+            if (section1.buffers.light?.[segment] &&
+                section2.buffers.light?.[segment]) {
+                if (!BinaryBuffer.Compare(section1.buffers.light[segment], section2.buffers.light[segment]))
+                    return false;
+            }
+            else if ((!section1.buffers.light[segment] && section2.buffers.light[segment]) ||
+                (section1.buffers.light[segment] && !section2.buffers.light[segment]))
+                return false;
+        }
+    }
+    else if ((!section1.buffers.light && section2.buffers?.light) ||
+        (section1.buffers.light && !section2.buffers?.light))
+        return false;
+    if (section1.buffers.level && section2.buffers?.level) {
+        if (!BinaryBuffer.Compare(section1.buffers.level, section2.buffers.level))
+            return false;
+    }
+    else if ((!section1.buffers.level && section2.buffers?.level) ||
+        (section1.buffers.level && !section2.buffers?.level))
+        return false;
+    return true;
+}
+export function RemoveDuplicateSections(sector) {
+    const sectionsLength = sector.sections.length;
+    const sections = (sector.sections);
+    const newSections = [];
+    const added = new Set();
+    const duplicates = new Map();
+    for (let i = 0; i < sectionsLength; i++) {
+        const sectionA = sections[i];
+        newSections[i] = sectionA;
+        if (added.has(i))
+            continue;
+        for (let j = 0; j < sectionsLength; j++) {
+            if (i == j)
+                continue;
+            if (added.has(j))
+                continue;
+            const sectionB = sections[j];
+            if (compareSection(sectionA, sectionB)) {
+                let array = duplicates.get(sectionA);
+                if (!array) {
+                    array = [i];
+                    added.add(i);
+                    duplicates.set(sectionA, array);
+                }
+                added.add(j);
+                array.push(j);
+            }
+        }
+    }
+    const duplicateSections = {};
+    let dupIndex = 0;
+    for (const [section, indexes] of duplicates) {
+        const key = uint16To4CharString(dupIndex);
+        duplicateSections[key] = section;
+        for (const index of indexes) {
+            newSections[index] = key;
+        }
+        dupIndex++;
+    }
+    sector.sections = newSections;
+    sector.duplicates ??= {};
+    sector.duplicates.sections = duplicateSections;
+}

package/World/Archive/Functions/Shared/BaseData.d.ts

@@ -0,0 +1,2 @@
+import { BaseArchivedDataBase } from "../../Types/Archive.types";
+export declare function getBaseData(dimension: string): BaseArchivedDataBase;

package/World/Archive/Functions/Shared/BaseData.js

@@ -0,0 +1,14 @@
+import { WorldSpaces } from "../../../WorldSpaces";
+import { EngineSettings } from "../../../../Settings/EngineSettings";
+import { VoxelArchivePalette } from "../../../../Voxels/Archive/VoxelPaletteArechive";
+export function getBaseData(dimension) {
+    return {
+        dimension,
+        formatVersion: "",
+        engineVersion: EngineSettings.version,
+        dataKey: {
+            voxelPalette: VoxelArchivePalette.GetVoxelPaletteDataKey(),
+            ...WorldSpaces.getDataKey(),
+        },
+    };
+}

package/World/Archive/Functions/Shared/IntToString.d.ts

@@ -0,0 +1 @@
+export declare function uint16To4CharString(value: number): string;

package/World/Archive/Functions/Shared/IntToString.js

@@ -0,0 +1,13 @@
+const charset = "0123456789ABCDEF";
+export function uint16To4CharString(value) {
+    if (value < 0 || value > 0xffff) {
+        throw new RangeError("Value must be a 16-bit unsigned integer.");
+    }
+    const chars = [];
+    for (let i = 0; i < 4; i++) {
+        const charCode = (value >> (i * 4)) & 0x0f;
+        chars.unshift(charset[charCode]);
+    }
+    const result = chars.join("").replace(/^0+(?!$)/, "");
+    return result;
+}

package/World/Archive/Functions/{Shared.d.ts → Shared/LightSegments.d.ts}

@@ -1,6 +1,5 @@
-import { ArchivedLightSegments, ArchivedSectionData } from "../Archive.types";
+import { ArchivedLightSegments } from "../../Types/Archive.types";
 export declare const lightSegments: ArchivedLightSegments[];
 export declare const lightSemgnetGet: Record<ArchivedLightSegments, (value: number) => number>;
 export declare const lightSemgnetSet: Record<ArchivedLightSegments, (value: number, source: number) => number>;
-export declare function uint16To4CharString(value: number): string;
-export declare function compareSection(section1: ArchivedSectionData, section2: ArchivedSectionData): boolean;
+export declare function getLightBuffer(light: ArchivedLightSegments, buffer: Uint16Array): Uint8Array;

package/World/Archive/Functions/Shared/LightSegments.js

@@ -0,0 +1,37 @@
+import { setNibbleArrayIndex } from "../../../../Util/Binary/BinaryArrays";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
+const lightData = new VoxelLightData();
+export const lightSegments = [
+    "sun",
+    "red",
+    "green",
+    "blue",
+];
+export const lightSemgnetGet = {
+    sun: (value) => lightData.getS(value),
+    red: (value) => lightData.getR(value),
+    green: (value) => lightData.getG(value),
+    blue: (value) => lightData.getB(value),
+};
+export const lightSemgnetSet = {
+    sun: (value, source) => lightData.setS(value, source),
+    red: (value, source) => lightData.setR(value, source),
+    green: (value, source) => lightData.setG(value, source),
+    blue: (value, source) => lightData.setB(value, source),
+};
+export function getLightBuffer(light, buffer) {
+    const array = new Uint8Array(buffer.length / 2);
+    for (let i = 0; i < buffer.length; i++) {
+        let l = 0;
+        if (light == "sun")
+            l = lightData.getS(buffer[i]);
+        if (light == "red")
+            l = lightData.getR(buffer[i]);
+        if (light == "green")
+            l = lightData.getG(buffer[i]);
+        if (light == "blue")
+            l = lightData.getB(buffer[i]);
+        setNibbleArrayIndex(array, i, l);
+    }
+    return array;
+}

package/World/Archive/Functions/Shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./BaseData";
+export * from "./IntToString";
+export * from "./LightSegments";

package/World/Archive/Functions/Shared/index.js

@@ -0,0 +1,3 @@
+export * from "./BaseData";
+export * from "./IntToString";
+export * from "./LightSegments";

package/World/Archive/Functions/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./ArchiveArea";
-export * from "./ArchiveSector";
-export * from "./ImportSector";
+export * from "./Area/ArchiveArea";
+export * from "./Sector/ArchiveSector";
+export * from "./Sector/ImportSector";

package/World/Archive/Functions/index.js

@@ -1,3 +1,3 @@
-export * from "./ArchiveArea";
-export * from "./ArchiveSector";
-export * from "./ImportSector";
+export * from "./Area/ArchiveArea";
+export * from "./Sector/ArchiveSector";
+export * from "./Sector/ImportSector";

package/World/Archive/InitTasks.js

@@ -1,32 +1,23 @@
 import { Threads } from "@amodx/threads";
-import ArchiveSector from "./Functions/ArchiveSector";
+import ArchiveSector from "./Functions/Sector/ArchiveSector";
 import { WorldRegister } from "../WorldRegister";
-import ImportSector from "./Functions/ImportSector";
+import ImportSector from "./Functions/Sector/ImportSector";
 import { compressBinaryObject, expandBinaryObject, } from "../../Util/BinaryObject";
 function runArchiveSector(location) {
-    const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
-    if (!sector)
+    const sector = WorldRegister.sectors.get(...location);
+    if (!sector) {
+        console.warn([...location], WorldRegister._dimensions.get(0).sectors, sector);
         throw new Error(`Sector at location ${location.toString()} does not exist`);
+    }
     const archived = ArchiveSector({
-        location: location,
+        location,
     });
     const transfers = [];
-    // if (archived.palettes.light) transfers.push(archived.palettes.light.buffer);
-    if (archived.palettes.state)
-        transfers.push(archived.palettes.state.buffer);
-    if (archived.palettes.secondaryState)
-        transfers.push(archived.palettes.secondaryState.buffer);
     for (const section of archived.sections) {
         if (typeof section == "string")
             continue;
         if (ArrayBuffer.isView(section.buffers.id?.buffer))
             transfers.push(section.buffers.id.buffer);
-        if (ArrayBuffer.isView(section.buffers.state?.buffer))
-            transfers.push(section.buffers.state.buffer);
-        if (ArrayBuffer.isView(section.buffers.mod?.buffer))
-            transfers.push(section.buffers.mod.buffer);
-        if (ArrayBuffer.isView(section.buffers.state?.buffer))
-            transfers.push(section.buffers.state.buffer);
         if (ArrayBuffer.isView(section.buffers.light?.sun?.buffer))
             transfers.push((section.buffers.light?.sun).buffer);
         if (ArrayBuffer.isView(section.buffers.light?.red?.buffer))
@@ -41,15 +32,6 @@ function runArchiveSector(location) {
             continue;
         if (section.palettes.id)
             transfers.push(section.palettes.id.buffer);
-        //   if (section.palettes.light) transfers.push(section.palettes.light.buffer);
-        if (section.palettes.state)
-            transfers.push(section.palettes.state.buffer);
-        if (section.palettes.mod)
-            transfers.push(section.palettes.mod.buffer);
-        if (section.palettes.secondaryState)
-            transfers.push(section.palettes.secondaryState.buffer);
-        if (section.palettes.secondaryId)
-            transfers.push(section.palettes.secondaryId.buffer);
     }
     return [archived, transfers];
 }
@@ -71,17 +53,23 @@ export default function InitTasks(props) {
     });
     Threads.registerTask("import-sector", async (archived) => {
         const importedSector = ImportSector(archived, {});
-        await props.worldThread.runTaskAsync("load-sector", [
-            archived.location,
-            importedSector,
-        ]);
+        props.worldThread.runTask("load-sector", [
+            [
+                WorldRegister.dimensions._dimensionMap.get(archived.dimension) || 0,
+                archived.position.x,
+                archived.position.y,
+                archived.position.z,
+            ],
+            importedSector.buffer,
+        ], importedSector.buffer instanceof ArrayBuffer
+            ? [importedSector.buffer]
+            : []);
     });
     Threads.registerTask("import-sector-binary", async ([location, archived]) => {
         const archivedSector = await expandBinaryObject(archived, true);
         const importedSector = ImportSector(archivedSector, {});
-        await props.worldThread.runTaskAsync("load-sector", [
-            location,
-            importedSector,
-        ]);
+        props.worldThread.runTask("load-sector", [location, importedSector.buffer], importedSector.buffer instanceof ArrayBuffer
+            ? [importedSector.buffer]
+            : []);
     });
 }

package/World/Archive/Types/Archive.types.d.ts

@@ -0,0 +1,45 @@
+import { Vector3Like } from "@amodx/math";
+import { ArchivedVoxelPaletteDataKey } from "Voxels/Archive/VoxelArchive.types";
+import { WorldSpaceDataKey } from "World/WorldSpaces";
+export type ArchivedLightSegments = "sun" | "red" | "green" | "blue";
+export interface ArchivedDataKey extends WorldSpaceDataKey {
+    voxelPalette: ArchivedVoxelPaletteDataKey;
+}
+export interface BaseArchivedDataBase {
+    dimension: string;
+    /** A user provided version of the data. */
+    formatVersion: string;
+    /** The version of vlox the data was stored in. */
+    engineVersion: string;
+    dataKey: ArchivedDataKey;
+}
+export interface BaseArchivedSectorData {
+    /** The location of the sector in the world. */
+    position: Vector3Like;
+    /** Record of the sector's bit flags.  */
+    flags: Record<string, boolean>;
+    /** Record of the sector's timestamps. */
+    timestamps: Record<string, number>;
+}
+export interface BaseArchivedSectionData {
+    /** Record of the section's bit flags.  */
+    flags?: Record<string, boolean>;
+}
+/**
+ * Interface representing the palette data for a single section in the voxel engine.
+ */
+export interface BaseArchivedSectionPaletteData<BufferType> {
+    id?: BufferType;
+    light?: Partial<Record<ArchivedLightSegments, BufferType>>;
+    level?: BufferType;
+    secondary?: BufferType;
+}
+/**
+ * Interface representing the buffer data for a section.
+ */
+export interface BaseArchivedSectionBuffers<BufferType> {
+    id?: BufferType;
+    light?: Partial<Record<ArchivedLightSegments, BufferType>>;
+    level?: BufferType;
+    secondary?: BufferType;
+}

package/World/Archive/Types/Archive.types.js

@@ -0,0 +1 @@
+export {};

package/World/Archive/Types/ArchiveArea.types.d.ts

@@ -0,0 +1,38 @@
+import { VoxelBinaryStateSchemaNode } from "../../../Voxels/State/State.types";
+import { BinaryBufferData } from "../../../Util/BinaryBuffer/BinaryBuffer.types";
+import { ArchivedLightSegments, BaseArchivedDataBase, BaseArchivedSectorData } from "./Archive.types";
+import { ArchivedSectionData, ArchivedSectorDuplicteData } from "./ArchivedSector.types";
+export interface ArchiveAreaPalettesData {
+    voxelStateSchemas: Record<string, VoxelBinaryStateSchemaNode[]>;
+    voxelSchemas: Record<string, {
+        stateSchemaId?: string;
+        modSchema?: VoxelBinaryStateSchemaNode[];
+    } | null>;
+}
+/**
+ * Interface for an archived area.
+ */
+export interface ArchivedAreaData extends BaseArchivedDataBase {
+    palettes: ArchiveAreaPalettesData;
+    /** Array of archived sector data within the area. */
+    sectors: ArchivedAreaSectorData[];
+}
+/**
+ * Interface representing the palette data for a sector.
+ */
+export interface ArchivedAreaSectorPaletteData {
+    id: string[];
+    voxelPalette: BinaryBufferData;
+    level?: BinaryBufferData;
+    light?: Partial<Record<ArchivedLightSegments, BinaryBufferData>>;
+}
+/**
+ * Interface representing the archived data for a sector within an area.
+ */
+export interface ArchivedAreaSectorData extends BaseArchivedSectorData {
+    /** The palette data used within the sector. */
+    palettes: ArchivedAreaSectorPaletteData;
+    /** Array of archived section data or references to section data. */
+    sections: (ArchivedSectionData | string)[];
+    duplicates: ArchivedSectorDuplicteData;
+}

package/World/Archive/Types/ArchiveArea.types.js

@@ -0,0 +1 @@
+export {};