@dcl/sdk 7.0.0-2536021667.commit-17c845c

package/src/setupProxy.js

@@ -0,0 +1,165 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var path = require("path");
+var fs = require("fs");
+var setupUtils_1 = require("./cli/setupUtils");
+var mock_catalyst_1 = require("./cli/mock-catalyst");
+var wearables_1 = require("./cli/wearables");
+var schemas_1 = require("@dcl/schemas");
+var setupProxy = function (dcl, app) {
+    // first resolve all dependencies in the local current working directory
+    // second try to resolve dependencies in @dcl/sdk folder
+    /**
+     * to test locally with linked packages:
+     *
+     * 1. go to explorer/kernel/static and run `npm link`
+     * 2. in an empty folder create a test scene with `dcl init`
+     * 3. in that folder run `npm install folder-to/@dcl/sdk`
+     * 4. install whatever version of `@dcl/unity-renderer` you want to test
+     * 5. link kernel using `npm link @dcll/kernel` this will use the folder from step 1
+     */
+    var ecsPath = path.dirname(require.resolve('@dcl/sdk/package.json', {
+        paths: [
+            dcl.getWorkingDir(),
+            __dirname + '/../../',
+            __dirname + '/../../../',
+            __dirname + '/../'
+        ]
+    }));
+    var dclKernelPath = path.dirname(require.resolve('@dcl/kernel/package.json', {
+        paths: [dcl.getWorkingDir(), ecsPath]
+    }));
+    var dclKernelDefaultProfilePath = path.resolve(dclKernelPath, 'default-profile');
+    var dclKernelImagesDecentralandConnect = path.resolve(dclKernelPath, 'images', 'decentraland-connect');
+    var dclKernelLoaderPath = path.resolve(dclKernelPath, 'loader');
+    var dclUnityRenderer = path.dirname(require.resolve('@dcl/unity-renderer/package.json', {
+        paths: [dcl.getWorkingDir(), ecsPath]
+    }));
+    var baseSceneFolders = [dcl.getWorkingDir()];
+    var baseWearableFolders = [dcl.getWorkingDir()];
+    // TODO: merge types from github.com/decentraland/cli
+    if (dcl.workspace) {
+        var projects = dcl.workspace.getAllProjects();
+        if (!!(projects === null || projects === void 0 ? void 0 : projects.length)) {
+            var _a = projects.reduce(function (acc, project) {
+                var projectType = project.getInfo().sceneType;
+                var projectDir = project.getProjectWorkingDir();
+                if (projectType === schemas_1.sdk.ProjectType.SCENE ||
+                    projectType === schemas_1.sdk.ProjectType.SMART_ITEM)
+                    acc.scenes.push(projectDir);
+                if (projectType === schemas_1.sdk.ProjectType.PORTABLE_EXPERIENCE)
+                    acc.wearables.push(projectDir);
+                return acc;
+            }, { wearables: [], scenes: [] }), wearables = _a.wearables, scenes = _a.scenes;
+            baseSceneFolders = scenes;
+            baseWearableFolders = wearables;
+        }
+    }
+    try {
+        (0, mock_catalyst_1.mockCatalyst)(app, __spreadArray(__spreadArray([], baseSceneFolders, true), baseWearableFolders, true));
+    }
+    catch (err) {
+        console.error("Fatal error, couldn't mock the catalyst", err);
+    }
+    try {
+        (0, wearables_1.mockPreviewWearables)(app, baseWearableFolders);
+    }
+    catch (err) {
+        console.error("Fatal error, couldn't mock the wearables", err);
+    }
+    var 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'
+        }
+    ];
+    var _loop_1 = function (route) {
+        app.get(route.route, function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+            var contentFile;
+            return __generator(this, function (_a) {
+                res.setHeader('Content-Type', route.type);
+                contentFile = fs.readFileSync(route.path);
+                res.send(contentFile);
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    for (var _i = 0, routes_1 = routes; _i < routes_1.length; _i++) {
+        var route = routes_1[_i];
+        _loop_1(route);
+    }
+    (0, setupUtils_1.createStaticRoutes)(app, '/images/decentraland-connect/*', dclKernelImagesDecentralandConnect);
+    (0, setupUtils_1.createStaticRoutes)(app, '/@/artifacts/unity-renderer/*', dclUnityRenderer, function (filePath) { return filePath.replace(/.br+$/, ''); });
+    (0, setupUtils_1.createStaticRoutes)(app, '/@/artifacts/loader/*', dclKernelLoaderPath);
+    (0, setupUtils_1.createStaticRoutes)(app, '/default-profile/*', dclKernelDefaultProfilePath);
+    app.get('/feature-flags/:file', function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var featureFlagResponse, featureFlagBody;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch("https://feature-flags.decentraland.zone/" + req.params.file)];
+                case 1:
+                    featureFlagResponse = _a.sent();
+                    return [4 /*yield*/, featureFlagResponse.json()];
+                case 2:
+                    featureFlagBody = _a.sent();
+                    return [2 /*return*/, res.json(featureFlagBody)];
+            }
+        });
+    }); });
+};
+module.exports = setupProxy;

package/types/@decentraland/CommunicationsController/index.d.ts

@@ -0,0 +1,7 @@
+declare module '@decentraland/CommunicationsController' {
+  /**
+   * Send the comms transmission
+   * @param message
+   */
+  export function send(message: string): Promise<void>
+}

package/types/@decentraland/EnvironmentAPI/index.d.ts

@@ -0,0 +1,45 @@
+declare module '@decentraland/EnvironmentAPI' {
+  export type Realm = {
+    domain: string
+    /** @deprecated use room instead */
+    layer: string
+    room: string
+    serverName: string
+    displayName: string
+  }
+
+  export type ExplorerConfiguration = {
+    clientUri: string
+    configurations: Record<string, string | number | boolean>
+  }
+
+  export const enum Platform {
+    DESKTOP = 'desktop',
+    BROWSER = 'browser'
+  }
+
+  /**
+   * Returns the current connected realm
+   */
+  export function getCurrentRealm(): Promise<Realm | undefined>
+
+  /**
+   * Returns whether the scene is running in preview mode or not
+   */
+  export function isPreviewMode(): Promise<boolean>
+
+  /**
+   * Returns explorer configuration and environment information
+   */
+  export function getExplorerConfiguration(): Promise<ExplorerConfiguration>
+
+  /**
+   * Returns what platform is running the scene
+   */
+  export function getPlatform(): Promise<Platform>
+
+  /**
+   * Returns Decentraland's time
+   */
+  export function getDecentralandTime(): Promise<{ seconds: number }>
+}

package/types/@decentraland/EthereumController/index.d.ts

@@ -0,0 +1,47 @@
+declare module '@decentraland/EthereumController' {
+  export type RPCSendableMessage = {
+    jsonrpc: '2.0'
+    id: number
+    method: string
+    params: any[]
+  }
+
+  export interface MessageDict {
+    [key: string]: string
+  }
+
+  /**
+   * Requires a generic payment in ETH or ERC20.
+   * @param  {string} [toAddress] - NFT asset id.
+   * @param  {number} [amount] - Exact amount of the order.
+   * @param  {string} [currency] - ETH or ERC20 supported token symbol
+   */
+  export function requirePayment(toAddress: string, amount: number, currency: string): Promise<any>
+
+  /**
+   * Takes a dictionary, converts it to string with correct format and signs it.
+   * @param  {messageToSign} [MessageDict] - Message in an object format.
+   * @return {object} - Promise of message and signature in an object.
+   */
+  export function signMessage(
+    message: MessageDict
+  ): Promise<{ message: string; hexEncodedMessage: string; signature: string }>
+
+  /**
+   * Takes a message string, parses it and converts to object.
+   * @param  {message} [string] - Message in a string format.
+   * @return {object} - Promise of message as a MessageDict.
+   * @internal
+   */
+  export function convertMessageToObject(message: string): Promise<MessageDict>
+
+  /**
+   * Used to build a Ethereum provider
+   */
+  export function sendAsync(message: RPCSendableMessage): Promise<any>
+
+  /**
+   * Returns the user's public key (address)
+   */
+  export function getUserAccount(): Promise<string>
+}

package/types/@decentraland/Identity/index.d.ts

@@ -0,0 +1,42 @@
+declare module '@decentraland/Identity' {
+  export type ColorString = string
+
+  export type Snapshots = {
+    // @deprecated
+    face: string
+    // @deprecated
+    face256: string
+    // @deprecated
+    face128: string
+    // @deprecated
+    body: string
+  }
+
+  export type AvatarForUserData = {
+    bodyShape: WearableId
+    skinColor: ColorString
+    hairColor: ColorString
+    eyeColor: ColorString
+    wearables: WearableId[]
+    snapshots: Snapshots
+  }
+
+  export type UserData = {
+    displayName: string
+    publicKey: string | null
+    hasConnectedWeb3: boolean
+    userId: string
+    version: number
+    avatar: AvatarForUserData
+  }
+
+  /**
+   * Return the Ethereum address of the user
+   */
+  export function getUserPublicKey(): Promise<string | null>
+
+  /**
+   * Return the user's data
+   */
+  export function getUserData(): Promise<UserData | null>
+}

package/types/@decentraland/ParcelIdentity/index.d.ts

@@ -0,0 +1,49 @@
+declare module '@decentraland/ParcelIdentity' {
+
+  export type ILand = {
+    sceneJsonData: SceneJsonData
+  }
+
+  export type SceneJsonData = {
+    display?: SceneDisplay
+    owner?: string
+    contact?: SceneContact
+    tags?: string[]
+    scene: SceneParcels
+    spawnPoints?: SceneSpawnPoint[]
+    requiredPermissions?: string[]
+  }
+
+  export type SceneDisplay = {
+    title?: string
+    favicon?: string
+    description?: string
+    navmapThumbnail?: string
+  }
+
+  export type SceneContact = {
+    name?: string
+    email?: string
+    url?: string
+  }
+
+  export type SceneParcels = {
+    base: string
+    parcels: string[]
+  }
+
+  export type SceneSpawnPoint = {
+    name?: string
+    position: {
+      x: number | number[]
+      y: number | number[]
+      z: number | number[]
+    }
+    default?: boolean
+  }
+
+  /**
+   * Returns the current parcel data
+   */
+  export function getParcel(): Promise<{ land: ILand; cid: string }>
+}

package/types/@decentraland/Players/index.d.ts

@@ -0,0 +1,47 @@
+declare module '@decentraland/Players' {
+  export type ColorString = string
+
+  export type Snapshots = {
+    // @deprecated
+    face: string
+    // @deprecated
+    face256: string
+    // @deprecated
+    face128: string
+    // @deprecated
+    body: string
+  }
+
+  export type AvatarForUserData = {
+    bodyShape: WearableId
+    skinColor: ColorString
+    hairColor: ColorString
+    eyeColor: ColorString
+    wearables: WearableId[]
+    snapshots: Snapshots
+  }
+
+  export type UserData = {
+    displayName: string
+    publicKey: string | null
+    hasConnectedWeb3: boolean
+    userId: string
+    version: number
+    avatar: AvatarForUserData
+  }
+
+  /**
+   * Return the players's data
+   */
+  export function getPlayerData(opt: { userId: string }): Promise<UserData | null>
+
+  /**
+   * Return array of connected players
+   */
+  export function getConnectedPlayers(): Promise<{ userId: string }[]>
+
+  /**
+   * Return array of players inside the scene
+   */
+  export function getPlayersInScene(): Promise<{ userId: string }[]>
+}

package/types/@decentraland/PortableExperiences/index.d.ts

@@ -0,0 +1,39 @@
+declare module '@decentraland/PortableExperiences' {
+  type PortableExperienceUrn = string
+  type PortableExperienceHandle = {
+    pid: PortableExperienceUrn
+    parentCid: string // Identifier of who triggered the PE to allow to kill it only to who created it
+  }
+  type PortableExperienceLoaded = {
+    portableExperiences: PortableExperienceHandle[]
+  }
+
+  /**
+   * Starts a portable experience.
+   * @param  {SpawnPortableExperienceParameters} [pid] - Information to identify the PE
+   *
+   * Returns the handle of the portable experience.
+   */
+  export function spawn(pid: PortableExperienceUrn): Promise<PortableExperienceHandle>
+
+  /**
+   * Stops a portable experience. Only the executor that spawned the portable experience has permission to kill it.
+   * @param  {string} [pid] - The portable experience process id
+   *
+   * Returns true if was able to kill the portable experience, false if not.
+   */
+  export function kill(pid: PortableExperienceUrn): Promise<boolean>
+
+  /**
+   * Stops a portable experience from the current running portable scene.
+   *
+   * Returns true if was able to kill the portable experience, false if not.
+   */
+  export function exit(): Promise<boolean>
+
+  /**
+   *
+   * Returns current portable experiences loaded with ids and parentCid
+   */
+  export function getPortableExperiencesLoaded(): Promise<PortableExperienceLoaded>
+}

package/types/@decentraland/RestrictedActions/index.d.ts

@@ -0,0 +1,41 @@
+declare module '@decentraland/RestrictedActions' {
+  /**
+   * move player to a position inside the scene
+   *
+   * @param position PositionType
+   * @param cameraTarget PositionType
+   */
+  export function movePlayerTo(newPosition: PositionType, cameraTarget?: PositionType): Promise<void>
+
+  export type PositionType = { x: number; y: number; z: number }
+
+  /**
+   * trigger an emote on the current player
+   *
+   * @param emote the emote to perform
+   */
+  export function triggerEmote(emote: Emote): Promise<void>
+
+  export type Emote = {
+    predefined: PredefinedEmote
+  }
+
+  export const enum PredefinedEmote {
+    WAVE = 'wave',
+    FIST_PUMP = 'fistpump',
+    ROBOT = 'robot',
+    RAISE_HAND = 'raiseHand',
+    CLAP = 'clap',
+    MONEY = 'money',
+    KISS = 'kiss',
+    TIK = 'tik',
+    HAMMER = 'hammer',
+    TEKTONIK = 'tektonik',
+    DONT_SEE = 'dontsee',
+    HANDS_AIR = 'handsair',
+    SHRUG = 'shrug',
+    DISCO = 'disco',
+    DAB = 'dab',
+    HEAD_EXPLODDE = 'headexplode'
+  }
+}

package/types/@decentraland/SignedFetch/index.d.ts

@@ -0,0 +1,16 @@
+declare module '@decentraland/SignedFetch' {
+  export type FlatFetchResponse = {
+    ok: boolean
+    status: number
+    statusText: string
+    headers: Record<string, string>
+    json?: any
+    text?: string
+  }
+
+  export type BodyType = 'json' | 'text'
+
+  export type FlatFetchInit = RequestInit & { responseBodyType?: BodyType }
+
+  export function signedFetch(url: string, init?: FlatFetchInit): Promise<FlatFetchResponse>
+}

package/types/@decentraland/SocialController/index.d.ts

@@ -0,0 +1 @@
+declare module '@decentraland/SocialController'

package/types/@decentraland/web3-provider/index.d.ts

@@ -0,0 +1,7 @@
+declare module '@decentraland/web3-provider' {
+  export type Provider = {
+    send: Function
+    sendAsync: Function
+  }
+  export function getProvider(): Promise<Provider>
+}