@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/objects/avatar/data/AvatarAnimationData.js

@@ -0,0 +1,122 @@
+import { animationXml } from "./static/animation.xml";
+export class AvatarAnimationData {
+    constructor(xml) {
+        this._animationFrames = new Map();
+        this._animationFramesCount = new Map();
+        const document = new DOMParser().parseFromString(xml, "text/xml");
+        // `action[id="${id}"] part[set-type="${type}"] frame`
+        document.querySelectorAll("action").forEach((action) => {
+            const actionId = action.getAttribute("id");
+            if (actionId == null)
+                return;
+            action.querySelectorAll("part").forEach((part) => {
+                const setType = part.getAttribute("set-type");
+                if (setType == null)
+                    return;
+                const frames = [];
+                part.querySelectorAll("frame").forEach((frame) => {
+                    const animationFrame = this._getAnimationFrameFromElement(frame);
+                    frames.push(animationFrame);
+                });
+                this._animationFrames.set(`${actionId}_${setType}`, frames);
+            });
+            const partFrameCount = action.querySelectorAll("part:first-child frame")
+                .length;
+            const offsetsFrameCount = action.querySelectorAll(`offsets frame`).length;
+            const frameCount = Math.max(partFrameCount, offsetsFrameCount);
+            this._animationFramesCount.set(actionId, frameCount);
+            action.querySelectorAll(`offsets frame`).forEach((frame) => {
+                const frameId = frame.getAttribute("id");
+                if (frameId == null)
+                    return;
+                frame.querySelectorAll(`directions direction`).forEach((direction) => {
+                    const directionId = direction.getAttribute("id");
+                    if (directionId == null)
+                        return;
+                    direction.querySelectorAll(`bodypart`).forEach((bodypart) => {
+                        const bodyPartId = bodypart.getAttribute("id");
+                        if (bodyPartId == null)
+                            return;
+                    });
+                });
+            });
+        });
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarAnimationData(text);
+    }
+    static default() {
+        return new AvatarAnimationData(atob(animationXml));
+    }
+    getAnimationFrame(id, type, frame) {
+        const frames = this._animationFrames.get(`${id}_${type}`);
+        if (frames == null)
+            return;
+        const animationFrameElement = frames[frame];
+        if (animationFrameElement == null)
+            return;
+        return animationFrameElement;
+    }
+    getAnimationFrames(id, type) {
+        var _a;
+        const key = `${id}_${type}`;
+        return (_a = this._animationFrames.get(key)) !== null && _a !== void 0 ? _a : [];
+    }
+    getAnimationFramesCount(id) {
+        var _a;
+        return (_a = this._animationFramesCount.get(id)) !== null && _a !== void 0 ? _a : 0;
+    }
+    getAnimationOffset(id, geometryId, frame, direction) {
+        /*
+        const bodypart = this.querySelector(
+          `action[id="${id}"] offsets frame[id="${frame}"] directions direction[id="${direction}"] bodypart[id="${geometryId}"]`
+        );
+    
+        if (bodypart == null) return { x: 0, y: 0 };
+    
+        const dx = Number(bodypart.getAttribute("dx"));
+        const dy = Number(bodypart.getAttribute("dy"));
+    
+        if (isNaN(dx) || isNaN(dy)) {
+          return { x: 0, y: 0 };
+        }
+    
+        return {
+          x: dx,
+          y: dy,
+        };*/
+    }
+    _getAnimationOffsetFromElement(bodypart) {
+        if (bodypart == null)
+            return { x: 0, y: 0 };
+        const dx = Number(bodypart.getAttribute("dx"));
+        const dy = Number(bodypart.getAttribute("dy"));
+        if (isNaN(dx) || isNaN(dy)) {
+            return { x: 0, y: 0 };
+        }
+        return {
+            x: dx,
+            y: dy,
+        };
+    }
+    _getAnimationFrameFromElement(element) {
+        const number = Number(element.getAttribute("number"));
+        if (isNaN(number))
+            throw new Error("number was NaN");
+        const repeatsString = element.getAttribute("repeats");
+        let repeats = 2;
+        if (repeatsString != null) {
+            repeats = Number(repeatsString);
+        }
+        const assetpartdefinition = element.getAttribute("assetpartdefinition");
+        if (assetpartdefinition == null)
+            throw new Error("assetpartdefinition was null");
+        return {
+            number,
+            assetpartdefinition,
+            repeats,
+        };
+    }
+}

package/dist-esm/objects/avatar/data/AvatarData.js

@@ -0,0 +1,11 @@
+export class AvatarData {
+    constructor(xml) {
+        this.document = new DOMParser().parseFromString(xml, "text/xml");
+    }
+    querySelectorAll(query) {
+        return Array.from(this.document.querySelectorAll(query));
+    }
+    querySelector(query) {
+        return this.document.querySelector(query);
+    }
+}

package/dist-esm/objects/avatar/data/AvatarEffectData.js

@@ -0,0 +1,182 @@
+import { getNumberFromAttribute } from "../../../util/getNumberFromAttribute";
+export class AvatarEffectData {
+    constructor(string) {
+        this._frameBodyParts = new Map();
+        this._frameFxParts = new Map();
+        this._sprites = new Map();
+        this._additions = new Map();
+        this._spriteDirections = new Map();
+        this._frameBodyPartsById = new Map();
+        this._frameBodyPartByBase = new Map();
+        this._frameFxPartsById = new Map();
+        const document = new DOMParser().parseFromString(string, "text/xml");
+        const frameElements = document.querySelectorAll("animation > frame");
+        frameElements.forEach((frame, index) => {
+            frame.querySelectorAll("bodypart").forEach((bodypart) => {
+                var _a;
+                const bodyPart = this._getFrameBodyPartFromElement(bodypart);
+                const current = (_a = this._frameBodyParts.get(index)) !== null && _a !== void 0 ? _a : [];
+                this._frameBodyParts.set(index, [...current, bodyPart]);
+                this._frameBodyPartsById.set(`${bodypart.id}_${index}`, bodyPart);
+                if (bodyPart.base != null) {
+                    this._frameBodyPartByBase.set(`${bodyPart.base}_${index}`, bodyPart);
+                }
+            });
+            frame.querySelectorAll("fx").forEach((element) => {
+                var _a;
+                const fxPart = this._getFXPartFromElement(element);
+                const current = (_a = this._frameFxParts.get(index)) !== null && _a !== void 0 ? _a : [];
+                if (fxPart != null) {
+                    this._frameFxParts.set(index, [...current, fxPart]);
+                    this._frameFxPartsById.set(`${fxPart.id}_${index}`, fxPart);
+                }
+            });
+        });
+        document.querySelectorAll("sprite").forEach((element) => {
+            const sprite = this._getEffectSpriteFromElement(element);
+            this._sprites.set(sprite.id, sprite);
+            element.querySelectorAll("direction").forEach((element) => {
+                const direction = this._getDirectionSpriteFromElement(element);
+                this._spriteDirections.set(`${sprite.id}_${direction.id}`, direction);
+            });
+        });
+        document.querySelectorAll("add").forEach((element) => {
+            const addition = this._getFXAddition(element);
+            this._additions.set(addition.id, addition);
+        });
+        const directionElement = document.querySelector("animation > direction");
+        if (directionElement != null) {
+            this._direction = this._getDirectionFromElement(directionElement);
+        }
+        this._frameCount = frameElements.length;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarEffectData(text);
+    }
+    getFrameBodyPartByBase(bodyPartId, frame) {
+        return this._frameBodyPartByBase.get(`${bodyPartId}_${frame}`);
+    }
+    getFrameEffectPart(id, frame) {
+        return this._frameFxPartsById.get(`${id}_${frame}`);
+    }
+    getFrameBodyPart(bodyPartId, frame) {
+        return this._frameBodyPartsById.get(`${bodyPartId}_${frame}`);
+    }
+    getAddtions() {
+        return Array.from(this._additions.values());
+    }
+    getFrameEffectParts(frame) {
+        var _a;
+        return (_a = this._frameFxParts.get(frame)) !== null && _a !== void 0 ? _a : [];
+    }
+    getDirection() {
+        return this._direction;
+    }
+    getFrameBodyParts(frame) {
+        var _a;
+        return (_a = this._frameBodyParts.get(frame)) !== null && _a !== void 0 ? _a : [];
+    }
+    getFrameCount() {
+        return this._frameCount;
+    }
+    getSprites() {
+        return Array.from(this._sprites.values());
+    }
+    getSpriteDirection(id, direction) {
+        return this._spriteDirections.get(`${id}_${direction}`);
+    }
+    _getFXAddition(element) {
+        var _a, _b, _c;
+        const id = (_a = element.getAttribute("id")) !== null && _a !== void 0 ? _a : undefined;
+        const align = (_b = element.getAttribute("align")) !== null && _b !== void 0 ? _b : undefined;
+        const base = (_c = element.getAttribute("base")) !== null && _c !== void 0 ? _c : undefined;
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            align,
+            base,
+        };
+    }
+    _getFXPartFromElement(element) {
+        // action="Default" frame="0" dx="2" dy="0" dd="6"
+        const action = element.getAttribute("action");
+        const frame = getNumberFromAttribute(element.getAttribute("frame"));
+        const dx = getNumberFromAttribute(element.getAttribute("dx"));
+        const dy = getNumberFromAttribute(element.getAttribute("dy"));
+        const dd = getNumberFromAttribute(element.getAttribute("dd"));
+        const id = element.getAttribute("id");
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            action: action !== null && action !== void 0 ? action : undefined,
+            frame,
+            dx,
+            dy,
+            dd,
+        };
+    }
+    _getDirectionFromElement(element) {
+        const offset = getNumberFromAttribute(element.getAttribute("offset"));
+        if (offset == null)
+            return;
+        return {
+            offset,
+        };
+    }
+    _getDirectionSpriteFromElement(element) {
+        const id = getNumberFromAttribute(element.getAttribute("id"));
+        const dz = getNumberFromAttribute(element.getAttribute("dz"));
+        const dx = getNumberFromAttribute(element.getAttribute("dx"));
+        const dy = getNumberFromAttribute(element.getAttribute("dy"));
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            dz,
+            dx,
+            dy,
+        };
+    }
+    _getEffectSpriteFromElement(element) {
+        var _a;
+        const id = element.getAttribute("id");
+        const ink = getNumberFromAttribute(element.getAttribute("ink"));
+        const member = (_a = element.getAttribute("member")) !== null && _a !== void 0 ? _a : undefined;
+        const staticY = getNumberFromAttribute(element.getAttribute("staticY"));
+        const directions = element.getAttribute("directions") === "1";
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            ink,
+            member,
+            staticY,
+            directions,
+        };
+    }
+    _getFrameBodyPartFromElement(element) {
+        var _a, _b;
+        const action = (_a = element.getAttribute("action")) !== null && _a !== void 0 ? _a : undefined;
+        const id = element.getAttribute("id");
+        const frame = getNumberFromAttribute(element.getAttribute("frame"));
+        const dx = getNumberFromAttribute(element.getAttribute("dx"));
+        const dy = getNumberFromAttribute(element.getAttribute("dy"));
+        const dd = getNumberFromAttribute(element.getAttribute("dd"));
+        const base = (_b = element.getAttribute("base")) !== null && _b !== void 0 ? _b : undefined;
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            action,
+            frame,
+            id,
+            dx,
+            dy,
+            dd,
+            base,
+        };
+    }
+}

package/dist-esm/objects/avatar/data/AvatarEffectMap.js

@@ -0,0 +1,34 @@
+export class AvatarEffectMap {
+    constructor(string) {
+        this._effects = new Map();
+        this._effectsArray = [];
+        const document = new DOMParser().parseFromString(string, "text/xml");
+        document.querySelectorAll("effect").forEach((element) => {
+            const effect = this._getEffectFromElement(element);
+            this._effects.set(effect.id, effect);
+            this._effectsArray.push(effect);
+        });
+    }
+    getEffects() {
+        return this._effectsArray;
+    }
+    getEffectInfo(id) {
+        return this._effects.get(id);
+    }
+    _getEffectFromElement(element) {
+        const id = element.getAttribute("id");
+        const lib = element.getAttribute("lib");
+        const type = element.getAttribute("type");
+        if (lib == null)
+            throw new Error("Invalid lib for effect");
+        if (type == null)
+            throw new Error("Invalid type for effect");
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            lib,
+            type,
+        };
+    }
+}

package/dist-esm/objects/avatar/data/AvatarGeometryData.js

@@ -0,0 +1,118 @@
+import { getNumberFromAttribute } from "../../../util/getNumberFromAttribute";
+import { geometryXml } from "./static/geometry.xml";
+export class AvatarGeometryData {
+    constructor(string) {
+        this._bodypartMap = new Map();
+        this._avatarSetMap = new Map();
+        this._geometries = new Map();
+        this._bodyPartItemMap = new Map();
+        const document = new DOMParser().parseFromString(string, "text/xml");
+        document
+            .querySelectorAll(`canvas[scale="h"] geometry`)
+            .forEach((element) => {
+            const geometry = this._getGeometryFromElement(element);
+            this._geometries.set(geometry.id, geometry);
+        });
+        document.querySelectorAll(`avatarset`).forEach((element) => {
+            const avatarSetId = element.getAttribute("id");
+            if (avatarSetId == null)
+                return;
+            const bodyParts = element.querySelectorAll(`bodypart`);
+            bodyParts.forEach((bodyPart) => {
+                var _a;
+                const id = bodyPart.getAttribute("id");
+                if (id != null) {
+                    const current = (_a = this._avatarSetMap.get(avatarSetId)) !== null && _a !== void 0 ? _a : [];
+                    this._avatarSetMap.set(avatarSetId, [...current, id]);
+                }
+            });
+        });
+        document.querySelectorAll(`type`).forEach((element) => {
+            const typeId = element.getAttribute("id");
+            if (typeId == null)
+                return;
+            element.querySelectorAll(`bodypart`).forEach((bodypart) => {
+                const bodyPart = this._getBodyPartFromElement(bodypart);
+                if (bodyPart == null)
+                    return;
+                const bodyPartItems = [];
+                bodypart.querySelectorAll(`item`).forEach((item) => {
+                    const bodyPartItem = this._getBodyPartItemFromElement(item);
+                    if (bodyPartItem != null) {
+                        bodyPartItems.push(bodyPartItem);
+                        this._bodyPartItemMap.set(`${typeId}_${bodyPart.id}_${bodyPartItem.id}`, bodyPartItem);
+                    }
+                });
+                this._bodypartMap.set(`${typeId}_${bodyPart.id}`, {
+                    ...bodyPart,
+                    items: bodyPartItems,
+                });
+            });
+        });
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarGeometryData(text);
+    }
+    static default() {
+        return new AvatarGeometryData(atob(geometryXml));
+    }
+    getBodyPartItem(geometry, bodyPartId, itemId) {
+        return this._bodyPartItemMap.get(`${geometry}_${bodyPartId}_${itemId}`);
+    }
+    getBodyPart(geometry, bodyPartId) {
+        return this._bodypartMap.get(`${geometry}_${bodyPartId}`);
+    }
+    getBodyParts(avaterSet) {
+        var _a;
+        return (_a = this._avatarSetMap.get(avaterSet)) !== null && _a !== void 0 ? _a : [];
+    }
+    getGeometry(geometry) {
+        return this._geometries.get(geometry);
+    }
+    _getGeometryFromElement(element) {
+        const id = element.getAttribute("id");
+        const width = Number(element.getAttribute("width"));
+        const height = Number(element.getAttribute("height"));
+        const dx = Number(element.getAttribute("dx"));
+        const dy = Number(element.getAttribute("dy"));
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            width,
+            height,
+            dx,
+            dy,
+        };
+    }
+    _getBodyPartFromElement(item) {
+        const id = item.getAttribute("id");
+        const z = Number(item.getAttribute("z"));
+        if (id == null)
+            return;
+        if (isNaN(z))
+            return;
+        return {
+            id,
+            z,
+        };
+    }
+    _getBodyPartItemFromElement(item) {
+        const id = item.getAttribute("id");
+        const z = getNumberFromAttribute(item.getAttribute("z"));
+        const radius = getNumberFromAttribute(item.getAttribute("radius"));
+        if (id == null)
+            return;
+        if (z == null)
+            return;
+        if (radius == null)
+            return;
+        return {
+            id,
+            z,
+            radius,
+        };
+    }
+}

package/dist-esm/objects/avatar/data/AvatarManifestData.js

@@ -0,0 +1,51 @@
+import { AvatarData } from "./AvatarData";
+export class AvatarManifestData extends AvatarData {
+    constructor(xml) {
+        super(xml);
+        this._assets = [];
+        this._assetbyName = new Map();
+        this._aliases = [];
+        this._cacheData();
+    }
+    getAliases() {
+        return this._aliases;
+    }
+    getAssets() {
+        return this._assets;
+    }
+    getAssetByName(name) {
+        return this._assetbyName.get(name);
+    }
+    _cacheData() {
+        const assets = this.querySelectorAll(`assets asset`);
+        const aliases = this.querySelectorAll(`aliases alias`);
+        for (const asset of assets) {
+            const offsetParam = asset.querySelector(`param[key="offset"]`);
+            const value = offsetParam === null || offsetParam === void 0 ? void 0 : offsetParam.getAttribute("value");
+            const name = asset.getAttribute("name");
+            if (value != null && name != null) {
+                const offsets = value.split(",");
+                const x = Number(offsets[0]);
+                const y = Number(offsets[1]);
+                const asset = { name, x, y, flipH: false, flipV: false };
+                this._assets.push(asset);
+                this._assetbyName.set(name, asset);
+            }
+        }
+        for (const alias of aliases) {
+            const name = alias.getAttribute("name");
+            const link = alias.getAttribute("link");
+            const fliph = alias.getAttribute("fliph") === "1";
+            const flipv = alias.getAttribute("flipv") === "1";
+            if (name != null && link != null) {
+                const alias = {
+                    name,
+                    link,
+                    fliph,
+                    flipv,
+                };
+                this._aliases.push(alias);
+            }
+        }
+    }
+}

package/dist-esm/objects/avatar/data/AvatarOffsetsData.js

@@ -0,0 +1,13 @@
+export class AvatarOffsetsData {
+    constructor(_json) {
+        this._json = _json;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const json = await response.json();
+        return new AvatarOffsetsData(json);
+    }
+    getOffsets(fileName) {
+        return this._json[fileName];
+    }
+}

package/dist-esm/objects/avatar/data/AvatarPartSetsData.js

@@ -0,0 +1,34 @@
+import { AvatarData } from "./AvatarData";
+import { partsetsXml } from "./static/partsets.xml";
+export class AvatarPartSetsData extends AvatarData {
+    constructor(xml) {
+        super(xml);
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarPartSetsData(text);
+    }
+    static default() {
+        return new AvatarPartSetsData(atob(partsetsXml));
+    }
+    getPartInfo(id) {
+        var _a, _b;
+        const element = this.querySelector(`partSet part[set-type="${id}"]`);
+        if (element == null)
+            return;
+        return {
+            flippedSetType: (_a = element.getAttribute("flipped-set-type")) !== null && _a !== void 0 ? _a : undefined,
+            removeSetType: (_b = element.getAttribute("remove-set-type")) !== null && _b !== void 0 ? _b : undefined,
+        };
+    }
+    getActivePartSet(id) {
+        const partSet = this.querySelectorAll(`activePartSet[id="${id}"] activePart`);
+        return new Set(partSet.map((value) => {
+            const setType = value.getAttribute("set-type");
+            if (setType == null)
+                throw new Error("Invalid set type");
+            return setType;
+        }));
+    }
+}

package/dist-esm/objects/avatar/data/FigureData.js

@@ -0,0 +1,102 @@
+import { AvatarData } from "./AvatarData";
+const _getColorKey = (paletteId, colorId) => {
+    return `${paletteId}_${colorId}`;
+};
+const _getPartsKey = (setType, id) => {
+    return `${setType}_${id}`;
+};
+export class FigureData extends AvatarData {
+    constructor(xml) {
+        super(xml);
+        this._parts = new Map();
+        this._paletteIdForSetType = new Map();
+        this._colors = new Map();
+        this._hiddenLayers = new Map();
+        this._cacheData();
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new FigureData(text);
+    }
+    getColor(setType, colorId) {
+        const paletteId = this._paletteIdForSetType.get(setType);
+        if (paletteId == null)
+            return;
+        return this._colors.get(_getColorKey(paletteId, colorId));
+    }
+    getParts(setType, id) {
+        return this._parts.get(_getPartsKey(setType, id));
+    }
+    getHiddenLayers(setType, id) {
+        var _a;
+        return (_a = this._hiddenLayers.get(_getPartsKey(setType, id))) !== null && _a !== void 0 ? _a : [];
+    }
+    _cacheData() {
+        const setTypes = this.querySelectorAll("sets settype");
+        const palettes = this.querySelectorAll("colors palette");
+        palettes.forEach((palette) => {
+            const paletteId = palette.getAttribute("id");
+            if (paletteId == null)
+                return;
+            const colors = Array.from(palette.querySelectorAll("color"));
+            colors.forEach((color) => {
+                const colorId = color.getAttribute("id");
+                if (colorId != null) {
+                    this._colors.set(_getColorKey(paletteId, colorId), color.innerHTML);
+                }
+            });
+        });
+        setTypes.forEach((element) => {
+            const setType = element.getAttribute("type");
+            const paletteId = element.getAttribute("paletteid");
+            const sets = this.querySelectorAll("set");
+            if (setType == null)
+                return;
+            if (paletteId != null) {
+                this._paletteIdForSetType.set(setType, paletteId);
+            }
+            sets.forEach((set) => {
+                const setId = set.getAttribute("id");
+                if (setId == null)
+                    return;
+                const parts = Array.from(set.querySelectorAll("part"));
+                const partArr = [];
+                const hiddenLayers = [];
+                set
+                    .querySelectorAll(`hiddenlayers layer`)
+                    .forEach((hiddenLayerElement) => {
+                    const partType = hiddenLayerElement.getAttribute("parttype");
+                    if (partType != null) {
+                        hiddenLayers.push(partType);
+                    }
+                });
+                this._hiddenLayers.set(_getPartsKey(setType, setId), hiddenLayers);
+                parts
+                    .map((part) => {
+                    const id = part.getAttribute("id");
+                    const type = part.getAttribute("type");
+                    const colorable = part.getAttribute("colorable");
+                    let index = Number(part.getAttribute("index"));
+                    if (isNaN(index)) {
+                        index = 0;
+                    }
+                    if (id == null)
+                        throw new Error("Invalid id");
+                    if (type == null)
+                        throw new Error("Invalid type");
+                    return {
+                        id,
+                        type,
+                        colorable: colorable === "1" ? true : false,
+                        index,
+                    };
+                })
+                    .forEach((part) => {
+                    partArr.push(part);
+                });
+                this._parts.set(_getPartsKey(setType, setId), partArr);
+            });
+        });
+    }
+}