@caspertech/node-metaverse 0.7.50 → 0.7.52

package/dist/lib/classes/Caps.d.ts

@@ -1,23 +1,21 @@
 import { EventQueueClient } from './EventQueueClient';
-import { UUID } from './UUID';
-import { ClientEvents } from './ClientEvents';
-import { Agent } from './Agent';
-import { ICapResponse } from './interfaces/ICapResponse';
-import { HTTPAssets } from '../enums/HTTPAssets';
+import type { UUID } from './UUID';
+import type { ClientEvents } from './ClientEvents';
+import type { Agent } from './Agent';
+import type { ICapResponse } from './interfaces/ICapResponse';
+import { AssetType } from '../enums/AssetType';
 export declare class Caps {
-    static CAP_INVOCATION_DELAY_MS: {
-        [key: string]: number;
-    };
-    private onGotSeedCap;
+    eventQueueClient: EventQueueClient | null;
+    private static readonly CAP_INVOCATION_DELAY_MS;
+    private readonly onGotSeedCap;
     private gotSeedCap;
     private capabilities;
-    private clientEvents;
-    private agent;
+    private readonly clientEvents;
+    private readonly agent;
     private active;
     private timeLastCapExecuted;
-    eventQueueClient: EventQueueClient | null;
     constructor(agent: Agent, seedURL: string, clientEvents: ClientEvents);
-    downloadAsset(uuid: UUID, type: HTTPAssets): Promise<Buffer>;
+    downloadAsset(uuid: UUID, type: AssetType): Promise<Buffer>;
     requestPost(capURL: string, data: string | Buffer, contentType: string): Promise<{
         status: number;
         body: string;
@@ -25,22 +23,18 @@ export declare class Caps {
     requestPut(capURL: string, data: string | Buffer, contentType: string): Promise<ICapResponse>;
     requestGet(requestURL: string): Promise<ICapResponse>;
     requestDelete(requestURL: string): Promise<ICapResponse>;
-    waitForSeedCapability(): Promise<void>;
     isCapAvailable(capability: string): Promise<boolean>;
     getCapability(capability: string): Promise<string>;
     capsRequestUpload(capURL: string, data: Buffer): Promise<any>;
-    private waitForCapTimeout;
     capsPerformXMLPost(capURL: string, data: any): Promise<any>;
     capsPerformXMLPut(capURL: string, data: any): Promise<any>;
     capsPerformXMLGet(capURL: string): Promise<any>;
-    capsGetXML(capability: string | [string, {
-        [key: string]: string;
-    }]): Promise<any>;
-    capsPostXML(capability: string | [string, {
-        [key: string]: string;
-    }], data: any): Promise<any>;
-    capsPutXML(capability: string | [string, {
-        [key: string]: string;
-    }], data: any): Promise<any>;
+    capsPerformGet(capURL: string): Promise<string>;
+    capsGetXML(capability: string | [string, Record<string, string>]): Promise<any>;
+    capsGetString(capability: string | [string, Record<string, string>]): Promise<string>;
+    capsPostXML(capability: string | [string, Record<string, string>], data: any): Promise<any>;
+    capsPutXML(capability: string | [string, Record<string, string>], data: any): Promise<any>;
     shutdown(): void;
+    waitForSeedCapability(): Promise<void>;
+    private waitForCapTimeout;
 }

package/dist/lib/classes/Caps.js

@@ -1,29 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Caps = void 0;
 const EventQueueClient_1 = require("./EventQueueClient");
 const rxjs_1 = require("rxjs");
-const HTTPAssets_1 = require("../enums/HTTPAssets");
 const LLSD = require("@caspertech/llsd");
 const url = require("url");
 const got_1 = require("got");
+const AssetType_1 = require("../enums/AssetType");
+const AssetTypeRegistry_1 = require("./AssetTypeRegistry");
 class Caps {
     constructor(agent, seedURL, clientEvents) {
+        this.eventQueueClient = null;
         this.onGotSeedCap = new rxjs_1.Subject();
         this.gotSeedCap = false;
         this.capabilities = {};
         this.active = false;
         this.timeLastCapExecuted = {};
-        this.eventQueueClient = null;
         this.agent = agent;
         this.clientEvents = clientEvents;
         const req = [];
@@ -143,9 +135,9 @@ class Caps {
             this.capabilities = LLSD.LLSD.parseXML(resp.body);
             this.gotSeedCap = true;
             this.onGotSeedCap.next();
-            if (this.capabilities['EventQueueGet']) {
+            if (this.capabilities.EventQueueGet) {
                 if (this.eventQueueClient !== null) {
-                    this.eventQueueClient.shutdown();
+                    void this.eventQueueClient.shutdown();
                 }
                 this.eventQueueClient = new EventQueueClient_1.EventQueueClient(this.agent, this, this.clientEvents);
             }
@@ -154,77 +146,288 @@ class Caps {
             console.error(err);
         });
     }
-    downloadAsset(uuid, type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (type === HTTPAssets_1.HTTPAssets.ASSET_LSL_TEXT || type === HTTPAssets_1.HTTPAssets.ASSET_NOTECARD) {
-                throw new Error('Invalid Syntax');
-            }
-            const capURL = yield this.getCapability('ViewerAsset');
-            const assetURL = capURL + '/?' + type + '_id=' + uuid.toString();
-            const response = yield got_1.default.get(assetURL, {
-                https: {
-                    rejectUnauthorized: false,
-                },
-                method: 'GET',
-                responseType: 'buffer'
-            });
-            if (response.statusCode < 200 || response.statusCode > 299) {
-                throw new Error(response.body.toString('utf-8'));
-            }
-            return response.body;
+    async downloadAsset(uuid, type) {
+        if (type === AssetType_1.AssetType.LSLText || type === AssetType_1.AssetType.Notecard) {
+            throw new Error('Invalid Syntax');
+        }
+        const capURL = await this.getCapability('ViewerAsset');
+        const assetURL = capURL + '/?' + AssetTypeRegistry_1.AssetTypeRegistry.getTypeName(type) + '_id=' + uuid.toString();
+        const response = await got_1.default.get(assetURL, {
+            https: {
+                rejectUnauthorized: false,
+            },
+            method: 'GET',
+            responseType: 'buffer'
         });
+        if (response.statusCode < 200 || response.statusCode > 299) {
+            throw new Error(response.body.toString('utf-8'));
+        }
+        return response.body;
     }
-    requestPost(capURL, data, contentType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield got_1.default.post(capURL, {
-                headers: {
-                    'Content-Length': String(Buffer.byteLength(data)),
-                    'Content-Type': contentType
-                },
-                body: data,
-                https: {
-                    rejectUnauthorized: false,
-                },
-            });
-            return { status: response.statusCode, body: response.body };
+    async requestPost(capURL, data, contentType) {
+        const response = await got_1.default.post(capURL, {
+            headers: {
+                'Content-Length': String(Buffer.byteLength(data)),
+                'Content-Type': contentType
+            },
+            body: data,
+            https: {
+                rejectUnauthorized: false,
+            },
         });
+        return { status: response.statusCode, body: response.body };
     }
-    requestPut(capURL, data, contentType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield got_1.default.put(capURL, {
-                headers: {
-                    'Content-Length': String(Buffer.byteLength(data)),
-                    'Content-Type': contentType
-                },
-                body: data,
-                https: {
-                    rejectUnauthorized: false,
-                },
-            });
-            return { status: response.statusCode, body: response.body };
+    async requestPut(capURL, data, contentType) {
+        const response = await got_1.default.put(capURL, {
+            headers: {
+                'Content-Length': String(Buffer.byteLength(data)),
+                'Content-Type': contentType
+            },
+            body: data,
+            https: {
+                rejectUnauthorized: false,
+            },
         });
+        return { status: response.statusCode, body: response.body };
     }
-    requestGet(requestURL) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield got_1.default.get(requestURL, {
-                https: {
-                    rejectUnauthorized: false,
-                },
-            });
-            return { status: response.statusCode, body: response.body };
+    async requestGet(requestURL) {
+        const response = await got_1.default.get(requestURL, {
+            https: {
+                rejectUnauthorized: false,
+            },
         });
+        return { status: response.statusCode, body: response.body };
     }
-    requestDelete(requestURL) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield got_1.default.delete(requestURL, {
-                https: {
-                    rejectUnauthorized: false,
-                },
-            });
-            return { status: response.statusCode, body: response.body };
+    async requestDelete(requestURL) {
+        const response = await got_1.default.delete(requestURL, {
+            https: {
+                rejectUnauthorized: false,
+            },
         });
+        return { status: response.statusCode, body: response.body };
+    }
+    async isCapAvailable(capability) {
+        await this.waitForSeedCapability();
+        return (this.capabilities[capability] !== undefined);
+    }
+    async getCapability(capability) {
+        if (!this.active) {
+            throw new Error('Requesting getCapability to an inactive Caps instance');
+        }
+        await this.waitForSeedCapability();
+        if (this.capabilities[capability] !== undefined) {
+            return this.capabilities[capability];
+        }
+        throw new Error('Capability ' + capability + ' not available');
+    }
+    async capsRequestUpload(capURL, data) {
+        const resp = await this.requestPost(capURL, data, 'application/octet-stream');
+        try {
+            return LLSD.LLSD.parseXML(resp.body);
+        }
+        catch (err) {
+            if (resp.status === 201) {
+                return resp.body;
+            }
+            else if (resp.status === 403) {
+                throw new Error('Access Denied');
+            }
+            throw (err);
+        }
+    }
+    async capsPerformXMLPost(capURL, data) {
+        const xml = LLSD.LLSD.formatXML(data);
+        const resp = await this.requestPost(capURL, xml, 'application/llsd+xml');
+        try {
+            return LLSD.LLSD.parseXML(resp.body);
+        }
+        catch (_err) {
+            if (resp.status === 201) {
+                return {};
+            }
+            else if (resp.status === 403) {
+                throw new Error('Access Denied');
+            }
+            else if (resp.status === 404) {
+                throw new Error('Not found');
+            }
+            else {
+                throw resp.body;
+            }
+        }
     }
-    waitForSeedCapability() {
+    async capsPerformXMLPut(capURL, data) {
+        const xml = LLSD.LLSD.formatXML(data);
+        const resp = await this.requestPut(capURL, xml, 'application/llsd+xml');
+        try {
+            return LLSD.LLSD.parseXML(resp.body);
+        }
+        catch (err) {
+            if (resp.status === 201) {
+                return {};
+            }
+            else if (resp.status === 403) {
+                throw new Error('Access Denied');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async capsPerformXMLGet(capURL) {
+        const resp = await this.requestGet(capURL);
+        try {
+            return LLSD.LLSD.parseXML(resp.body);
+        }
+        catch (err) {
+            if (resp.status === 201) {
+                return {};
+            }
+            else if (resp.status === 403) {
+                throw new Error('Access Denied');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async capsPerformGet(capURL) {
+        const resp = await this.requestGet(capURL);
+        try {
+            return resp.body;
+        }
+        catch (err) {
+            if (resp.status === 201) {
+                return '';
+            }
+            else if (resp.status === 403) {
+                throw new Error('Access Denied');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async capsGetXML(capability) {
+        let capName = '';
+        let queryParams = {};
+        if (typeof capability === 'string') {
+            capName = capability;
+        }
+        else {
+            capName = capability[0];
+            queryParams = capability[1];
+        }
+        await this.waitForCapTimeout(capName);
+        let capURL = await this.getCapability(capName);
+        if (Object.keys(queryParams).length > 0) {
+            const parsedURL = url.parse(capURL, true);
+            for (const key of Object.keys(queryParams)) {
+                parsedURL.query[key] = queryParams[key];
+            }
+            capURL = url.format(parsedURL);
+        }
+        try {
+            return await this.capsPerformXMLGet(capURL);
+        }
+        catch (error) {
+            console.log('Error with cap ' + capName);
+            console.log(error);
+            throw error;
+        }
+    }
+    async capsGetString(capability) {
+        let capName = '';
+        let queryParams = {};
+        if (typeof capability === 'string') {
+            capName = capability;
+        }
+        else {
+            capName = capability[0];
+            queryParams = capability[1];
+        }
+        await this.waitForCapTimeout(capName);
+        let capURL = await this.getCapability(capName);
+        if (Object.keys(queryParams).length > 0) {
+            const parsedURL = url.parse(capURL, true);
+            for (const key of Object.keys(queryParams)) {
+                parsedURL.query[key] = queryParams[key];
+            }
+            capURL = url.format(parsedURL);
+        }
+        try {
+            return await this.capsPerformGet(capURL);
+        }
+        catch (error) {
+            console.log('Error with cap ' + capName);
+            console.log(error);
+            throw error;
+        }
+    }
+    async capsPostXML(capability, data) {
+        let capName = '';
+        let queryParams = {};
+        if (typeof capability === 'string') {
+            capName = capability;
+        }
+        else {
+            capName = capability[0];
+            queryParams = capability[1];
+        }
+        await this.waitForCapTimeout(capName);
+        let capURL = await this.getCapability(capName);
+        if (Object.keys(queryParams).length > 0) {
+            const parsedURL = url.parse(capURL, true);
+            for (const key of Object.keys(queryParams)) {
+                parsedURL.query[key] = queryParams[key];
+            }
+            capURL = url.format(parsedURL);
+        }
+        try {
+            return await this.capsPerformXMLPost(capURL, data);
+        }
+        catch (error) {
+            console.log('Error with cap ' + capName);
+            console.log(error);
+            throw error;
+        }
+    }
+    async capsPutXML(capability, data) {
+        let capName = '';
+        let queryParams = {};
+        if (typeof capability === 'string') {
+            capName = capability;
+        }
+        else {
+            capName = capability[0];
+            queryParams = capability[1];
+        }
+        await this.waitForCapTimeout(capName);
+        let capURL = await this.getCapability(capName);
+        if (Object.keys(queryParams).length > 0) {
+            const parsedURL = url.parse(capURL, true);
+            for (const key of Object.keys(queryParams)) {
+                parsedURL.query[key] = queryParams[key];
+            }
+            capURL = url.format(parsedURL);
+        }
+        try {
+            return await this.capsPerformXMLPut(capURL, data);
+        }
+        catch (error) {
+            console.log('Error with cap ' + capName);
+            console.log(error);
+            throw error;
+        }
+    }
+    shutdown() {
+        this.onGotSeedCap.complete();
+        if (this.eventQueueClient) {
+            void this.eventQueueClient.shutdown();
+        }
+        this.active = false;
+    }
+    async waitForSeedCapability() {
         return new Promise((resolve) => {
             if (this.gotSeedCap) {
                 resolve();
@@ -237,52 +440,7 @@ class Caps {
             }
         });
     }
-    isCapAvailable(capability) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForSeedCapability();
-            return (this.capabilities[capability] !== undefined);
-        });
-    }
-    getCapability(capability) {
-        return new Promise((resolve, reject) => {
-            if (!this.active) {
-                reject(new Error('Requesting getCapability to an inactive Caps instance'));
-                return;
-            }
-            this.waitForSeedCapability().then(() => {
-                if (this.capabilities[capability]) {
-                    resolve(this.capabilities[capability]);
-                }
-                else {
-                    reject(new Error('Capability ' + capability + ' not available'));
-                }
-            });
-        });
-    }
-    capsRequestUpload(capURL, data) {
-        return new Promise((resolve, reject) => {
-            this.requestPost(capURL, data, 'application/octet-stream').then((resp) => {
-                try {
-                    resolve(LLSD.LLSD.parseXML(resp.body));
-                }
-                catch (err) {
-                    if (resp.status === 201) {
-                        resolve({});
-                    }
-                    else if (resp.status === 403) {
-                        reject(new Error('Access Denied'));
-                    }
-                    else {
-                        reject(err);
-                    }
-                }
-            }).catch((err) => {
-                console.error(err);
-                reject(err);
-            });
-        });
-    }
-    waitForCapTimeout(capName) {
+    async waitForCapTimeout(capName) {
         return new Promise((resolve) => {
             if (!Caps.CAP_INVOCATION_DELAY_MS[capName]) {
                 resolve();
@@ -306,183 +464,6 @@ class Caps {
             }
         });
     }
-    capsPerformXMLPost(capURL, data) {
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            const xml = LLSD.LLSD.formatXML(data);
-            this.requestPost(capURL, xml, 'application/llsd+xml').then((resp) => __awaiter(this, void 0, void 0, function* () {
-                let result = null;
-                try {
-                    result = LLSD.LLSD.parseXML(resp.body);
-                    resolve(result);
-                }
-                catch (err) {
-                    if (resp.status === 201) {
-                        resolve({});
-                    }
-                    else if (resp.status === 403) {
-                        reject(new Error('Access Denied'));
-                    }
-                    else if (resp.status === 404) {
-                        reject(new Error('Not found'));
-                    }
-                    else {
-                        reject(resp.body);
-                    }
-                }
-            })).catch((err) => {
-                console.error(err);
-                reject(err);
-            });
-        }));
-    }
-    capsPerformXMLPut(capURL, data) {
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            const xml = LLSD.LLSD.formatXML(data);
-            this.requestPut(capURL, xml, 'application/llsd+xml').then((resp) => {
-                let result = null;
-                try {
-                    result = LLSD.LLSD.parseXML(resp.body);
-                    resolve(result);
-                }
-                catch (err) {
-                    if (resp.status === 201) {
-                        resolve({});
-                    }
-                    else if (resp.status === 403) {
-                        reject(new Error('Access Denied'));
-                    }
-                    else {
-                        reject(err);
-                    }
-                }
-            }).catch((err) => {
-                console.error(err);
-                reject(err);
-            });
-        }));
-    }
-    capsPerformXMLGet(capURL) {
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            this.requestGet(capURL).then((resp) => {
-                let result = null;
-                try {
-                    result = LLSD.LLSD.parseXML(resp.body);
-                    resolve(result);
-                }
-                catch (err) {
-                    if (resp.status === 201) {
-                        resolve({});
-                    }
-                    else if (resp.status === 403) {
-                        reject(new Error('Access Denied'));
-                    }
-                    else {
-                        reject(err);
-                    }
-                }
-            }).catch((err) => {
-                console.error(err);
-                reject(err);
-            });
-        }));
-    }
-    capsGetXML(capability) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let capName = '';
-            let queryParams = {};
-            if (typeof capability === 'string') {
-                capName = capability;
-            }
-            else {
-                capName = capability[0];
-                queryParams = capability[1];
-            }
-            yield this.waitForCapTimeout(capName);
-            let capURL = yield this.getCapability(capName);
-            if (Object.keys(queryParams).length > 0) {
-                const parsedURL = url.parse(capURL, true);
-                for (const key of Object.keys(queryParams)) {
-                    parsedURL.query[key] = queryParams[key];
-                }
-                capURL = url.format(parsedURL);
-            }
-            try {
-                return yield this.capsPerformXMLGet(capURL);
-            }
-            catch (error) {
-                console.log('Error with cap ' + capName);
-                console.log(error);
-                throw error;
-            }
-        });
-    }
-    capsPostXML(capability, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let capName = '';
-            let queryParams = {};
-            if (typeof capability === 'string') {
-                capName = capability;
-            }
-            else {
-                capName = capability[0];
-                queryParams = capability[1];
-            }
-            yield this.waitForCapTimeout(capName);
-            let capURL = yield this.getCapability(capName);
-            if (Object.keys(queryParams).length > 0) {
-                const parsedURL = url.parse(capURL, true);
-                for (const key of Object.keys(queryParams)) {
-                    parsedURL.query[key] = queryParams[key];
-                }
-                capURL = url.format(parsedURL);
-            }
-            try {
-                return yield this.capsPerformXMLPost(capURL, data);
-            }
-            catch (error) {
-                console.log('Error with cap ' + capName);
-                console.log(error);
-                throw error;
-            }
-        });
-    }
-    capsPutXML(capability, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let capName = '';
-            let queryParams = {};
-            if (typeof capability === 'string') {
-                capName = capability;
-            }
-            else {
-                capName = capability[0];
-                queryParams = capability[1];
-            }
-            yield this.waitForCapTimeout(capName);
-            let capURL = yield this.getCapability(capName);
-            if (Object.keys(queryParams).length > 0) {
-                const parsedURL = url.parse(capURL, true);
-                for (const key of Object.keys(queryParams)) {
-                    parsedURL.query[key] = queryParams[key];
-                }
-                capURL = url.format(parsedURL);
-            }
-            try {
-                return yield this.capsPerformXMLPut(capURL, data);
-            }
-            catch (error) {
-                console.log('Error with cap ' + capName);
-                console.log(error);
-                throw error;
-            }
-        });
-    }
-    shutdown() {
-        this.onGotSeedCap.complete();
-        if (this.eventQueueClient) {
-            this.eventQueueClient.shutdown();
-        }
-        this.active = false;
-    }
 }
 exports.Caps = Caps;
 Caps.CAP_INVOCATION_DELAY_MS = {