@dcl/sdk 7.0.6-3999809037.commit-0a47a3c → 7.0.6-4009020955.commit-08722f5

package/cli/commands/preview/endpoints.js

@@ -0,0 +1,500 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilesFromFolder = exports.setupEcs6Endpoints = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
+const sdk_1 = require("@dcl/schemas/dist/sdk");
+const schemas_1 = require("@dcl/schemas");
+const ignore_1 = __importDefault(require("ignore"));
+const node_fetch_1 = __importStar(require("node-fetch"));
+const catalyst_1 = require("./catalyst");
+function getCatalystUrl() {
+    return new URL('https://peer.decentraland.org');
+}
+function smartWearableNameToId(name) {
+    return name.toLocaleLowerCase().replace(/ /g, '-');
+}
+function setupEcs6Endpoints(dir, router) {
+    const baseFolders = [dir];
+    router.get('/scene.json', async () => {
+        return {
+            headers: { 'content-type': 'application/json' },
+            body: fs.createReadStream(path.join(dir, 'scene.json'))
+        };
+    });
+    router.get('/lambdas/explore/realms', async (ctx) => {
+        return {
+            body: [
+                {
+                    serverName: 'localhost',
+                    url: `http://${ctx.url.host}`,
+                    layer: 'stub',
+                    usersCount: 0,
+                    maxUsers: 100,
+                    userParcels: []
+                }
+            ]
+        };
+    });
+    router.get('/lambdas/contracts/servers', async (ctx) => {
+        return {
+            body: [
+                {
+                    address: `http://${ctx.url.host}`,
+                    owner: '0x0000000000000000000000000000000000000000',
+                    id: '0x0000000000000000000000000000000000000000000000000000000000000000'
+                }
+            ]
+        };
+    });
+    router.get('/lambdas/profiles', async (ctx, next) => {
+        const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
+        try {
+            const previewWearables = getAllPreviewWearables({
+                baseFolders,
+                baseUrl
+            }).map((wearable) => wearable.id);
+            if (previewWearables.length === 1) {
+                const catalystUrl = getCatalystUrl();
+                const u = new URL(ctx.url.toString());
+                u.host = catalystUrl.host;
+                u.protocol = catalystUrl.protocol;
+                u.port = catalystUrl.port;
+                const req = await (0, node_fetch_1.default)(u.toString(), {
+                    headers: {
+                        connection: 'close'
+                    },
+                    method: ctx.request.method,
+                    body: ctx.request.method === 'get' ? undefined : ctx.request.body
+                });
+                const deployedProfile = (await req.json());
+                if ((deployedProfile === null || deployedProfile === void 0 ? void 0 : deployedProfile.length) === 1) {
+                    deployedProfile[0].avatars[0].avatar.wearables.push(...previewWearables);
+                    return {
+                        headers: {
+                            'content-type': req.headers.get('content-type') || 'application/binary'
+                        },
+                        body: deployedProfile
+                    };
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`Failed to catch profile and fill with preview wearables.`, err);
+        }
+        return next();
+    });
+    router.all('/lambdas/:path+', async (ctx) => {
+        const catalystUrl = getCatalystUrl();
+        const u = new URL(ctx.url.toString());
+        u.host = catalystUrl.host;
+        u.protocol = catalystUrl.protocol;
+        u.port = catalystUrl.port;
+        const req = await (0, node_fetch_1.default)(u.toString(), {
+            headers: {
+                connection: 'close'
+            },
+            method: ctx.request.method,
+            body: ctx.request.method === 'get' ? undefined : ctx.request.body
+        });
+        return {
+            headers: {
+                'content-type': req.headers.get('content-type') || 'application/binary'
+            },
+            body: req.body
+        };
+    });
+    router.post('/content/entities', async (ctx) => {
+        const catalystUrl = getCatalystUrl();
+        const headers = new node_fetch_1.Headers();
+        console.log(ctx.request.headers);
+        const res = await (0, node_fetch_1.default)(`${catalystUrl.toString()}/content/entities`, {
+            method: 'post',
+            headers,
+            body: ctx.request.body
+        });
+        return res;
+    });
+    serveStatic(dir, router);
+    serveFolders(router, baseFolders);
+}
+exports.setupEcs6Endpoints = setupEcs6Endpoints;
+function serveFolders(router, baseFolders) {
+    router.get('/content/contents/:hash', async (ctx, next) => {
+        if (ctx.params.hash && ctx.params.hash.startsWith('b64-')) {
+            const fullPath = path.resolve(Buffer.from(ctx.params.hash.replace(/^b64-/, ''), 'base64').toString('utf8'));
+            if (!baseFolders.find((folder) => fullPath.startsWith(folder))) {
+                return next();
+            }
+            return {
+                headers: {
+                    'x-timestamp': Date.now(),
+                    'x-sent': true,
+                    'cache-control': 'no-cache,private,max-age=1'
+                },
+                body: fs.createReadStream(fullPath)
+            };
+        }
+        return next();
+    });
+    async function pointerRequestHandler(pointers) {
+        if (!pointers || pointers.length === 0) {
+            return [];
+        }
+        const requestedPointers = new Set(pointers && typeof pointers === 'string' ? [pointers] : pointers);
+        const resultEntities = getSceneJson({
+            baseFolders,
+            pointers: Array.from(requestedPointers)
+        });
+        const catalystUrl = getCatalystUrl();
+        const remote = (0, catalyst_1.fetchEntityByPointer)(catalystUrl.toString(), pointers.filter(($) => !$.match(/-?\d+,-?\d+/)));
+        const serverEntities = Array.isArray(remote) ? remote : [];
+        return [...resultEntities, ...serverEntities];
+    }
+    router.get('/content/entities/scene', async (ctx) => {
+        return {
+            body: await pointerRequestHandler(ctx.url.searchParams.getAll('pointer'))
+        };
+    });
+    router.post('/content/entities/active', async (ctx) => {
+        const body = await ctx.request.json();
+        return {
+            body: await pointerRequestHandler(body.pointers)
+        };
+    });
+    router.get('/preview-wearables/:id', async (ctx) => {
+        const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
+        const wearables = getAllPreviewWearables({
+            baseUrl,
+            baseFolders
+        });
+        const wearableId = ctx.params.id;
+        return {
+            body: {
+                ok: true,
+                data: wearables.filter((wearable) => smartWearableNameToId(wearable === null || wearable === void 0 ? void 0 : wearable.name) === wearableId)
+            }
+        };
+    });
+    router.get('/preview-wearables', async (ctx) => {
+        const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
+        return {
+            body: {
+                ok: true,
+                data: getAllPreviewWearables({ baseUrl, baseFolders })
+            }
+        };
+    });
+}
+const defaultHashMaker = (str) => 'b64-' + Buffer.from(str).toString('base64');
+function getAllPreviewWearables({ baseFolders, baseUrl }) {
+    const wearablePathArray = [];
+    for (const wearableDir of baseFolders) {
+        const wearableJsonPath = path.resolve(wearableDir, 'wearable.json');
+        if (fs.existsSync(wearableJsonPath)) {
+            wearablePathArray.push(wearableJsonPath);
+        }
+    }
+    const ret = [];
+    for (const wearableJsonPath of wearablePathArray) {
+        try {
+            ret.push(serveWearable({ wearableJsonPath, baseUrl }));
+        }
+        catch (err) {
+            console.error(`Couldn't mock the wearable ${wearableJsonPath}. Please verify the correct format and scheme.`, err);
+        }
+    }
+    return ret;
+}
+function serveWearable({ wearableJsonPath, baseUrl }) {
+    var _a;
+    const wearableDir = path.dirname(wearableJsonPath);
+    const wearableJson = JSON.parse(fs.readFileSync(wearableJsonPath).toString());
+    if (!sdk_1.WearableJson.validate(wearableJson)) {
+        const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
+        console.error(`Unable to validate wearable.json properly, please check it.`, errors);
+        throw new Error(`Invalid wearable.json (${wearableJsonPath})`);
+    }
+    const dclIgnorePath = path.resolve(wearableDir, '.dclignore');
+    let ignoreFileContent = '';
+    if (fs.existsSync(dclIgnorePath)) {
+        ignoreFileContent = fs.readFileSync(path.resolve(wearableDir, '.dclignore'), 'utf-8');
+    }
+    const hashedFiles = getFilesFromFolder({
+        folder: wearableDir,
+        addOriginalPath: false,
+        ignorePattern: ignoreFileContent
+    });
+    const thumbnailFiltered = hashedFiles.filter(($) => ($ === null || $ === void 0 ? void 0 : $.file) === 'thumbnail.png');
+    const thumbnail = thumbnailFiltered.length > 0 && ((_a = thumbnailFiltered[0]) === null || _a === void 0 ? void 0 : _a.hash) && `${baseUrl}/${thumbnailFiltered[0].hash}`;
+    const wearableId = 'urn:8dc2d7ad-97e3-44d0-ba89-e8305d795a6a';
+    const representations = wearableJson.data.representations.map((representation) => (Object.assign(Object.assign({}, representation), { mainFile: `male/${representation.mainFile}`, contents: hashedFiles.map(($) => ({
+            key: `male/${$ === null || $ === void 0 ? void 0 : $.file}`,
+            url: `${baseUrl}/${$ === null || $ === void 0 ? void 0 : $.hash}`,
+            hash: $ === null || $ === void 0 ? void 0 : $.hash
+        })) })));
+    return {
+        id: wearableId,
+        rarity: wearableJson.rarity,
+        i18n: [{ code: 'en', text: wearableJson.name }],
+        description: wearableJson.description,
+        thumbnail: thumbnail || '',
+        baseUrl: `${baseUrl}/`,
+        name: wearableJson.name || '',
+        data: {
+            category: wearableJson.data.category,
+            replaces: [],
+            hides: [],
+            tags: [],
+            scene: hashedFiles,
+            representations: representations
+        }
+    };
+}
+function getSceneJson({ baseFolders, pointers, customHashMaker }) {
+    const requestedPointers = new Set(pointers);
+    const resultEntities = [];
+    const allDeployments = baseFolders.map((folder) => {
+        const dclIgnorePath = path.resolve(folder, '.dclignore');
+        let ignoreFileContent = '';
+        if (fs.existsSync(dclIgnorePath)) {
+            ignoreFileContent = fs.readFileSync(path.resolve(folder, '.dclignore'), 'utf-8');
+        }
+        return entityV3FromFolder({
+            folder,
+            addOriginalPath: false,
+            ignorePattern: ignoreFileContent,
+            customHashMaker
+        });
+    });
+    for (const pointer of Array.from(requestedPointers)) {
+        const theDeployment = allDeployments.find(($) => $ && $.pointers.includes(pointer));
+        if (theDeployment) {
+            theDeployment.pointers.forEach(($) => requestedPointers.delete($));
+            resultEntities.push(theDeployment);
+        }
+    }
+    return resultEntities;
+}
+function getEcsPath(workingDir) {
+    try {
+        return require.resolve('decentraland-ecs/package.json', {
+            paths: [workingDir]
+        });
+    }
+    catch (e) {
+        return require.resolve('@dcl/sdk/package.json', {
+            paths: [workingDir]
+        });
+    }
+}
+function serveStatic(dir, router) {
+    const ecsPath = path.dirname(getEcsPath(dir));
+    const dclKernelPath = path.dirname(require.resolve('@dcl/kernel/package.json', {
+        paths: [dir, ecsPath]
+    }));
+    const dclKernelDefaultProfilePath = path.resolve(dclKernelPath, 'default-profile');
+    const dclKernelImagesDecentralandConnect = path.resolve(dclKernelPath, 'images', 'decentraland-connect');
+    const dclKernelLoaderPath = path.resolve(dclKernelPath, 'loader');
+    const dclUnityRenderer = path.dirname(require.resolve('@dcl/unity-renderer/package.json', {
+        paths: [dir, ecsPath]
+    }));
+    const routes = [
+        {
+            route: '/',
+            path: path.resolve(dclKernelPath, 'preview.html'),
+            type: 'text/html'
+        },
+        {
+            route: '/favicon.ico',
+            path: path.resolve(dclKernelPath, 'favicon.ico'),
+            type: 'text/html'
+        },
+        {
+            route: '/@/artifacts/index.js',
+            path: path.resolve(dclKernelPath, 'index.js'),
+            type: 'text/javascript'
+        }
+    ];
+    for (const route of routes) {
+        router.get(route.route, async (_ctx) => {
+            return {
+                headers: { 'Content-Type': route.type },
+                body: fs.createReadStream(route.path)
+            };
+        });
+    }
+    function createStaticRoutes(route, folder, transform = (str) => str) {
+        router.get(route, async (ctx, next) => {
+            const file = ctx.params.path;
+            const fullPath = path.resolve(folder, transform(file));
+            if (!fs.existsSync(fullPath)) {
+                return next();
+            }
+            const headers = {
+                'x-timestamp': Date.now(),
+                'x-sent': true,
+                'cache-control': 'no-cache,private,max-age=1'
+            };
+            if (fullPath.endsWith('.wasm')) {
+                headers['content-type'] = 'application/wasm';
+            }
+            return {
+                headers,
+                body: fs.createReadStream(fullPath)
+            };
+        });
+    }
+    createStaticRoutes('/images/decentraland-connect/:path+', dclKernelImagesDecentralandConnect);
+    createStaticRoutes('/@/artifacts/unity-renderer/:path+', dclUnityRenderer, (filePath) => filePath.replace(/.br+$/, ''));
+    createStaticRoutes('/@/artifacts/loader/:path+', dclKernelLoaderPath);
+    createStaticRoutes('/default-profile/:path+', dclKernelDefaultProfilePath);
+    router.get('/feature-flags/:file', async (ctx) => {
+        const res = await (0, node_fetch_1.default)(`https://feature-flags.decentraland.zone/${ctx.params.file}`, {
+            headers: {
+                connection: 'close'
+            }
+        });
+        return {
+            body: await res.arrayBuffer()
+        };
+    });
+}
+function entityV3FromFolder({ folder, addOriginalPath, ignorePattern, customHashMaker }) {
+    const sceneJsonPath = path.resolve(folder, './scene.json');
+    let isParcelScene = true;
+    const wearableJsonPath = path.resolve(folder, './wearable.json');
+    if (fs.existsSync(wearableJsonPath)) {
+        try {
+            const wearableJson = JSON.parse(fs.readFileSync(wearableJsonPath).toString());
+            if (!sdk_1.WearableJson.validate(wearableJson)) {
+                const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
+                console.error(`Unable to validate wearable.json properly, please check it.`, errors);
+                console.error(`Invalid wearable.json (${wearableJsonPath})`);
+            }
+            else {
+                isParcelScene = false;
+            }
+        }
+        catch (err) {
+            console.error(`Unable to load wearable.json properly`, err);
+        }
+    }
+    const hashMaker = customHashMaker ? customHashMaker : defaultHashMaker;
+    if (fs.existsSync(sceneJsonPath) && isParcelScene) {
+        const sceneJson = JSON.parse(fs.readFileSync(sceneJsonPath).toString());
+        const { base, parcels } = sceneJson.scene;
+        const pointers = new Set();
+        pointers.add(base);
+        parcels.forEach(($) => pointers.add($));
+        const mappedFiles = getFilesFromFolder({
+            folder,
+            addOriginalPath,
+            ignorePattern,
+            customHashMaker
+        });
+        return {
+            version: 'v3',
+            type: schemas_1.EntityType.SCENE,
+            id: hashMaker(folder),
+            pointers: Array.from(pointers),
+            timestamp: Date.now(),
+            metadata: sceneJson,
+            content: mappedFiles
+        };
+    }
+    return null;
+}
+const defaultDclIgnore = () => [
+    '.*',
+    'package.json',
+    'package-lock.json',
+    'yarn-lock.json',
+    'build.json',
+    'export',
+    'tsconfig.json',
+    'tslint.json',
+    'node_modules',
+    '*.ts',
+    '*.tsx',
+    'Dockerfile',
+    'dist',
+    'README.md',
+    '*.blend',
+    '*.fbx',
+    '*.zip',
+    '*.rar'
+].join('\n');
+function getFilesFromFolder({ folder, addOriginalPath, ignorePattern, customHashMaker }) {
+    const hashMaker = customHashMaker ? customHashMaker : defaultHashMaker;
+    const allFiles = (0, glob_1.sync)('**/*', {
+        cwd: folder,
+        dot: false,
+        absolute: true
+    })
+        .map((file) => {
+        try {
+            if (!fs.statSync(file).isFile())
+                return;
+        }
+        catch (err) {
+            return;
+        }
+        const _folder = folder.replace(/\\/gi, '/');
+        const key = file.replace(_folder, '').replace(/^\/+/, '');
+        return key;
+    })
+        .filter(($) => !!$);
+    const ensureIgnorePattern = ignorePattern && ignorePattern !== '' ? ignorePattern : defaultDclIgnore();
+    const ig = (0, ignore_1.default)().add(ensureIgnorePattern);
+    const filteredFiles = ig.filter(allFiles);
+    const ret = [];
+    for (const file of filteredFiles) {
+        const absolutePath = path.resolve(folder, file);
+        try {
+            if (!fs.statSync(absolutePath).isFile())
+                continue;
+        }
+        catch (err) {
+            console.log(err);
+            continue;
+        }
+        const absoluteFolder = folder.replace(/\\/gi, '/');
+        const relativeFilePathToFolder = file.replace(absoluteFolder, '').replace(/^\/+/, '');
+        ret.push({
+            file: relativeFilePathToFolder.toLowerCase(),
+            original_path: addOriginalPath ? absolutePath : undefined,
+            hash: hashMaker(absolutePath)
+        });
+    }
+    return ret;
+}
+exports.getFilesFromFolder = getFilesFromFolder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"endpoints.js","sourceRoot":"","sources":["endpoints.ts"],"names":[],"mappings":"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","sourcesContent":["import { Router } from '@well-known-components/http-server'\nimport { PreviewComponents } from './types'\nimport * as path from 'path'\nimport * as fs from 'fs'\nimport { sync as globSync } from 'glob'\nimport { WearableJson } from '@dcl/schemas/dist/sdk'\nimport { ContentMapping, Entity, EntityType } from '@dcl/schemas'\nimport ignore from 'ignore'\nimport fetch, { Headers } from 'node-fetch'\nimport { fetchEntityByPointer } from './catalyst'\n\nfunction getCatalystUrl(): URL {\n  return new URL('https://peer.decentraland.org')\n}\n\nfunction smartWearableNameToId(name: string) {\n  return name.toLocaleLowerCase().replace(/ /g, '-')\n}\n\nexport function setupEcs6Endpoints(dir: string, router: Router<PreviewComponents>) {\n  const baseFolders = [dir]\n  // handle old preview scene.json\n  router.get('/scene.json', async () => {\n    return {\n      headers: { 'content-type': 'application/json' },\n      body: fs.createReadStream(path.join(dir, 'scene.json'))\n    }\n  })\n\n  router.get('/lambdas/explore/realms', async (ctx) => {\n    return {\n      body: [\n        {\n          serverName: 'localhost',\n          url: `http://${ctx.url.host}`,\n          layer: 'stub',\n          usersCount: 0,\n          maxUsers: 100,\n          userParcels: []\n        }\n      ]\n    }\n  })\n\n  router.get('/lambdas/contracts/servers', async (ctx) => {\n    return {\n      body: [\n        {\n          address: `http://${ctx.url.host}`,\n          owner: '0x0000000000000000000000000000000000000000',\n          id: '0x0000000000000000000000000000000000000000000000000000000000000000'\n        }\n      ]\n    }\n  })\n\n  router.get('/lambdas/profiles', async (ctx, next) => {\n    const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`\n\n    try {\n      const previewWearables = getAllPreviewWearables({\n        baseFolders,\n        baseUrl\n      }).map((wearable) => wearable.id)\n\n      if (previewWearables.length === 1) {\n        const catalystUrl = getCatalystUrl()\n\n        const u = new URL(ctx.url.toString())\n        u.host = catalystUrl.host\n        u.protocol = catalystUrl.protocol\n        u.port = catalystUrl.port\n        const req = await fetch(u.toString(), {\n          headers: {\n            connection: 'close'\n          },\n          method: ctx.request.method,\n          body: ctx.request.method === 'get' ? undefined : ctx.request.body\n        })\n\n        const deployedProfile = (await req.json()) as any[]\n\n        if (deployedProfile?.length === 1) {\n          deployedProfile[0].avatars[0].avatar.wearables.push(...previewWearables)\n          return {\n            headers: {\n              'content-type': req.headers.get('content-type') || 'application/binary'\n            },\n            body: deployedProfile\n          }\n        }\n      }\n    } catch (err) {\n      console.warn(`Failed to catch profile and fill with preview wearables.`, err)\n    }\n\n    return next()\n  })\n\n  router.all('/lambdas/:path+', async (ctx) => {\n    const catalystUrl = getCatalystUrl()\n    const u = new URL(ctx.url.toString())\n    u.host = catalystUrl.host\n    u.protocol = catalystUrl.protocol\n    u.port = catalystUrl.port\n    const req = await fetch(u.toString(), {\n      headers: {\n        connection: 'close'\n      },\n      method: ctx.request.method,\n      body: ctx.request.method === 'get' ? undefined : ctx.request.body\n    })\n\n    return {\n      headers: {\n        'content-type': req.headers.get('content-type') || 'application/binary'\n      },\n      body: req.body\n    }\n  })\n\n  router.post('/content/entities', async (ctx) => {\n    const catalystUrl = getCatalystUrl()\n    const headers = new Headers()\n    console.log(ctx.request.headers)\n    const res = await fetch(`${catalystUrl.toString()}/content/entities`, {\n      method: 'post',\n      headers,\n      body: ctx.request.body\n    })\n\n    return res\n  })\n\n  serveStatic(dir, router)\n\n  // TODO: get workspace scenes & wearables...\n\n  serveFolders(router, baseFolders)\n}\n\nfunction serveFolders(router: Router<PreviewComponents>, baseFolders: string[]) {\n  router.get('/content/contents/:hash', async (ctx: any, next: any) => {\n    if (ctx.params.hash && ctx.params.hash.startsWith('b64-')) {\n      const fullPath = path.resolve(Buffer.from(ctx.params.hash.replace(/^b64-/, ''), 'base64').toString('utf8'))\n\n      // only return files IF the file is within a baseFolder\n      if (!baseFolders.find((folder: string) => fullPath.startsWith(folder))) {\n        return next()\n      }\n\n      return {\n        headers: {\n          'x-timestamp': Date.now(),\n          'x-sent': true,\n          'cache-control': 'no-cache,private,max-age=1'\n        },\n        body: fs.createReadStream(fullPath)\n      }\n    }\n\n    return next()\n  })\n\n  async function pointerRequestHandler(pointers: string[]) {\n    if (!pointers || pointers.length === 0) {\n      return []\n    }\n\n    const requestedPointers = new Set<string>(\n      pointers && typeof pointers === 'string' ? [pointers as string] : (pointers as string[])\n    )\n\n    const resultEntities = getSceneJson({\n      baseFolders,\n      pointers: Array.from(requestedPointers)\n    })\n    const catalystUrl = getCatalystUrl()\n    const remote = fetchEntityByPointer(\n      catalystUrl.toString(),\n      pointers.filter(($: string) => !$.match(/-?\\d+,-?\\d+/))\n    )\n\n    const serverEntities = Array.isArray(remote) ? remote : []\n\n    return [...resultEntities, ...serverEntities]\n  }\n\n  // REVIEW RESPONSE FORMAT\n  router.get('/content/entities/scene', async (ctx) => {\n    return {\n      body: await pointerRequestHandler(ctx.url.searchParams.getAll('pointer'))\n    }\n  })\n\n  // REVIEW RESPONSE FORMAT\n  router.post('/content/entities/active', async (ctx) => {\n    const body = await ctx.request.json()\n    return {\n      body: await pointerRequestHandler(body.pointers)\n    }\n  })\n\n  router.get('/preview-wearables/:id', async (ctx) => {\n    const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`\n    const wearables = getAllPreviewWearables({\n      baseUrl,\n      baseFolders\n    })\n    const wearableId = ctx.params.id\n    return {\n      body: {\n        ok: true,\n        data: wearables.filter((wearable) => smartWearableNameToId(wearable?.name) === wearableId)\n      }\n    }\n  })\n\n  router.get('/preview-wearables', async (ctx) => {\n    const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`\n    return {\n      body: {\n        ok: true,\n        data: getAllPreviewWearables({ baseUrl, baseFolders })\n      }\n    }\n  })\n}\n\nconst defaultHashMaker = (str: string) => 'b64-' + Buffer.from(str).toString('base64')\n\nfunction getAllPreviewWearables({ baseFolders, baseUrl }: { baseFolders: string[]; baseUrl: string }) {\n  const wearablePathArray: string[] = []\n  for (const wearableDir of baseFolders) {\n    const wearableJsonPath = path.resolve(wearableDir, 'wearable.json')\n    if (fs.existsSync(wearableJsonPath)) {\n      wearablePathArray.push(wearableJsonPath)\n    }\n  }\n\n  const ret: ReturnType<typeof serveWearable>[] = []\n  for (const wearableJsonPath of wearablePathArray) {\n    try {\n      ret.push(serveWearable({ wearableJsonPath, baseUrl }))\n    } catch (err) {\n      console.error(`Couldn't mock the wearable ${wearableJsonPath}. Please verify the correct format and scheme.`, err)\n    }\n  }\n  return ret\n}\n\nfunction serveWearable({ wearableJsonPath, baseUrl }: { wearableJsonPath: string; baseUrl: string }) {\n  const wearableDir = path.dirname(wearableJsonPath)\n  const wearableJson = JSON.parse(fs.readFileSync(wearableJsonPath).toString())\n\n  if (!WearableJson.validate(wearableJson)) {\n    const errors = (WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('')\n\n    console.error(`Unable to validate wearable.json properly, please check it.`, errors)\n    throw new Error(`Invalid wearable.json (${wearableJsonPath})`)\n  }\n\n  const dclIgnorePath = path.resolve(wearableDir, '.dclignore')\n  let ignoreFileContent = ''\n  if (fs.existsSync(dclIgnorePath)) {\n    ignoreFileContent = fs.readFileSync(path.resolve(wearableDir, '.dclignore'), 'utf-8')\n  }\n\n  const hashedFiles = getFilesFromFolder({\n    folder: wearableDir,\n    addOriginalPath: false,\n    ignorePattern: ignoreFileContent\n  })\n\n  const thumbnailFiltered = hashedFiles.filter(($) => $?.file === 'thumbnail.png')\n  const thumbnail =\n    thumbnailFiltered.length > 0 && thumbnailFiltered[0]?.hash && `${baseUrl}/${thumbnailFiltered[0].hash}`\n\n  const wearableId = 'urn:8dc2d7ad-97e3-44d0-ba89-e8305d795a6a'\n\n  const representations = wearableJson.data.representations.map((representation) => ({\n    ...representation,\n    mainFile: `male/${representation.mainFile}`,\n    contents: hashedFiles.map(($) => ({\n      key: `male/${$?.file}`,\n      url: `${baseUrl}/${$?.hash}`,\n      hash: $?.hash\n    }))\n  }))\n\n  return {\n    id: wearableId,\n    rarity: wearableJson.rarity,\n    i18n: [{ code: 'en', text: wearableJson.name }],\n    description: wearableJson.description,\n    thumbnail: thumbnail || '',\n    baseUrl: `${baseUrl}/`,\n    name: wearableJson.name || '',\n    data: {\n      category: wearableJson.data.category,\n      replaces: [],\n      hides: [],\n      tags: [],\n      scene: hashedFiles,\n      representations: representations as any\n    }\n  }\n}\n\nfunction getSceneJson({\n  baseFolders,\n  pointers,\n  customHashMaker\n}: {\n  baseFolders: string[]\n  pointers: string[]\n  customHashMaker?: (str: string) => string\n}): Entity[] {\n  const requestedPointers = new Set<string>(pointers)\n  const resultEntities: Entity[] = []\n\n  const allDeployments = baseFolders.map((folder) => {\n    const dclIgnorePath = path.resolve(folder, '.dclignore')\n    let ignoreFileContent = ''\n    if (fs.existsSync(dclIgnorePath)) {\n      ignoreFileContent = fs.readFileSync(path.resolve(folder, '.dclignore'), 'utf-8')\n    }\n\n    return entityV3FromFolder({\n      folder,\n      addOriginalPath: false,\n      ignorePattern: ignoreFileContent,\n      customHashMaker\n    })\n  })\n\n  for (const pointer of Array.from(requestedPointers)) {\n    // get deployment by pointer\n    const theDeployment = allDeployments.find(($) => $ && $.pointers.includes(pointer))\n    if (theDeployment) {\n      // remove all the required pointers from the requestedPointers set\n      // to prevent sending duplicated entities\n      theDeployment.pointers.forEach(($) => requestedPointers.delete($))\n\n      // add the deployment to the results\n      resultEntities.push(theDeployment)\n    }\n  }\n\n  return resultEntities\n}\n\nfunction getEcsPath(workingDir: string) {\n  try {\n    return require.resolve('decentraland-ecs/package.json', {\n      paths: [workingDir]\n    })\n  } catch (e) {\n    return require.resolve('@dcl/sdk/package.json', {\n      paths: [workingDir]\n    })\n  }\n}\n\nfunction serveStatic(dir: string, router: Router<PreviewComponents>) {\n  const ecsPath = path.dirname(getEcsPath(dir))\n  const dclKernelPath = path.dirname(\n    require.resolve('@dcl/kernel/package.json', {\n      paths: [dir, ecsPath]\n    })\n  )\n  const dclKernelDefaultProfilePath = path.resolve(dclKernelPath, 'default-profile')\n  const dclKernelImagesDecentralandConnect = path.resolve(dclKernelPath, 'images', 'decentraland-connect')\n  const dclKernelLoaderPath = path.resolve(dclKernelPath, 'loader')\n  const dclUnityRenderer = path.dirname(\n    require.resolve('@dcl/unity-renderer/package.json', {\n      paths: [dir, ecsPath]\n    })\n  )\n\n  const routes = [\n    {\n      route: '/',\n      path: path.resolve(dclKernelPath, 'preview.html'),\n      type: 'text/html'\n    },\n    {\n      route: '/favicon.ico',\n      path: path.resolve(dclKernelPath, 'favicon.ico'),\n      type: 'text/html'\n    },\n    {\n      route: '/@/artifacts/index.js',\n      path: path.resolve(dclKernelPath, 'index.js'),\n      type: 'text/javascript'\n    }\n  ]\n\n  for (const route of routes) {\n    router.get(route.route, async (_ctx) => {\n      return {\n        headers: { 'Content-Type': route.type },\n        body: fs.createReadStream(route.path)\n      }\n    })\n  }\n\n  function createStaticRoutes(route: string, folder: string, transform = (str: string) => str) {\n    router.get(route, async (ctx, next) => {\n      const file = ctx.params.path\n      const fullPath = path.resolve(folder, transform(file))\n\n      // only return files IF the file is within a baseFolder\n      if (!fs.existsSync(fullPath)) {\n        return next()\n      }\n\n      const headers: Record<string, any> = {\n        'x-timestamp': Date.now(),\n        'x-sent': true,\n        'cache-control': 'no-cache,private,max-age=1'\n      }\n\n      if (fullPath.endsWith('.wasm')) {\n        headers['content-type'] = 'application/wasm'\n      }\n\n      return {\n        headers,\n        body: fs.createReadStream(fullPath)\n      }\n    })\n  }\n\n  createStaticRoutes('/images/decentraland-connect/:path+', dclKernelImagesDecentralandConnect)\n  createStaticRoutes('/@/artifacts/unity-renderer/:path+', dclUnityRenderer, (filePath) =>\n    filePath.replace(/.br+$/, '')\n  )\n  createStaticRoutes('/@/artifacts/loader/:path+', dclKernelLoaderPath)\n  createStaticRoutes('/default-profile/:path+', dclKernelDefaultProfilePath)\n\n  router.get('/feature-flags/:file', async (ctx) => {\n    const res = await fetch(`https://feature-flags.decentraland.zone/${ctx.params.file}`, {\n      headers: {\n        connection: 'close'\n      }\n    })\n    return {\n      body: await res.arrayBuffer()\n    }\n  })\n}\n\nfunction entityV3FromFolder({\n  folder,\n  addOriginalPath,\n  ignorePattern,\n  customHashMaker\n}: {\n  folder: string\n  addOriginalPath?: boolean\n  ignorePattern?: string\n  customHashMaker?: (str: string) => string\n}): Entity | null {\n  const sceneJsonPath = path.resolve(folder, './scene.json')\n  let isParcelScene = true\n\n  const wearableJsonPath = path.resolve(folder, './wearable.json')\n  if (fs.existsSync(wearableJsonPath)) {\n    try {\n      const wearableJson = JSON.parse(fs.readFileSync(wearableJsonPath).toString())\n      if (!WearableJson.validate(wearableJson)) {\n        const errors = (WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('')\n\n        console.error(`Unable to validate wearable.json properly, please check it.`, errors)\n        console.error(`Invalid wearable.json (${wearableJsonPath})`)\n      } else {\n        isParcelScene = false\n      }\n    } catch (err) {\n      console.error(`Unable to load wearable.json properly`, err)\n    }\n  }\n\n  const hashMaker = customHashMaker ? customHashMaker : defaultHashMaker\n\n  if (fs.existsSync(sceneJsonPath) && isParcelScene) {\n    const sceneJson = JSON.parse(fs.readFileSync(sceneJsonPath).toString())\n    const { base, parcels }: { base: string; parcels: string[] } = sceneJson.scene\n    const pointers = new Set<string>()\n    pointers.add(base)\n    parcels.forEach(($) => pointers.add($))\n\n    const mappedFiles = getFilesFromFolder({\n      folder,\n      addOriginalPath,\n      ignorePattern,\n      customHashMaker\n    })\n\n    return {\n      version: 'v3',\n      type: EntityType.SCENE,\n      id: hashMaker(folder),\n      pointers: Array.from(pointers),\n      timestamp: Date.now(),\n      metadata: sceneJson,\n      content: mappedFiles\n    }\n  }\n\n  return null\n}\n\nconst defaultDclIgnore = () =>\n  [\n    '.*',\n    'package.json',\n    'package-lock.json',\n    'yarn-lock.json',\n    'build.json',\n    'export',\n    'tsconfig.json',\n    'tslint.json',\n    'node_modules',\n    '*.ts',\n    '*.tsx',\n    'Dockerfile',\n    'dist',\n    'README.md',\n    '*.blend',\n    '*.fbx',\n    '*.zip',\n    '*.rar'\n  ].join('\\n')\n\nexport function getFilesFromFolder({\n  folder,\n  addOriginalPath,\n  ignorePattern,\n  customHashMaker\n}: {\n  folder: string\n  addOriginalPath?: boolean\n  ignorePattern?: string\n  customHashMaker?: (str: string) => string\n}): ContentMapping[] {\n  const hashMaker = customHashMaker ? customHashMaker : defaultHashMaker\n\n  const allFiles = globSync('**/*', {\n    cwd: folder,\n    dot: false,\n    absolute: true\n  })\n    .map((file) => {\n      try {\n        if (!fs.statSync(file).isFile()) return\n      } catch (err) {\n        return\n      }\n      const _folder = folder.replace(/\\\\/gi, '/')\n      const key = file.replace(_folder, '').replace(/^\\/+/, '')\n      return key\n    })\n    .filter(($) => !!$) as string[]\n\n  const ensureIgnorePattern = ignorePattern && ignorePattern !== '' ? ignorePattern : defaultDclIgnore()\n  const ig = ignore().add(ensureIgnorePattern)\n  const filteredFiles = ig.filter(allFiles)\n\n  const ret: (ContentMapping & { original_path: string | undefined })[] = []\n\n  for (const file of filteredFiles) {\n    const absolutePath = path.resolve(folder, file)\n    try {\n      if (!fs.statSync(absolutePath).isFile()) continue\n    } catch (err) {\n      console.log(err)\n      continue\n    }\n\n    const absoluteFolder = folder.replace(/\\\\/gi, '/')\n\n    const relativeFilePathToFolder = file.replace(absoluteFolder, '').replace(/^\\/+/, '')\n\n    ret.push({\n      file: relativeFilePathToFolder.toLowerCase(),\n      original_path: addOriginalPath ? absolutePath : undefined,\n      hash: hashMaker(absolutePath)\n    })\n  }\n\n  return ret\n}\n"]}