@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/data/FurnitureIndexData.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureIndexData = void 0;
+class FurnitureIndexData {
+    get visualization() {
+        return this._visualization;
+    }
+    get logic() {
+        return this._logic;
+    }
+    constructor(xml) {
+        var _a, _b;
+        const document = new DOMParser().parseFromString(xml, "text/xml");
+        const object = document.querySelector("object");
+        this._visualization = (_a = object === null || object === void 0 ? void 0 : object.getAttribute("visualization")) !== null && _a !== void 0 ? _a : undefined;
+        this._logic = (_b = object === null || object === void 0 ? void 0 : object.getAttribute("logic")) !== null && _b !== void 0 ? _b : undefined;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new FurnitureIndexData(text);
+    }
+    toJson() {
+        return this.toObject();
+    }
+    toObject() {
+        return { visualization: this.visualization, logic: this.logic };
+    }
+}
+exports.FurnitureIndexData = FurnitureIndexData;

package/dist/objects/furniture/data/FurnitureIndexJson.d.ts

@@ -0,0 +1,4 @@
+export interface FurnitureIndexJson {
+    logic?: string;
+    visualization?: string;
+}

package/dist/objects/furniture/data/FurnitureIndexJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/data/FurnitureJson.d.ts

@@ -0,0 +1,11 @@
+import { FurnitureAssetsJson } from "./FurnitureAssetsJson";
+import { FurnitureIndexJson } from "./FurnitureIndexJson";
+import { FurnitureLogicJson } from "./FurnitureLogicJson";
+import { FurnitureVisualizationJson } from "./FurnitureVisualizationJson";
+export interface FurnitureJson {
+    visualization: FurnitureVisualizationJson;
+    logic: FurnitureLogicJson;
+    assets: FurnitureAssetsJson;
+    index: FurnitureIndexJson;
+    spritesheet: any;
+}

package/dist/objects/furniture/data/FurnitureJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/data/FurnitureLogicData.d.ts

@@ -0,0 +1,10 @@
+import { XmlData } from "../../../data/XmlData";
+import { FurnitureLogicJson } from "./FurnitureLogicJson";
+import { FurnitureLogic, IFurnitureLogicData } from "./interfaces/IFurnitureLogicData";
+export declare class FurnitureLogicData extends XmlData implements IFurnitureLogicData {
+    private _logic;
+    constructor(xml: string);
+    private parseObjectData;
+    toJson(): FurnitureLogicJson | undefined;
+    getLogic(): FurnitureLogic | undefined;
+}

package/dist/objects/furniture/data/FurnitureLogicData.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureLogicData = void 0;
+const XmlData_1 = require("../../../data/XmlData");
+class FurnitureLogicData extends XmlData_1.XmlData {
+    constructor(xml) {
+        super(xml);
+        this.parseObjectData();
+    }
+    parseObjectData() {
+        var _a, _b, _c;
+        const objectDataElement = this.querySelector("objectData");
+        if (!objectDataElement)
+            return;
+        const type = objectDataElement.getAttribute("type");
+        if (!type)
+            throw new Error("Invalid object type");
+        const dimensionsElement = objectDataElement.querySelector("dimensions");
+        const directions = Array.from(objectDataElement.querySelectorAll("direction")).map((dir) => Number(dir.getAttribute("id")));
+        const particleSystemElement = objectDataElement.querySelector("particlesystem");
+        this._logic = {
+            type,
+            dimensions: {
+                x: Number((_a = dimensionsElement === null || dimensionsElement === void 0 ? void 0 : dimensionsElement.getAttribute("x")) !== null && _a !== void 0 ? _a : 0),
+                y: Number((_b = dimensionsElement === null || dimensionsElement === void 0 ? void 0 : dimensionsElement.getAttribute("y")) !== null && _b !== void 0 ? _b : 0),
+                z: Number((_c = dimensionsElement === null || dimensionsElement === void 0 ? void 0 : dimensionsElement.getAttribute("z")) !== null && _c !== void 0 ? _c : 0),
+            },
+            directions,
+            particleSystemSize: particleSystemElement
+                ? Number(particleSystemElement.getAttribute("size"))
+                : undefined,
+        };
+    }
+    toJson() {
+        if (!this._logic)
+            return undefined;
+        return this._logic;
+    }
+    getLogic() {
+        return this._logic;
+    }
+}
+exports.FurnitureLogicData = FurnitureLogicData;

package/dist/objects/furniture/data/FurnitureLogicJson.d.ts

@@ -0,0 +1,3 @@
+import { FurnitureLogic } from "./interfaces/IFurnitureLogicData";
+export interface FurnitureLogicJson extends FurnitureLogic {
+}

package/dist/objects/furniture/data/FurnitureLogicJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/data/FurnitureVisualizationData.d.ts

@@ -0,0 +1,26 @@
+import { XmlData } from "../../../data/XmlData";
+import { FurnitureVisualizationJson } from "./FurnitureVisualizationJson";
+import { FurnitureAnimationLayer, FurnitureDirectionLayer, IFurnitureVisualizationData, FurnitureLayer, FurnitureAnimation } from "./interfaces/IFurnitureVisualizationData";
+export declare class FurnitureVisualizationData extends XmlData implements IFurnitureVisualizationData {
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<FurnitureVisualizationData>;
+    getFrameCountWithoutRepeat(size: number, animationId: number): number | undefined;
+    getTransitionForAnimation(size: number, transitionTo: number): FurnitureAnimation | undefined;
+    getAnimation(size: number, animationId: number): FurnitureAnimation | undefined;
+    getColor(size: number, colorId: number, layerId: number): string | undefined;
+    getFrameCount(size: number, animationId: number): number | undefined;
+    getAnimationIds(size: number): number[];
+    getAnimationLayer(size: number, animationId: number, id: number): FurnitureAnimationLayer | undefined;
+    getDirections(size: number): number[];
+    getDirectionLayer(size: number, direction: number, layerId: number): FurnitureDirectionLayer | undefined;
+    getLayerCount(size: number): number;
+    getLayer(size: number, layerId: number): FurnitureLayer | undefined;
+    toJson(): FurnitureVisualizationJson;
+    private _toJsonMap;
+    private _getJsonAnimations;
+    private _getJsonColors;
+    private _getDirections;
+    private _getLayers;
+    private _getJsonForSize;
+    private _getNumberFromAttributeValue;
+}

package/dist/objects/furniture/data/FurnitureVisualizationData.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureVisualizationData = void 0;
+const XmlData_1 = require("../../../data/XmlData");
+const notNullOrUndefined_1 = require("../../../util/notNullOrUndefined");
+class FurnitureVisualizationData extends XmlData_1.XmlData {
+    constructor(xml) {
+        super(xml);
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new FurnitureVisualizationData(text);
+    }
+    getFrameCountWithoutRepeat(size, animationId) {
+        const frameSequences = this.querySelectorAll(`visualization[size="${size}"] animation[id="${animationId}"] frameSequence`);
+        let count;
+        frameSequences.forEach((element) => {
+            const value = element.children.length;
+            if (count == null || value > count) {
+                count = value;
+            }
+        });
+        return count;
+    }
+    getTransitionForAnimation(size, transitionTo) {
+        var _a;
+        const animation = this.querySelector(`visualization[size="${size}"] animations animation[transitionTo="${transitionTo}"]`);
+        const animationId = Number((_a = animation === null || animation === void 0 ? void 0 : animation.getAttribute("id")) !== null && _a !== void 0 ? _a : undefined);
+        if (isNaN(animationId)) {
+            return;
+        }
+        return {
+            id: animationId,
+            transitionTo,
+        };
+    }
+    getAnimation(size, animationId) {
+        var _a;
+        const animation = this.querySelector(`visualization[size="${size}"] animations animation[id="${animationId}"]`);
+        if (animation == null)
+            return;
+        const transitionAnimationId = Number((_a = animation === null || animation === void 0 ? void 0 : animation.getAttribute("transitionTo")) !== null && _a !== void 0 ? _a : undefined);
+        return {
+            id: animationId,
+            transitionTo: isNaN(transitionAnimationId)
+                ? undefined
+                : transitionAnimationId,
+        };
+    }
+    getColor(size, colorId, layerId) {
+        var _a;
+        const colorElement = this.querySelector(`visualization[size="${size}"] colors color[id="${colorId}"] colorLayer[id="${layerId}"]`);
+        return (_a = colorElement === null || colorElement === void 0 ? void 0 : colorElement.getAttribute("color")) !== null && _a !== void 0 ? _a : undefined;
+    }
+    getFrameCount(size, animationId) {
+        const frameSequences = this.querySelectorAll(`visualization[size="${size}"] animation[id="${animationId}"] frameSequence`);
+        let count;
+        frameSequences.forEach((element) => {
+            var _a;
+            const parent = element.parentElement;
+            const multiplier = Number((_a = parent === null || parent === void 0 ? void 0 : parent.getAttribute("frameRepeat")) !== null && _a !== void 0 ? _a : "1");
+            const value = element.children.length * multiplier;
+            if (count == null || value > count) {
+                count = value;
+            }
+        });
+        return count;
+    }
+    getAnimationIds(size) {
+        const animations = this.querySelectorAll(`visualization[size="${size}"] animations animation`);
+        return animations
+            .map((element) => element.getAttribute("id"))
+            .filter(notNullOrUndefined_1.notNullOrUndefined)
+            .map((id) => Number(id));
+    }
+    getAnimationLayer(size, animationId, id) {
+        var _a, _b;
+        const animationLayer = this.querySelector(`visualization[size="${size}"] animations animation[id="${animationId}"] animationLayer[id="${id}"]`);
+        if (animationLayer == null)
+            return;
+        const frameRepeat = Number((_a = animationLayer.getAttribute("frameRepeat")) !== null && _a !== void 0 ? _a : undefined);
+        const loopCount = Number((_b = animationLayer.getAttribute("loopCount")) !== null && _b !== void 0 ? _b : undefined);
+        const frames = Array.from(animationLayer.querySelectorAll(`frameSequence frame`));
+        return {
+            id: animationId,
+            frames: frames.map((element) => { var _a; return Number((_a = element.getAttribute("id")) !== null && _a !== void 0 ? _a : undefined); }),
+            frameRepeat: isNaN(frameRepeat) ? undefined : frameRepeat,
+            loopCount: isNaN(loopCount) ? undefined : loopCount,
+        };
+    }
+    getDirections(size) {
+        const directions = this.querySelectorAll(`visualization[size="${size}"] directions direction`);
+        return directions.map((element) => {
+            var _a;
+            const id = (_a = element.getAttribute("id")) !== null && _a !== void 0 ? _a : undefined;
+            return Number(id);
+        });
+    }
+    getDirectionLayer(size, direction, layerId) {
+        const directionLayer = this.querySelector(`visualization[size="${size}"] directions direction[id="${direction}"] layer[id="${layerId}"]`);
+        if (directionLayer == null)
+            return;
+        const z = this._getNumberFromAttributeValue(directionLayer.getAttribute("z"));
+        const x = this._getNumberFromAttributeValue(directionLayer.getAttribute("x"));
+        const y = this._getNumberFromAttributeValue(directionLayer.getAttribute("y"));
+        return {
+            z: z,
+            x: x,
+            y: y,
+        };
+    }
+    getLayerCount(size) {
+        var _a;
+        const visualization = this.querySelector(`visualization[size="${size}"]`);
+        if (visualization == null)
+            throw new Error("Invalid visualization");
+        return Number((_a = visualization.getAttribute("layerCount")) !== null && _a !== void 0 ? _a : undefined);
+    }
+    getLayer(size, layerId) {
+        var _a, _b, _c, _d, _e, _f;
+        const layerElement = this.querySelector(`visualization[size="${size}"] layers layer[id="${layerId}"]`);
+        if (layerElement == null)
+            return;
+        const id = (_a = layerElement.getAttribute("id")) !== null && _a !== void 0 ? _a : undefined;
+        const z = (_b = layerElement.getAttribute("z")) !== null && _b !== void 0 ? _b : undefined;
+        const tag = (_c = layerElement.getAttribute("tag")) !== null && _c !== void 0 ? _c : undefined;
+        const alpha = (_d = layerElement.getAttribute("alpha")) !== null && _d !== void 0 ? _d : undefined;
+        const ink = (_e = layerElement.getAttribute("ink")) !== null && _e !== void 0 ? _e : undefined;
+        const ignoreMouse = (_f = layerElement.getAttribute("ignoreMouse")) !== null && _f !== void 0 ? _f : undefined;
+        const idNumber = Number(id);
+        const zNumber = Number(z);
+        const alphaNumber = Number(alpha);
+        if (isNaN(idNumber))
+            throw new Error("Invalid layer id");
+        return {
+            id: idNumber,
+            z: isNaN(zNumber) ? 0 : zNumber,
+            alpha: isNaN(alphaNumber) ? undefined : alphaNumber,
+            tag: tag !== null && tag !== void 0 ? tag : undefined,
+            ink: ink !== null && ink !== void 0 ? ink : undefined,
+            ignoreMouse: ignoreMouse != null ? ignoreMouse === "1" : undefined,
+        };
+    }
+    toJson() {
+        return {
+            ...this._getJsonForSize(64),
+        };
+    }
+    _toJsonMap(arr, getKey) {
+        const map = {};
+        arr.forEach((value) => {
+            const key = getKey(value);
+            if (key != null) {
+                map[key] = value;
+            }
+        });
+        return map;
+    }
+    _getJsonAnimations(size) {
+        const arr = Array.from(this.document.querySelectorAll(`visualization[size="${size}"] animations animation`))
+            .map((element) => {
+            const layers = Array.from(element.querySelectorAll(`animationLayer`))
+                .map((element) => {
+                const id = this._getNumberFromAttributeValue(element.getAttribute("id"));
+                const frames = Array.from(element.querySelectorAll(`frame`))
+                    .map((element) => element.getAttribute("id"))
+                    .filter(notNullOrUndefined_1.notNullOrUndefined)
+                    .map((id) => Number(id));
+                const frameRepeat = this._getNumberFromAttributeValue(element.getAttribute("frameRepeat"));
+                const loopCount = this._getNumberFromAttributeValue(element.getAttribute("loopCount"));
+                const random = this._getNumberFromAttributeValue(element.getAttribute("random")) === 1;
+                if (id == null)
+                    return;
+                return {
+                    id,
+                    frames,
+                    frameRepeat,
+                    loopCount,
+                    random,
+                };
+            })
+                .filter(notNullOrUndefined_1.notNullOrUndefined);
+            const animationId = this._getNumberFromAttributeValue(element.getAttribute("id"));
+            const transitionTo = this._getNumberFromAttributeValue(element.getAttribute("transitionTo"));
+            if (animationId == null)
+                return null;
+            return {
+                id: animationId,
+                layers: this._toJsonMap(layers, (layer) => layer.id.toString()),
+                transitionTo,
+            };
+        })
+            .filter(notNullOrUndefined_1.notNullOrUndefined);
+        return this._toJsonMap(arr, (element) => element.id.toString());
+    }
+    _getJsonColors(size) {
+        const arr = Array.from(this.document.querySelectorAll(`visualization[size="${size}"] colors color`)).map((element) => {
+            const colorId = element.getAttribute("id");
+            const colorLayers = Array.from(element.querySelectorAll("colorLayer")).map((element) => {
+                const layerId = element.getAttribute("id");
+                const color = element.getAttribute("color");
+                if (color == null)
+                    throw new Error("Invalid color");
+                return {
+                    id: layerId,
+                    color,
+                };
+            });
+            return {
+                id: colorId,
+                layers: this._toJsonMap(colorLayers, (layer) => layer.id),
+            };
+        });
+        return this._toJsonMap(arr, (value) => value.id);
+    }
+    _getDirections(size) {
+        const arr = Array.from(this.document.querySelectorAll(`visualization[size="${size}"] directions direction`)).map((element) => {
+            const id = element.getAttribute("id");
+            const layers = Array.from(element.querySelectorAll("layer")).map((element) => {
+                const id = element.getAttribute("id");
+                const x = this._getNumberFromAttributeValue(element.getAttribute("x"));
+                const y = this._getNumberFromAttributeValue(element.getAttribute("y"));
+                const z = this._getNumberFromAttributeValue(element.getAttribute("z"));
+                return {
+                    id,
+                    x,
+                    y,
+                    z,
+                };
+            });
+            return {
+                id,
+                layers: this._toJsonMap(layers, (layer) => layer.id),
+            };
+        });
+        return this._toJsonMap(arr, (direction) => direction.id);
+    }
+    _getLayers(size) {
+        const arr = Array.from(this.document.querySelectorAll(`visualization[size="${size}"] layers layer`)).map((element) => {
+            var _a, _b;
+            const id = this._getNumberFromAttributeValue(element.getAttribute("id"));
+            const ink = (_a = element.getAttribute("ink")) !== null && _a !== void 0 ? _a : undefined;
+            const alpha = this._getNumberFromAttributeValue(element.getAttribute("alpha"));
+            const z = this._getNumberFromAttributeValue(element.getAttribute("z"));
+            const ignoreMouse = this._getNumberFromAttributeValue(element.getAttribute("ignoreMouse")) === 1;
+            const tag = (_b = element.getAttribute("tag")) !== null && _b !== void 0 ? _b : undefined;
+            if (id == null)
+                throw new Error("Invalid id");
+            return {
+                id,
+                z: z !== null && z !== void 0 ? z : 0,
+                alpha,
+                ignoreMouse,
+                ink,
+                tag,
+            };
+        });
+        return this._toJsonMap(arr, (layer) => layer.id.toString());
+    }
+    _getJsonForSize(size) {
+        return {
+            [size.toString()]: {
+                layerCount: this.getLayerCount(size),
+                animations: this._getJsonAnimations(size),
+                colors: this._getJsonColors(size),
+                directions: this._getDirections(size),
+                layers: this._getLayers(size),
+            },
+        };
+    }
+    _getNumberFromAttributeValue(value) {
+        if (value == null)
+            return undefined;
+        const numberValue = Number(value);
+        if (isNaN(numberValue))
+            return undefined;
+        return numberValue;
+    }
+}
+exports.FurnitureVisualizationData = FurnitureVisualizationData;

package/dist/objects/furniture/data/FurnitureVisualizationJson.d.ts

@@ -0,0 +1,37 @@
+import { FurnitureAnimationLayer, FurnitureDirectionLayer, FurnitureLayer } from "./interfaces/IFurnitureVisualizationData";
+export interface FurnitureVisualizationJson {
+    [size: string]: {
+        layerCount: number;
+        layers: FurnitureLayersJson;
+        directions: FurnitureDirectionsJson;
+        colors: FurnitureColorsJson;
+        animations: FurnitureAnimationsJson;
+    };
+}
+export type FurnitureLayersJson = {
+    [id: string]: FurnitureLayer | undefined;
+};
+export type FurnitureDirectionsJson = {
+    [id: string]: {
+        layers: {
+            [id: string]: FurnitureDirectionLayer | undefined;
+        };
+    } | undefined;
+};
+export type FurnitureColorsJson = {
+    [id: string]: {
+        layers: {
+            [id: string]: {
+                color: string;
+            } | undefined;
+        };
+    } | undefined;
+};
+export type FurnitureAnimationsJson = {
+    [id: string]: {
+        layers: {
+            [id: string]: FurnitureAnimationLayer | undefined;
+        };
+        transitionTo?: number;
+    } | undefined;
+};

package/dist/objects/furniture/data/FurnitureVisualizationJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/data/JsonFurnitureAssetsData.d.ts

@@ -0,0 +1,8 @@
+import { FurnitureAssetsJson } from "./FurnitureAssetsJson";
+import { FurnitureAsset, IFurnitureAssetsData } from "./interfaces/IFurnitureAssetsData";
+export declare class JsonFurnitureAssetsData implements IFurnitureAssetsData {
+    private _assets;
+    constructor(_assets: FurnitureAssetsJson);
+    getAsset(name: string): FurnitureAsset | undefined;
+    getAssets(): FurnitureAsset[];
+}

package/dist/objects/furniture/data/JsonFurnitureAssetsData.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFurnitureAssetsData = void 0;
+const notNullOrUndefined_1 = require("../../../util/notNullOrUndefined");
+class JsonFurnitureAssetsData {
+    constructor(_assets) {
+        this._assets = _assets;
+    }
+    getAsset(name) {
+        return this._assets[name];
+    }
+    getAssets() {
+        return Object.values(this._assets).filter(notNullOrUndefined_1.notNullOrUndefined);
+    }
+}
+exports.JsonFurnitureAssetsData = JsonFurnitureAssetsData;

package/dist/objects/furniture/data/JsonFurnitureLogicData.d.ts

@@ -0,0 +1,7 @@
+import { FurnitureLogicJson } from "./FurnitureLogicJson";
+import { FurnitureLogic, IFurnitureLogicData } from "./interfaces/IFurnitureLogicData";
+export declare class JsonFurnitureLogicData implements IFurnitureLogicData {
+    private _logic;
+    constructor(_logic: FurnitureLogicJson);
+    getLogic(): FurnitureLogic | undefined;
+}

package/dist/objects/furniture/data/JsonFurnitureLogicData.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFurnitureLogicData = void 0;
+class JsonFurnitureLogicData {
+    constructor(_logic) {
+        this._logic = _logic;
+    }
+    getLogic() {
+        return { ...this._logic };
+    }
+}
+exports.JsonFurnitureLogicData = JsonFurnitureLogicData;

package/dist/objects/furniture/data/JsonFurnitureVisualizationData.d.ts

@@ -0,0 +1,18 @@
+import { FurnitureVisualizationJson } from "./FurnitureVisualizationJson";
+import { FurnitureAnimation, FurnitureAnimationLayer, FurnitureDirectionLayer, FurnitureLayer, IFurnitureVisualizationData } from "./interfaces/IFurnitureVisualizationData";
+export declare class JsonFurnitureVisualizationData implements IFurnitureVisualizationData {
+    private _furniture;
+    constructor(_furniture: FurnitureVisualizationJson);
+    getLayerCount(size: number): number;
+    getLayer(size: number, layerId: number): FurnitureLayer | undefined;
+    getDirections(size: number): number[];
+    getAnimationIds(size: number): number[];
+    getDirectionLayer(size: number, direction: number, layerId: number): FurnitureDirectionLayer | undefined;
+    getAnimationLayer(size: number, animationId: number, id: number): FurnitureAnimationLayer | undefined;
+    getFrameCountWithoutRepeat(size: number, animationId: number): number | undefined;
+    getFrameCount(size: number, animationId: number): number | undefined;
+    getColor(size: number, colorId: number, layerId: number): string | undefined;
+    getAnimation(size: number, animationId: number): FurnitureAnimation | undefined;
+    getTransitionForAnimation(size: number, transitionTo: number): FurnitureAnimation | undefined;
+    private _getVisualization;
+}

package/dist/objects/furniture/data/JsonFurnitureVisualizationData.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFurnitureVisualizationData = void 0;
+class JsonFurnitureVisualizationData {
+    constructor(_furniture) {
+        this._furniture = _furniture;
+    }
+    getLayerCount(size) {
+        return this._getVisualization(size).layerCount;
+    }
+    getLayer(size, layerId) {
+        return this._getVisualization(size).layers[layerId.toString()];
+    }
+    getDirections(size) {
+        return Object.keys(this._getVisualization(size).directions).map((direction) => Number(direction));
+    }
+    getAnimationIds(size) {
+        var _a;
+        return Object.keys((_a = this._getVisualization(size).animations) !== null && _a !== void 0 ? _a : {})
+            .map((id) => Number(id))
+            .filter((id) => !Number.isNaN(id))
+            .sort((a, b) => a - b);
+    }
+    getDirectionLayer(size, direction, layerId) {
+        var _a;
+        return (_a = this._getVisualization(size).directions[direction.toString()]) === null || _a === void 0 ? void 0 : _a.layers[layerId.toString()];
+    }
+    getAnimationLayer(size, animationId, id) {
+        var _a;
+        return (_a = this._getVisualization(size).animations[animationId.toString()]) === null || _a === void 0 ? void 0 : _a.layers[id.toString()];
+    }
+    getFrameCountWithoutRepeat(size, animationId) {
+        var _a;
+        let count = 1;
+        Object.values((_a = this._getVisualization(size).animations[animationId.toString()]) !== null && _a !== void 0 ? _a : {}).forEach((layers) => {
+            Object.values(layers !== null && layers !== void 0 ? layers : {}).forEach((layer) => {
+                var _a;
+                const frameCount = (_a = layer === null || layer === void 0 ? void 0 : layer.frames.length) !== null && _a !== void 0 ? _a : 0;
+                const value = frameCount;
+                if (value > count) {
+                    count = value;
+                }
+            });
+        });
+        return count;
+    }
+    getFrameCount(size, animationId) {
+        var _a;
+        let count = 1;
+        Object.values((_a = this._getVisualization(size).animations[animationId.toString()]) !== null && _a !== void 0 ? _a : {}).forEach((layers) => {
+            Object.values(layers !== null && layers !== void 0 ? layers : {}).forEach((layer) => {
+                var _a, _b;
+                const frameCount = (_a = layer === null || layer === void 0 ? void 0 : layer.frames.length) !== null && _a !== void 0 ? _a : 0;
+                const multiplier = (_b = layer === null || layer === void 0 ? void 0 : layer.frameRepeat) !== null && _b !== void 0 ? _b : 1;
+                const value = frameCount * multiplier;
+                if (value > count) {
+                    count = value;
+                }
+            });
+        });
+        return count;
+    }
+    getColor(size, colorId, layerId) {
+        var _a, _b;
+        return (_b = (_a = this._getVisualization(size).colors[colorId.toString()]) === null || _a === void 0 ? void 0 : _a.layers[layerId.toString()]) === null || _b === void 0 ? void 0 : _b.color;
+    }
+    getAnimation(size, animationId) {
+        const animation = this._getVisualization(size).animations[animationId.toString()];
+        if (animation != null) {
+            return {
+                transitionTo: animation.transitionTo,
+                id: animationId,
+            };
+        }
+    }
+    getTransitionForAnimation(size, transitionTo) {
+        const animations = Object.entries(this._getVisualization(size).animations);
+        const animationTransitionTo = animations.find(([id, animation]) => (animation === null || animation === void 0 ? void 0 : animation.transitionTo) === transitionTo);
+        if (animationTransitionTo != null) {
+            const animationId = Number(animationTransitionTo[0]);
+            return {
+                id: animationId,
+                transitionTo,
+            };
+        }
+    }
+    _getVisualization(size) {
+        const visualization = this._furniture[size.toString()];
+        if (visualization == null) {
+            throw new Error("Invalid visualization");
+        }
+        return visualization;
+    }
+}
+exports.JsonFurnitureVisualizationData = JsonFurnitureVisualizationData;

package/dist/objects/furniture/data/interfaces/IFurnitureAssetsData.d.ts

@@ -0,0 +1,12 @@
+export interface IFurnitureAssetsData {
+    getAsset(name: string): FurnitureAsset | undefined;
+    getAssets(): FurnitureAsset[];
+}
+export interface FurnitureAsset {
+    name: string;
+    x: number;
+    y: number;
+    flipH: boolean;
+    source?: string;
+    valid: boolean;
+}

package/dist/objects/furniture/data/interfaces/IFurnitureAssetsData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/data/interfaces/IFurnitureIndexData.d.ts

@@ -0,0 +1,4 @@
+export interface IFurnitureIndexData {
+    logic?: string;
+    visualization?: string;
+}

package/dist/objects/furniture/data/interfaces/IFurnitureIndexData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });