@rsdoctor/core 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/sdk/server/index.js

@@ -0,0 +1,292 @@
+import "node:module";
+import { Client, SDK } from "@rsdoctor/shared/types";
+import { Server } from "../../build-utils/index.js";
+import sirv from "sirv";
+import { Bundle, GlobalConfig } from "../../common/index.js";
+import assert from "assert";
+import cors from "cors";
+import { PassThrough } from "stream";
+import { Socket } from "./socket/index.js";
+import { Router } from "./router.js";
+import * as __rspack_external__apis_index_js_275823d6 from "./apis/index.js";
+import { chalk, logger } from "../../logger.js";
+import { openBrowser } from "../utils/openBrowser.js";
+import path from "path";
+import { createRequire } from "module";
+import { randomBytes } from "crypto";
+import { jsonBodyParser } from "./json-body.js";
+import { DEFAULT_ALLOWED_CORS_ORIGINS, isAllowedCorsRequest, isAllowedOpenInEditorToken, isAllowedRequestHost } from "./security.js";
+export * from "./utils.js";
+const server_require = createRequire(import.meta.url);
+const OPEN_IN_EDITOR_PATH = '/__open-in-editor';
+const LISTEN_RETRY_LIMIT = 10;
+const OPEN_IN_EDITOR_EDITORS = new Set(SDK.OPEN_IN_EDITOR_EDITORS);
+const DEFAULT_JSON_BODY_LIMIT = '10mb';
+const LARGE_JSON_BODY_LIMIT = '500mb';
+const LARGE_JSON_BODY_ROUTES = new Set([
+    SDK.ServerAPI.API.ReportLoader,
+    SDK.ServerAPI.API.ReportSourceMap
+]);
+function isAddressInUseError(error) {
+    return 'EADDRINUSE' === error.code;
+}
+function isAllowedOpenInEditorEditor(editor) {
+    return 'string' == typeof editor && OPEN_IN_EDITOR_EDITORS.has(editor);
+}
+class RsdoctorServer {
+    get app() {
+        return this._server.app;
+    }
+    get host() {
+        return Server.defaultHost;
+    }
+    get origin() {
+        return `http://${this.host}:${this.port}`;
+    }
+    get socketUrl() {
+        return {
+            port: this.port,
+            socketUrl: `ws://localhost:${this.port}?token=${this._socketToken}`,
+            token: this._socketToken
+        };
+    }
+    get innerClientPath() {
+        return this._innerClientPath;
+    }
+    async createInnerServer() {
+        let expectedPort = this.port;
+        let lastError;
+        for(let retry = 0; retry < LISTEN_RETRY_LIMIT; retry++){
+            const port = Server.getPortSync(expectedPort, this.host);
+            try {
+                return {
+                    port,
+                    server: await Server.createServer(port, this.host)
+                };
+            } catch (error) {
+                if (!isAddressInUseError(error)) throw error;
+                lastError = error;
+                expectedPort = port + 1;
+            }
+        }
+        throw lastError;
+    }
+    resolveCorsOptions() {
+        if (false === this._cors) return false;
+        if (true === this._cors) return {};
+        if (void 0 === this._cors) return {
+            origin: DEFAULT_ALLOWED_CORS_ORIGINS
+        };
+        return {
+            ...this._cors,
+            origin: void 0 === this._cors.origin ? DEFAULT_ALLOWED_CORS_ORIGINS : this._cors.origin
+        };
+    }
+    async bootstrap() {
+        if (!this.disposed) return;
+        const { port, server } = await this.createInnerServer();
+        const corsOptions = this.resolveCorsOptions();
+        this.port = port;
+        this._server = server;
+        this._socket = new Socket({
+            sdk: this.sdk,
+            server: this._server.server,
+            port: this.port,
+            token: this._socketToken
+        });
+        await this._socket.bootstrap();
+        GlobalConfig.writeMcpPort(this.port, this.sdk.name);
+        logger.debug(`Successfully wrote mcp.json for ${chalk.cyan(this.sdk.name)} builder`);
+        this.disposed = false;
+        this.app.use((req, res, next)=>{
+            const host = req.headers.host || req.headers[':authority'];
+            if (!isAllowedRequestHost(host)) {
+                res.statusCode = 403;
+                res.end();
+                return;
+            }
+            next();
+        });
+        if (false !== corsOptions && corsOptions.origin === DEFAULT_ALLOWED_CORS_ORIGINS) this.app.use((req, res, next)=>{
+            const host = req.headers.host || req.headers[':authority'];
+            if (!isAllowedCorsRequest(req.headers.origin, host)) {
+                res.statusCode = 403;
+                res.end();
+                return;
+            }
+            next();
+        });
+        if (false !== corsOptions) this.app.use(cors(corsOptions));
+        this.app.use(jsonBodyParser({
+            limit: (req)=>{
+                const pathname = new URL(req.url || '/', 'http://localhost').pathname;
+                return LARGE_JSON_BODY_ROUTES.has(pathname) ? LARGE_JSON_BODY_LIMIT : DEFAULT_JSON_BODY_LIMIT;
+            }
+        }));
+        await this._router.setup();
+        const clientHtmlPath = this._innerClientPath ? this._innerClientPath : server_require.resolve('@rsdoctor/client');
+        const clientDistPath = path.resolve(clientHtmlPath, '..');
+        this.app.use(sirv(clientDistPath, {
+            dev: true
+        }));
+        this.app.use(OPEN_IN_EDITOR_PATH, (req, res, next)=>{
+            if ('GET' !== req.method && 'HEAD' !== req.method) return next();
+            const url = new URL(req.url || '', "http://localhost");
+            const file = url.searchParams.get('file');
+            const editor = url.searchParams.get('editor');
+            const token = url.searchParams.get('token');
+            if (!isAllowedOpenInEditorToken(token, this._socketToken)) {
+                res.statusCode = 403;
+                res.end();
+                return;
+            }
+            if (!file) {
+                res.statusCode = 400;
+                res.end('Missing file parameter');
+                return;
+            }
+            if (!isAllowedOpenInEditorEditor(editor)) {
+                res.statusCode = 400;
+                res.end('Unsupported editor parameter');
+                return;
+            }
+            try {
+                const launch = server_require('launch-editor');
+                let responded = false;
+                const safeEnd = (code, body)=>{
+                    if (responded) return;
+                    responded = true;
+                    res.statusCode = code;
+                    res.end(body);
+                };
+                launch(file, editor, (_fileName, errorMessage)=>{
+                    if (errorMessage) safeEnd(500, errorMessage);
+                });
+                setTimeout(()=>{
+                    safeEnd(200, '');
+                }, 200);
+            } catch (err) {
+                if (!res.writableEnded) {
+                    res.statusCode = 500;
+                    res.end(err.message);
+                }
+            }
+        });
+        process.once('exit', ()=>this.dispose());
+        process.once('SIGINT', ()=>this.dispose(0));
+        process.once('SIGTERM', ()=>this.dispose(0));
+        process.once('unhandledRejection', (reason)=>{
+            console.error('Unhandled promise rejection:', reason);
+            this.dispose(1);
+        });
+        process.once('uncaughtException', (err, origin)=>{
+            console.error('Uncaught exception:', err);
+            if (origin) console.error('Exception origin:', origin);
+            this.dispose(1);
+        });
+    }
+    wrapNextHandleFunction(method, cb) {
+        return async (req, res, next)=>{
+            const m = req.method?.toUpperCase();
+            if (m === method) {
+                try {
+                    const body = await cb(req, res, next);
+                    res.statusCode = 200;
+                    if (Buffer.isBuffer(body)) {
+                        res.setHeader('Content-Length', body.byteLength);
+                        const ps = new PassThrough();
+                        ps.write(body);
+                        ps.end();
+                        ps.pipe(res);
+                    } else if (body && 'object' == typeof body) {
+                        res.writeHead(200, {
+                            'Content-Type': 'application/json;utf-8'
+                        });
+                        res.write(JSON.stringify(body));
+                        res.end();
+                    } else res.writeHead(200).end(body);
+                } catch (error) {
+                    res.statusCode = 500;
+                    res.end(error.message);
+                    return next(error);
+                }
+                return;
+            }
+            await next();
+        };
+    }
+    proxy(api, method, cb) {
+        let idx = this.app.stack.findIndex((e)=>e.route === api);
+        if (-1 === idx) idx = this.app.stack.length - 1;
+        this.app.stack.splice(idx, 0, {
+            route: api,
+            handle: this.wrapNextHandleFunction(method, cb)
+        });
+    }
+    getClientUrl(route = 'homepage', ...args) {
+        const relativeUrl = SDK.ServerAPI.API.EntryHtml;
+        switch(route){
+            case Client.RsdoctorClientRoutes.BundleDiff:
+                {
+                    const [baseline, current] = args;
+                    const qs = Bundle.getBundleDiffPageQueryString([
+                        baseline,
+                        current
+                    ]);
+                    return `${relativeUrl}${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
+                }
+            default:
+                return relativeUrl;
+        }
+    }
+    async openClientPage(...args) {
+        const relativeUrl = this.getClientUrl(...args);
+        const needEncodeURI = args[0] === Client.RsdoctorClientRoutes.BundleDiff;
+        const url = `http://${this.host}:${this.port}${relativeUrl}`;
+        const localhostUrl = `http://localhost:${this.port}${relativeUrl}`;
+        await openBrowser(localhostUrl, !needEncodeURI);
+        if (this._printServerUrl) logger.info(`${chalk.green(`${this.sdk.name} compiler's`)} analyzer running on: ${chalk.cyan(url)}`);
+    }
+    sendAPIDataToClient(api, msg) {
+        this._socket?.sendAPIData(api, msg);
+    }
+    async broadcast() {
+        await this._socket?.broadcast();
+    }
+    constructor(sdk, port = Server.defaultPort, config){
+        this.sdk = sdk;
+        this.disposed = true;
+        this._socketToken = randomBytes(16).toString('hex');
+        this.get = (route, cb)=>{
+            const { app } = this;
+            app.use(route, this.wrapNextHandleFunction('GET', cb));
+            return app;
+        };
+        this.post = (route, cb)=>{
+            const { app } = this;
+            app.use(route, this.wrapNextHandleFunction('POST', cb));
+            return app;
+        };
+        this.dispose = async (exitCode)=>{
+            if (this.disposed) {
+                if (void 0 !== exitCode) process.exit(exitCode);
+                return;
+            }
+            this.disposed = true;
+            if (this._server) await this._server.close();
+            if (this._socket) this._socket.dispose();
+            if (void 0 !== exitCode) process.exit(exitCode);
+        };
+        assert('number' == typeof port);
+        this.port = port;
+        this._router = new Router({
+            sdk,
+            server: this,
+            apis: Object.values(__rspack_external__apis_index_js_275823d6)
+        });
+        this._innerClientPath = config?.innerClientPath || '';
+        this._printServerUrl = config?.printServerUrl ?? true;
+        this._cors = config?.cors;
+    }
+}
+export { RsdoctorServer };

package/dist/sdk/server/json-body.d.ts

@@ -0,0 +1,6 @@
+import type { Thirdparty } from '@rsdoctor/shared/types';
+interface JsonBodyParserOptions {
+    limit?: number | string | ((req: Thirdparty.connect.IncomingMessage) => number | string);
+}
+export declare function jsonBodyParser(options?: JsonBodyParserOptions): Thirdparty.connect.NextHandleFunction;
+export {};

package/dist/sdk/server/json-body.js

@@ -0,0 +1,150 @@
+import "node:module";
+import raw_body from "raw-body";
+import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+const JSON_CONTENT_TYPE = 'application/json';
+const DEFAULT_CHARSET = 'utf-8';
+function createHttpError(status, message, type) {
+    return Object.assign(new Error(message), {
+        status,
+        statusCode: status,
+        type
+    });
+}
+function hasBody(req) {
+    return void 0 !== req.headers['transfer-encoding'] || !Number.isNaN(Number(req.headers['content-length']));
+}
+function getContentType(req) {
+    const contentType = req.headers['content-type'];
+    if ('string' != typeof contentType) return;
+    return contentType;
+}
+function shouldParse(req) {
+    const contentType = getContentType(req);
+    if (!contentType) return false;
+    return contentType.split(';', 1)[0].trim().toLowerCase() === JSON_CONTENT_TYPE;
+}
+function getCharset(req) {
+    const contentType = getContentType(req);
+    const match = contentType?.match(/(?:^|;)\s*charset\s*=\s*(?:"([^"]+)"|([^;\s]+))/i);
+    return (match?.[1] || match?.[2] || DEFAULT_CHARSET).toLowerCase();
+}
+function getContentStream(req) {
+    const contentEncoding = req.headers['content-encoding'];
+    const encoding = 'string' == typeof contentEncoding ? contentEncoding.toLowerCase() : 'identity';
+    if ('identity' === encoding) return {
+        stream: req,
+        length: req.headers['content-length']
+    };
+    let stream;
+    switch(encoding){
+        case 'gzip':
+            stream = createGunzip();
+            break;
+        case 'deflate':
+            stream = createInflate();
+            break;
+        case 'br':
+            stream = createBrotliDecompress();
+            break;
+        default:
+            throw createHttpError(415, `unsupported content encoding "${encoding}"`, 'encoding.unsupported');
+    }
+    const cleanup = ()=>{
+        req.removeListener('aborted', onAborted);
+        req.removeListener('close', onClose);
+        req.removeListener('error', onError);
+        stream.removeListener('close', cleanup);
+    };
+    const destroy = (error)=>{
+        if (!stream.destroyed) stream.destroy(error);
+    };
+    const onAborted = ()=>{
+        destroy(createHttpError(400, 'request aborted', 'request.aborted'));
+    };
+    const onClose = ()=>{
+        if (false === req.complete) onAborted();
+    };
+    const onError = (error)=>{
+        destroy(error);
+    };
+    req.once('aborted', onAborted);
+    req.once('close', onClose);
+    req.once('error', onError);
+    stream.once('close', cleanup);
+    req.pipe(stream);
+    return {
+        stream,
+        cleanup,
+        decompressor: stream
+    };
+}
+function parseJson(body) {
+    if (0 === body.length) return {};
+    let value;
+    try {
+        value = JSON.parse(body);
+    } catch (error) {
+        throw createHttpError(400, error.message, 'entity.parse.failed');
+    }
+    if (null === value || 'object' != typeof value) throw createHttpError(400, 'JSON body must be an object or array', 'entity.parse.failed');
+    return value;
+}
+function normalizeReadError(error, charset) {
+    if (error instanceof Error && 'status' in error && 'number' == typeof error.status) {
+        if (charset && 'type' in error && 'encoding.unsupported' === error.type) return createHttpError(415, `unsupported charset "${charset.toUpperCase()}"`, 'charset.unsupported');
+        return error;
+    }
+    return createHttpError(400, error instanceof Error ? error.message : 'failed to read request body', 'request.invalid');
+}
+function jsonBodyParser(options = {}) {
+    return (req, _res, next)=>{
+        const request = req;
+        if (!('body' in request)) request.body = void 0;
+        if (!hasBody(req) || !shouldParse(req)) return void next();
+        const charset = getCharset(req);
+        if (!charset.startsWith('utf-')) {
+            req.resume();
+            next(createHttpError(415, `unsupported charset "${charset.toUpperCase()}"`, 'charset.unsupported'));
+            return;
+        }
+        let content;
+        try {
+            content = getContentStream(req);
+        } catch (error) {
+            req.resume();
+            next(normalizeReadError(error));
+            return;
+        }
+        const handleError = (error)=>{
+            content.cleanup?.();
+            if (content.decompressor) {
+                req.unpipe(content.decompressor);
+                content.decompressor.destroy();
+            }
+            req.resume();
+            next(normalizeReadError(error, charset));
+        };
+        let limit;
+        try {
+            limit = 'function' == typeof options.limit ? options.limit(req) : options.limit;
+        } catch (error) {
+            handleError(error);
+            return;
+        }
+        raw_body(content.stream, {
+            encoding: charset,
+            length: content.length,
+            limit
+        }).then((body)=>{
+            try {
+                request.body = parseJson(body);
+            } catch (error) {
+                handleError(error);
+                return;
+            }
+            content.cleanup?.();
+            next();
+        }, handleError);
+    };
+}
+export { jsonBodyParser };

package/dist/sdk/server/router.d.ts

@@ -0,0 +1,24 @@
+import type { ServerResponse } from 'http';
+import { Common, SDK, Thirdparty } from '@rsdoctor/shared/types';
+import { BaseAPI } from './apis/base.js';
+interface RouterOptions {
+    apis: Common.Constructor<typeof BaseAPI>[];
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+    server: SDK.RsdoctorServerInstance;
+}
+export declare class Router {
+    protected options: RouterOptions;
+    static routes: {
+        /**
+         * - `key` is the constructor of object which used to match the API class
+         */
+        get: Map<new (sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance) => BaseAPI, [apiKey: PropertyKey, pathname: string][]>;
+        post: Map<new (sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance) => BaseAPI, [apiKey: PropertyKey, pathname: string][]>;
+    };
+    static get(pathname: string): MethodDecorator;
+    static post(pathname: string): MethodDecorator;
+    constructor(options: RouterOptions);
+    setup(): Promise<void>;
+    wrapAPIFunction<T extends BaseAPI>(api: T, key: PropertyKey): (req: Thirdparty.connect.IncomingMessage, res: ServerResponse) => Promise<unknown>;
+}
+export {};

package/dist/sdk/server/router.js

@@ -0,0 +1,83 @@
+import "node:module";
+const normalizeAPIKey = (key)=>{
+    if (key && 'object' == typeof key && 'name' in key) return key.name;
+    return key;
+};
+class Router {
+    static get(pathname) {
+        return (target, propertyKey, descriptor)=>{
+            const routes = Router.routes.get;
+            const constructor = target.constructor;
+            if (!routes.has(constructor)) routes.set(constructor, []);
+            routes.get(constructor).push([
+                normalizeAPIKey(propertyKey),
+                pathname
+            ]);
+            return descriptor;
+        };
+    }
+    static post(pathname) {
+        return (target, propertyKey, descriptor)=>{
+            const routes = Router.routes.post;
+            const constructor = target.constructor;
+            if (!routes.has(constructor)) routes.set(constructor, []);
+            routes.get(constructor).push([
+                normalizeAPIKey(propertyKey),
+                pathname
+            ]);
+            return descriptor;
+        };
+    }
+    async setup() {
+        const { apis, sdk, server } = this.options;
+        apis.forEach((API)=>{
+            const obj = new API(sdk, server);
+            Router.routes.get.get(API)?.forEach(([key, pathname])=>{
+                server.get(pathname, this.wrapAPIFunction(obj, key));
+            });
+            Router.routes.post.get(API)?.forEach(([key, pathname])=>{
+                server.post(pathname, this.wrapAPIFunction(obj, key));
+            });
+        });
+    }
+    wrapAPIFunction(api, key) {
+        const { sdk, server } = this.options;
+        return async (req, res)=>{
+            const ctx = {
+                req,
+                res,
+                sdk,
+                server
+            };
+            const trap = new Proxy(api, {
+                get (target, key, receiver) {
+                    switch(key){
+                        case 'ctx':
+                            return ctx;
+                        default:
+                            return Reflect.get(target, key, receiver);
+                    }
+                },
+                set (target, key, value, receiver) {
+                    return Reflect.set(target, key, value, receiver);
+                },
+                defineProperty (target, p, attrs) {
+                    return Reflect.defineProperty(target, p, attrs);
+                }
+            });
+            const fn = api[key];
+            const result = await fn.call(trap, trap);
+            if ('string' == typeof result) return Buffer.from(result, 'utf-8');
+            if (result && 'object' == typeof result) return Buffer.from(JSON.stringify(result), 'utf-8');
+            return result;
+        };
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+Router.routes = {
+    get: new Map(),
+    post: new Map()
+};
+export { Router };

package/dist/sdk/server/security.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_ALLOWED_CORS_ORIGINS: RegExp;
+export declare function isAllowedRequestOrigin(origin: string | string[] | undefined): boolean;
+export declare function isAllowedRequestHost(host: string | string[] | undefined): boolean;
+export declare function isAllowedCorsRequest(origin: string | string[] | undefined, host: string | string[] | undefined): boolean;
+export declare function isAllowedOpenInEditorToken(token: string | null, expectedToken: string): boolean;

package/dist/sdk/server/security.js

@@ -0,0 +1,47 @@
+import "node:module";
+import { isIP } from "node:net";
+import { timingSafeEqual } from "node:crypto";
+const DEFAULT_ALLOWED_CORS_ORIGINS = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
+const LOCAL_HOSTNAMES = /^(?:localhost|[^:]+\.localhost)$/;
+function isAllowedRequestOrigin(origin) {
+    if (void 0 === origin) return true;
+    return 'string' == typeof origin && DEFAULT_ALLOWED_CORS_ORIGINS.test(origin);
+}
+function getHostnameFromOrigin(origin) {
+    try {
+        const hostname = new URL(origin).hostname.toLowerCase();
+        return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+    } catch  {
+        return '';
+    }
+}
+function isIpAddress(hostname) {
+    return 0 !== isIP(hostname);
+}
+function getHostnameFromHost(host) {
+    if (host.startsWith('[')) {
+        const endIndex = host.indexOf(']');
+        return -1 === endIndex ? '' : host.slice(1, endIndex);
+    }
+    return host.split(':')[0];
+}
+function isAllowedRequestHost(host) {
+    if ('string' != typeof host) return false;
+    const hostname = getHostnameFromHost(host).toLowerCase();
+    return LOCAL_HOSTNAMES.test(hostname) || isIpAddress(hostname);
+}
+function isAllowedCorsRequest(origin, host) {
+    if (void 0 === origin) return true;
+    if ('string' != typeof origin || 'string' != typeof host || !isAllowedRequestOrigin(origin)) return false;
+    const originHostname = getHostnameFromOrigin(origin);
+    const hostHostname = getHostnameFromHost(host).toLowerCase();
+    if (originHostname.endsWith('.localhost')) return originHostname === hostHostname;
+    return true;
+}
+function isAllowedOpenInEditorToken(token, expectedToken) {
+    if ('string' != typeof token || !expectedToken) return false;
+    const tokenBuffer = Buffer.from(token);
+    const expectedTokenBuffer = Buffer.from(expectedToken);
+    return tokenBuffer.length === expectedTokenBuffer.length && timingSafeEqual(tokenBuffer, expectedTokenBuffer);
+}
+export { DEFAULT_ALLOWED_CORS_ORIGINS, isAllowedCorsRequest, isAllowedOpenInEditorToken, isAllowedRequestHost, isAllowedRequestOrigin };

package/dist/sdk/server/socket/api.d.ts

@@ -0,0 +1,15 @@
+import { Data } from '../../../common/index.js';
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+interface SocketAPILoaderOptions {
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+}
+export declare class SocketAPILoader implements Manifest.ManifestDataLoader {
+    protected options: SocketAPILoaderOptions;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(options: SocketAPILoaderOptions);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+    get loadAPIData(): <T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>) => Promise<SDK.ServerAPI.InferResponseType<T>>;
+}
+export {};

package/dist/sdk/server/socket/api.js

@@ -0,0 +1,22 @@
+import "node:module";
+import { Data } from "../../../common/index.js";
+class SocketAPILoader {
+    async loadManifest() {
+        return this.options.sdk.getManifestData();
+    }
+    async loadData(key) {
+        const data = this.options.sdk.getStoreData();
+        const sep = '.';
+        let res = data[key];
+        if (key.includes(sep)) res = key.split(sep).reduce((t, k)=>t[k], data);
+        return res;
+    }
+    get loadAPIData() {
+        return this.dataLoader.loadAPI;
+    }
+    constructor(options){
+        this.options = options;
+        this.dataLoader = new Data.APIDataLoader(this);
+    }
+}
+export { SocketAPILoader };