@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/objects/furniture/WallFurniture.js

@@ -0,0 +1,225 @@
+import { RoomObject } from "../RoomObject";
+import { getZOrder } from "../../util/getZOrder";
+import { BaseFurniture } from "./BaseFurniture";
+import { getMaskId } from "../room/util/getMaskId";
+import { getFurnitureFetch } from "./util/getFurnitureFetch";
+import { LegacyWallGeometry } from "../room/util/LegacyWallGeometry";
+export class WallFurniture extends RoomObject {
+    constructor(options) {
+        super();
+        this.placementType = "wall";
+        this._offsetX = 0;
+        this._offsetY = 0;
+        this._type = options.type;
+        this._id = options.id;
+        this._roomX = options.roomX;
+        this._roomY = options.roomY;
+        this._offsetX = options.offsetX;
+        this._offsetY = options.offsetY;
+        this._altitude = options.altitude;
+        this._baseFurniture = new BaseFurniture({
+            animation: options.animation,
+            direction: options.direction,
+            type: getFurnitureFetch(options, "wall"),
+            getMaskId: (direction) => this._touchesWall(direction)
+                ? getMaskId(direction, this.roomX, this.roomY)
+                : undefined,
+        });
+    }
+    /**
+     * Moves the furniture to another spot on the walls.
+     *
+     * @param roomX New x-Position
+     * @param roomY New y-Position
+     * @param offsetX New x-Offset within the wall tile
+     * @param offsetY New y-Offset within the wall tile
+     */
+    move(roomX, roomY, offsetX, offsetY) {
+        if (this._roomX === roomX &&
+            this._roomY === roomY &&
+            this._offsetX === offsetX &&
+            this._offsetY === offsetY) {
+            return;
+        }
+        this._roomX = roomX;
+        this._roomY = roomY;
+        this._offsetX = offsetX;
+        this._offsetY = offsetY;
+        this._updatePosition();
+    }
+    get extradata() {
+        return this._baseFurniture.extradata;
+    }
+    get validDirections() {
+        return this._baseFurniture.validDirections;
+    }
+    get validAnimations() {
+        return this._baseFurniture.validAnimations;
+    }
+    get height() {
+        return this._baseFurniture.height;
+    }
+    get id() {
+        return this._id;
+    }
+    get highlight() {
+        return this._baseFurniture.highlight;
+    }
+    set highlight(value) {
+        this._baseFurniture.highlight = value;
+    }
+    get activeWired() {
+        return this._baseFurniture.activeWired;
+    }
+    set activeWired(value) {
+        this._baseFurniture.activeWired = value;
+    }
+    get alpha() {
+        return this._baseFurniture.alpha;
+    }
+    set alpha(value) {
+        this._baseFurniture.alpha = value;
+    }
+    get type() {
+        return this._type;
+    }
+    get animation() {
+        return this._baseFurniture.animation;
+    }
+    set animation(value) {
+        this._baseFurniture.animation = value;
+    }
+    get direction() {
+        return this._baseFurniture.direction;
+    }
+    set direction(value) {
+        this._baseFurniture.direction = value;
+    }
+    get roomX() {
+        return this._roomX;
+    }
+    set roomX(value) {
+        this._roomX = value;
+        this._updatePosition();
+    }
+    get roomY() {
+        return this._roomY;
+    }
+    set roomY(value) {
+        this._roomY = value;
+        this._updatePosition();
+    }
+    get offsetX() {
+        return this._offsetX;
+    }
+    set offsetX(value) {
+        this._offsetX = value;
+        this._updatePosition();
+    }
+    get offsetY() {
+        return this._offsetY;
+    }
+    set offsetY(value) {
+        this._offsetY = value;
+        this._updatePosition();
+    }
+    get visualization() {
+        return this._baseFurniture.visualization;
+    }
+    set visualization(value) {
+        this._baseFurniture.visualization = value;
+    }
+    get onClick() {
+        return this._baseFurniture.onClick;
+    }
+    set onClick(value) {
+        this._baseFurniture.onClick = value;
+    }
+    get onDoubleClick() {
+        return this._baseFurniture.onDoubleClick;
+    }
+    set onDoubleClick(value) {
+        this._baseFurniture.onDoubleClick = value;
+    }
+    get onPointerDown() {
+        return this._baseFurniture.onPointerDown;
+    }
+    set onPointerDown(value) {
+        this._baseFurniture.onPointerDown = value;
+    }
+    get onPointerUp() {
+        return this._baseFurniture.onPointerUp;
+    }
+    set onPointerUp(value) {
+        this._baseFurniture.onPointerUp = value;
+    }
+    get onPointerOver() {
+        return this._baseFurniture.onPointerOver;
+    }
+    set onPointerOver(value) {
+        this._baseFurniture.onPointerOver = value;
+    }
+    get onPointerOut() {
+        return this._baseFurniture.onPointerOut;
+    }
+    set onPointerOut(value) {
+        this._baseFurniture.onPointerOut = value;
+    }
+    destroyed() {
+        this._baseFurniture.destroy();
+    }
+    registered() {
+        this._baseFurniture.dependencies = {
+            animationTicker: this.animationTicker,
+            furnitureLoader: this.furnitureLoader,
+            placeholder: undefined,
+            configuration: this.configuration,
+            visualization: this.roomVisualization,
+            eventManager: this.eventManager,
+        };
+        this._updatePosition();
+    }
+    /**
+     * A window only reveals the landscape while it sits in an actual wall plane —
+     * see RoomVisualization.updateRoomPlaneMasks, which binds a mask to a plane
+     * only when the object lies in it. Items dragged out into the room have no
+     * plane to cut open, so their glass stays transparent.
+     */
+    _touchesWall(direction) {
+        var _a, _b;
+        const row = (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.getParsedTileTypes()) === null || _b === void 0 ? void 0 : _b[this.roomY];
+        const tile = row === null || row === void 0 ? void 0 : row[this.roomX];
+        if ((tile === null || tile === void 0 ? void 0 : tile.type) !== "wall")
+            return false;
+        switch (tile.kind) {
+            case "innerCorner":
+            case "outerCorner":
+                return true;
+            case "rowWall":
+                return direction === 2 || direction === 6;
+            case "colWall":
+                return direction === 0 || direction === 4;
+        }
+    }
+    _getOffsets(direction) {
+        var _a;
+        const geo = new LegacyWallGeometry(this.room.getParsedTileTypes());
+        const roomPosition = geo.getLocation(this.roomX, this.roomY, this._offsetX, this._offsetY, direction === 2 ? "l" : "r");
+        return this.room.getPosition(roomPosition.x, roomPosition.y, (_a = this._altitude) !== null && _a !== void 0 ? _a : roomPosition.z);
+    }
+    get altitude() {
+        return this._altitude;
+    }
+    set altitude(value) {
+        this._altitude = value;
+        this._updatePosition();
+    }
+    _updatePosition() {
+        const position = this._getOffsets(this.direction);
+        if (position == null)
+            return;
+        this._baseFurniture.x = position.x;
+        this._baseFurniture.y = position.y;
+        this._baseFurniture.zIndex = getZOrder(this.roomX, this.roomY, 0) - 1;
+    }
+}

package/dist-esm/objects/furniture/XmlFurnitureAssetBundle.js

@@ -0,0 +1,31 @@
+import { HitTexture } from "../hitdetection/HitTexture";
+import { FurnitureAssetsData } from "./data/FurnitureAssetsData";
+import { FurnitureIndexData } from "./data/FurnitureIndexData";
+import { FurnitureLogicData } from "./data/FurnitureLogicData";
+import { FurnitureVisualizationData } from "./data/FurnitureVisualizationData";
+export class XmlFurnitureAssetBundle {
+    constructor(_type, _assetBundle) {
+        this._type = _type;
+        this._assetBundle = _assetBundle;
+    }
+    async getAssets() {
+        const data = await this._assetBundle.getString(`${this._type}_assets.bin`);
+        return new FurnitureAssetsData(data);
+    }
+    async getVisualization() {
+        const data = await this._assetBundle.getString(`${this._type}_visualization.bin`);
+        return new FurnitureVisualizationData(data);
+    }
+    async getTexture(name) {
+        const blob = await this._assetBundle.getBlob(`${name}.png`);
+        return HitTexture.fromBlob(blob);
+    }
+    async getIndex() {
+        const data = await this._assetBundle.getString(`index.bin`);
+        return new FurnitureIndexData(data);
+    }
+    async getLogic() {
+        const data = await this._assetBundle.getString(`${this._type}_logic.bin`);
+        return new FurnitureLogicData(data);
+    }
+}

package/dist-esm/objects/furniture/data/FurnitureAssetsData.js

@@ -0,0 +1,47 @@
+import { XmlData } from "../../../data/XmlData";
+export class FurnitureAssetsData extends XmlData {
+    constructor(xml) {
+        super(xml);
+        this._assets = new Map();
+        this.querySelectorAll("asset").forEach((element) => {
+            const name = element.getAttribute("name");
+            const x = Number(element.getAttribute("x"));
+            const y = Number(element.getAttribute("y"));
+            const source = element.getAttribute("source");
+            const flipH = element.getAttribute("flipH") === "1";
+            if (name == null)
+                throw new Error("Invalid name");
+            if (isNaN(x))
+                throw new Error("x is not a number");
+            if (isNaN(y))
+                throw new Error("y is not a number");
+            this._assets.set(name, {
+                x,
+                y,
+                source: source !== null && source !== void 0 ? source : undefined,
+                flipH,
+                name,
+                valid: true,
+            });
+        });
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new FurnitureAssetsData(text);
+    }
+    toJson() {
+        const assets = this.getAssets();
+        const assetsObject = {};
+        assets.forEach((asset) => {
+            assetsObject[asset.name] = asset;
+        });
+        return assetsObject;
+    }
+    getAsset(name) {
+        return this._assets.get(name);
+    }
+    getAssets() {
+        return Array.from(this._assets.values());
+    }
+}

package/dist-esm/objects/furniture/data/FurnitureAssetsJson.js

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

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

@@ -0,0 +1,26 @@
+export 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 };
+    }
+}

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

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

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

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

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

@@ -0,0 +1,39 @@
+import { XmlData } from "../../../data/XmlData";
+export class FurnitureLogicData extends 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;
+    }
+}

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

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

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

@@ -0,0 +1,277 @@
+import { XmlData } from "../../../data/XmlData";
+import { notNullOrUndefined } from "../../../util/notNullOrUndefined";
+export class FurnitureVisualizationData extends 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)
+            .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)
+                    .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);
+            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);
+        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;
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { notNullOrUndefined } from "../../../util/notNullOrUndefined";
+export class JsonFurnitureAssetsData {
+    constructor(_assets) {
+        this._assets = _assets;
+    }
+    getAsset(name) {
+        return this._assets[name];
+    }
+    getAssets() {
+        return Object.values(this._assets).filter(notNullOrUndefined);
+    }
+}

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

@@ -0,0 +1,8 @@
+export class JsonFurnitureLogicData {
+    constructor(_logic) {
+        this._logic = _logic;
+    }
+    getLogic() {
+        return { ...this._logic };
+    }
+}