@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/IFurnitureVisualization.d.ts

@@ -0,0 +1,11 @@
+import { BaseFurniture } from "./BaseFurniture";
+import { IFurnitureVisualizationView } from "./IFurnitureVisualizationView";
+export interface IFurnitureVisualization {
+    isAnimated(animation?: string): boolean;
+    setView(view: IFurnitureVisualizationView): void;
+    updateFrame(frame: number): void;
+    updateDirection(direction: number): void;
+    updateAnimation(animation: string | undefined): void;
+    update(furniture: BaseFurniture): void;
+    destroy(): void;
+}

package/dist/objects/furniture/IFurnitureVisualization.js

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

package/dist/objects/furniture/IFurnitureVisualizationView.d.ts

@@ -0,0 +1,63 @@
+import type * as PIXI from "pixi.js";
+import { IFurnitureVisualizationData } from "./data/interfaces/IFurnitureVisualizationData";
+/**
+ * This is a intermediary interface injected into the visualization
+ * of a furniture (e.g. `AnimatedFurnitureVisualization`). This interface exposes
+ * all the necessary methods to manipulate the way the furniture displays on the screen.
+ */
+export interface IFurnitureVisualizationView {
+    /**
+     * Sets the displaying animation of the furniture.
+     * @param animation
+     */
+    setDisplayAnimation(animation?: string): void;
+    /**
+     * Sets the displaying direction of the furniture.
+     * @param direction
+     */
+    setDisplayDirection(direction: number): void;
+    /**
+     * Updates the furniture display with the previously set animation and direction.
+     */
+    updateDisplay(): void;
+    /**
+     * Gets the display layers of the furniture.
+     * This can only be called after `updateDisplay` has been called.
+     */
+    getLayers(): IFurnitureVisualizationLayer[];
+    /**
+     * Gets the visualization data of the furniture.
+     */
+    getVisualizationData(): IFurnitureVisualizationData;
+}
+export interface IFurnitureVisualizationLayer {
+    tag?: string;
+    /**
+     * How often frames are repeated
+     */
+    frameRepeat: number;
+    /**
+     * The layer index specified as a number.
+     * a = 0
+     * b = 1
+     * c = 2
+     *
+     * etc.
+     */
+    layerIndex: number;
+    /**
+     * The amount of frames for this layer
+     */
+    assetCount: number;
+    /**
+     * Sets the active frame to display for this layer
+     * @param frame
+     */
+    setCurrentFrameIndex(frame: number): void;
+    setColor(color: number): void;
+    alpha: number;
+    readonly z: number;
+    readonly ink?: string;
+    update(): void;
+    getSprites(): PIXI.Sprite[];
+}

package/dist/objects/furniture/IFurnitureVisualizationView.js

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

package/dist/objects/furniture/JsonFurnitureAssetBundle.d.ts

@@ -0,0 +1,18 @@
+import { IAssetBundle } from "../../assets/IAssetBundle";
+import { HitTexture } from "../hitdetection/HitTexture";
+import { IFurnitureAssetsData } from "./data/interfaces/IFurnitureAssetsData";
+import { IFurnitureIndexData } from "./data/interfaces/IFurnitureIndexData";
+import { IFurnitureVisualizationData } from "./data/interfaces/IFurnitureVisualizationData";
+import { IFurnitureAssetBundle } from "./IFurnitureAssetBundle";
+import { IFurnitureLogicData } from "./data/interfaces/IFurnitureLogicData";
+export declare class JsonFurnitureAssetBundle implements IFurnitureAssetBundle {
+    private _assetBundle;
+    private _data;
+    constructor(_assetBundle: IAssetBundle);
+    getLogic(): Promise<IFurnitureLogicData>;
+    getAssets(): Promise<IFurnitureAssetsData>;
+    getVisualization(): Promise<IFurnitureVisualizationData>;
+    getTexture(name: string): Promise<HitTexture>;
+    getIndex(): Promise<IFurnitureIndexData>;
+    private _load;
+}

package/dist/objects/furniture/JsonFurnitureAssetBundle.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFurnitureAssetBundle = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const HitTexture_1 = require("../hitdetection/HitTexture");
+const JsonFurnitureAssetsData_1 = require("./data/JsonFurnitureAssetsData");
+const JsonFurnitureVisualizationData_1 = require("./data/JsonFurnitureVisualizationData");
+const JsonFurnitureLogicData_1 = require("./data/JsonFurnitureLogicData");
+class JsonFurnitureAssetBundle {
+    constructor(_assetBundle) {
+        this._assetBundle = _assetBundle;
+        this._data = this._load();
+    }
+    async getLogic() {
+        const { logic } = await this._data;
+        return logic;
+    }
+    async getAssets() {
+        const { assets } = await this._data;
+        return assets;
+    }
+    async getVisualization() {
+        const { visualization } = await this._data;
+        return visualization;
+    }
+    async getTexture(name) {
+        const { spritesheet } = await this._data;
+        return HitTexture_1.HitTexture.fromSpriteSheet(spritesheet, name);
+    }
+    async getIndex() {
+        const { index } = await this._data;
+        return index;
+    }
+    async _load() {
+        const json = JSON.parse(await this._assetBundle.getString("index.json"));
+        const blob = await this._assetBundle.getBlob("spritesheet.png");
+        const baseTextureImage = await createImageBitmap(blob, {
+            premultiplyAlpha: "none",
+            colorSpaceConversion: "none",
+        });
+        const texture = PIXI.Texture.from(baseTextureImage);
+        texture.source.scaleMode = "nearest";
+        texture.source.antialias = false;
+        texture.source.autoGenerateMipmaps = false;
+        const spritesheet = new PIXI.Spritesheet(texture, json.spritesheet);
+        await spritesheet.parse();
+        return {
+            assets: new JsonFurnitureAssetsData_1.JsonFurnitureAssetsData(json.assets),
+            visualization: new JsonFurnitureVisualizationData_1.JsonFurnitureVisualizationData(json.visualization),
+            index: json.index,
+            spritesheet,
+            logic: new JsonFurnitureLogicData_1.JsonFurnitureLogicData(json.logic),
+        };
+    }
+}
+exports.JsonFurnitureAssetBundle = JsonFurnitureAssetBundle;

package/dist/objects/furniture/WallFurniture.d.ts

@@ -0,0 +1,90 @@
+import { RoomObject } from "../RoomObject";
+import { FurnitureFetchInfo } from "./FurnitureFetchInfo";
+import { FurnitureId } from "../../interfaces/IFurnitureData";
+export declare class WallFurniture extends RoomObject {
+    readonly placementType = "wall";
+    private _baseFurniture;
+    private readonly _type;
+    private readonly _id;
+    private _roomX;
+    private _roomY;
+    private _offsetX;
+    private _offsetY;
+    /**
+     * Absolute room height of the item, as Habbo ships it in the `a=` field of the
+     * wall location. When it is there we use it directly: it is the same value the
+     * server derived the offsets from, so it spares us guessing the height of the
+     * tile the item hangs on — which is exactly where a room model that only
+     * stores walkable tiles falls short.
+     */
+    private _altitude;
+    constructor(options: {
+        roomX: number;
+        roomY: number;
+        offsetX: number;
+        offsetY: number;
+        direction: number;
+        animation?: string;
+        altitude?: number;
+    } & FurnitureFetchInfo);
+    /**
+     * 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: number, roomY: number, offsetX: number, offsetY: number): void;
+    get extradata(): Promise<import("./FurnitureExtraData").FurnitureExtraData>;
+    get validDirections(): Promise<number[]>;
+    get validAnimations(): Promise<number[]>;
+    get height(): Promise<number | undefined>;
+    get id(): FurnitureId | undefined;
+    get highlight(): string | boolean;
+    set highlight(value: string | boolean);
+    get activeWired(): boolean;
+    set activeWired(value: boolean);
+    get alpha(): number;
+    set alpha(value: number);
+    get type(): string | undefined;
+    get animation(): string;
+    set animation(value: string);
+    get direction(): number;
+    set direction(value: number);
+    get roomX(): number;
+    set roomX(value: number);
+    get roomY(): number;
+    set roomY(value: number);
+    get offsetX(): number;
+    set offsetX(value: number);
+    get offsetY(): number;
+    set offsetY(value: number);
+    get visualization(): import("./IFurnitureVisualization").IFurnitureVisualization;
+    set visualization(value: import("./IFurnitureVisualization").IFurnitureVisualization);
+    get onClick(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onClick(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onDoubleClick(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onDoubleClick(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onPointerDown(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onPointerDown(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onPointerUp(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onPointerUp(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onPointerOver(): ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined;
+    set onPointerOver(value: ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined);
+    get onPointerOut(): ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined;
+    set onPointerOut(value: ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined);
+    destroyed(): void;
+    registered(): void;
+    /**
+     * 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.
+     */
+    private _touchesWall;
+    private _getOffsets;
+    get altitude(): number | undefined;
+    set altitude(value: number | undefined);
+    private _updatePosition;
+}

package/dist/objects/furniture/WallFurniture.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WallFurniture = void 0;
+const RoomObject_1 = require("../RoomObject");
+const getZOrder_1 = require("../../util/getZOrder");
+const BaseFurniture_1 = require("./BaseFurniture");
+const getMaskId_1 = require("../room/util/getMaskId");
+const getFurnitureFetch_1 = require("./util/getFurnitureFetch");
+const LegacyWallGeometry_1 = require("../room/util/LegacyWallGeometry");
+class WallFurniture extends RoomObject_1.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_1.BaseFurniture({
+            animation: options.animation,
+            direction: options.direction,
+            type: (0, getFurnitureFetch_1.getFurnitureFetch)(options, "wall"),
+            getMaskId: (direction) => this._touchesWall(direction)
+                ? (0, getMaskId_1.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_1.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 = (0, getZOrder_1.getZOrder)(this.roomX, this.roomY, 0) - 1;
+    }
+}
+exports.WallFurniture = WallFurniture;

package/dist/objects/furniture/XmlFurnitureAssetBundle.d.ts

@@ -0,0 +1,17 @@
+import { IAssetBundle } from "../../assets/IAssetBundle";
+import { HitTexture } from "../hitdetection/HitTexture";
+import { IFurnitureAssetsData } from "./data/interfaces/IFurnitureAssetsData";
+import { IFurnitureIndexData } from "./data/interfaces/IFurnitureIndexData";
+import { IFurnitureLogicData } from "./data/interfaces/IFurnitureLogicData";
+import { IFurnitureVisualizationData } from "./data/interfaces/IFurnitureVisualizationData";
+import { IFurnitureAssetBundle } from "./IFurnitureAssetBundle";
+export declare class XmlFurnitureAssetBundle implements IFurnitureAssetBundle {
+    private _type;
+    private _assetBundle;
+    constructor(_type: string, _assetBundle: IAssetBundle);
+    getAssets(): Promise<IFurnitureAssetsData>;
+    getVisualization(): Promise<IFurnitureVisualizationData>;
+    getTexture(name: string): Promise<HitTexture>;
+    getIndex(): Promise<IFurnitureIndexData>;
+    getLogic(): Promise<IFurnitureLogicData>;
+}

package/dist/objects/furniture/XmlFurnitureAssetBundle.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlFurnitureAssetBundle = void 0;
+const HitTexture_1 = require("../hitdetection/HitTexture");
+const FurnitureAssetsData_1 = require("./data/FurnitureAssetsData");
+const FurnitureIndexData_1 = require("./data/FurnitureIndexData");
+const FurnitureLogicData_1 = require("./data/FurnitureLogicData");
+const FurnitureVisualizationData_1 = require("./data/FurnitureVisualizationData");
+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_1.FurnitureAssetsData(data);
+    }
+    async getVisualization() {
+        const data = await this._assetBundle.getString(`${this._type}_visualization.bin`);
+        return new FurnitureVisualizationData_1.FurnitureVisualizationData(data);
+    }
+    async getTexture(name) {
+        const blob = await this._assetBundle.getBlob(`${name}.png`);
+        return HitTexture_1.HitTexture.fromBlob(blob);
+    }
+    async getIndex() {
+        const data = await this._assetBundle.getString(`index.bin`);
+        return new FurnitureIndexData_1.FurnitureIndexData(data);
+    }
+    async getLogic() {
+        const data = await this._assetBundle.getString(`${this._type}_logic.bin`);
+        return new FurnitureLogicData_1.FurnitureLogicData(data);
+    }
+}
+exports.XmlFurnitureAssetBundle = XmlFurnitureAssetBundle;

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

@@ -0,0 +1,11 @@
+import { XmlData } from "../../../data/XmlData";
+import { FurnitureAssetsJson } from "./FurnitureAssetsJson";
+import { FurnitureAsset, IFurnitureAssetsData } from "./interfaces/IFurnitureAssetsData";
+export declare class FurnitureAssetsData extends XmlData implements IFurnitureAssetsData {
+    private _assets;
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<FurnitureAssetsData>;
+    toJson(): FurnitureAssetsJson;
+    getAsset(name: string): FurnitureAsset | undefined;
+    getAssets(): FurnitureAsset[];
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureAssetsData = void 0;
+const XmlData_1 = require("../../../data/XmlData");
+class FurnitureAssetsData extends XmlData_1.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());
+    }
+}
+exports.FurnitureAssetsData = FurnitureAssetsData;

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

@@ -0,0 +1,4 @@
+import { FurnitureAsset } from "./interfaces/IFurnitureAssetsData";
+export interface FurnitureAssetsJson {
+    [key: string]: FurnitureAsset | undefined;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { FurnitureIndexJson } from "./FurnitureIndexJson";
+export declare class FurnitureIndexData {
+    private _visualization;
+    private _logic;
+    get visualization(): string | undefined;
+    get logic(): string | undefined;
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<FurnitureIndexData>;
+    toJson(): FurnitureIndexJson;
+    toObject(): {
+        visualization: string | undefined;
+        logic: string | undefined;
+    };
+}