@threekit-tools/treble 0.0.10-alpha.13 → 0.0.12

package/dist/Treble/Snapshots.d.ts

@@ -0,0 +1,28 @@
+export declare type ISnapshotsCameras = undefined | string | Array<string | undefined>;
+interface SnapshotSize {
+    width: number;
+    height: number;
+}
+export interface ITakeSnapshotsConfig {
+    attributeName?: string;
+    output?: string;
+    format?: string;
+    size?: SnapshotSize;
+    filename?: string;
+}
+interface IGetSnapshot {
+    size: SnapshotSize;
+    format: string;
+}
+interface ISnapshots {
+    getSnapshot(snapshotConfig: IGetSnapshot): Promise<string>;
+    getSnapshots(cameras: Array<string | undefined>, snapshotConfig: Pick<ITakeSnapshotsConfig, 'attributeName' | 'format' | 'size'>): Promise<Array<string>>;
+    takeSnapshots(cameras: ISnapshotsCameras, config: ITakeSnapshotsConfig): Promise<void | string[] | Blob[] | null>;
+}
+declare class Snapshots implements ISnapshots {
+    constructor();
+    getSnapshot: ({ size, format }: IGetSnapshot) => Promise<string>;
+    getSnapshots: (cameras: Array<string | undefined>, snapshotConfig: Pick<ITakeSnapshotsConfig, 'attributeName' | 'format' | 'size'>) => Promise<string[]>;
+    takeSnapshots: (camerasList: ISnapshotsCameras, snapshotsConfig: ITakeSnapshotsConfig) => Promise<void | string[] | Blob[] | null>;
+}
+export default Snapshots;

package/dist/Treble/Snapshots.js

@@ -0,0 +1,280 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var api_1 = __importDefault(require("../api"));
+var connection_1 = __importDefault(require("../connection"));
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var DEFAULT_CAMERA_CONFIG = {
+    filename: "snapshot",
+    size: { width: 1920, height: 1080 },
+    format: constants_1.SNAPSHOT_FORMATS.png,
+    attributeName: constants_1.ATTRIBUTES_RESERVED.camera,
+    output: constants_1.SNAPSHOT_OUTPUTS.blob,
+};
+var cameraValues;
+var getCameraValue = function (cameraAttrName) {
+    if (cameraAttrName === void 0) { cameraAttrName = constants_1.ATTRIBUTES_RESERVED.camera; }
+    var attribute = window.threekit.configurator
+        .getDisplayAttributes()
+        .find(function (el) { return el.name === cameraAttrName; });
+    if (!attribute)
+        return undefined;
+    return attribute.value;
+};
+var getCamerasMap = function (cameraAttrName) {
+    if (cameraAttrName === void 0) { cameraAttrName = constants_1.ATTRIBUTES_RESERVED.camera; }
+    if (cameraValues)
+        return cameraValues;
+    var attribute = window.threekit.configurator
+        .getDisplayAttributes()
+        .find(function (el) { return el.name === cameraAttrName; });
+    if (!attribute) {
+        cameraValues = {};
+        return cameraValues;
+    }
+    var cameraAttribute = attribute;
+    cameraAttribute.values.forEach(function (el) {
+        var _a;
+        var value = cameraAttribute.type === constants_1.ATTRIBUTE_TYPES.asset
+            ? { assetId: el.assetId }
+            : el.value;
+        cameraValues = Object.assign(cameraValues || {}, (_a = {},
+            _a[el.label] = value,
+            _a));
+    }, {});
+    return cameraValues;
+};
+var Snapshots = /** @class */ (function () {
+    function Snapshots() {
+        var _this = this;
+        this.getSnapshot = function (_a) {
+            var size = _a.size, format = _a.format;
+            return window.threekit.player.snapshotAsync({
+                size: size,
+                mimeType: "image/".concat(constants_1.SNAPSHOT_FORMATS[format]),
+            });
+        };
+        this.getSnapshots = function (cameras, snapshotConfig) {
+            var attributeName = snapshotConfig.attributeName || DEFAULT_CAMERA_CONFIG.attributeName;
+            var size = snapshotConfig.size || DEFAULT_CAMERA_CONFIG.size;
+            var format = snapshotConfig.format || DEFAULT_CAMERA_CONFIG.format;
+            var camerasMap = getCamerasMap(attributeName);
+            if (!camerasMap)
+                return Promise.resolve([]);
+            var snapshots = [];
+            return cameras.reduce(function (snapshotPromise, camera) {
+                return snapshotPromise.then(function () {
+                    return new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
+                        var snapshotStr;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    if (!camera) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, window.threekit.configurator.setConfiguration((_a = {},
+                                            _a[attributeName] = camerasMap[camera],
+                                            _a))];
+                                case 1:
+                                    _b.sent();
+                                    _b.label = 2;
+                                case 2: return [4 /*yield*/, this.getSnapshot({ size: size, format: format })];
+                                case 3:
+                                    snapshotStr = _b.sent();
+                                    snapshots.push(snapshotStr);
+                                    resolve(snapshots);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                });
+            }, Promise.resolve(snapshots));
+        };
+        this.takeSnapshots = function (camerasList, snapshotsConfig) { return __awaiter(_this, void 0, void 0, function () {
+            // function getSnapshot() {
+            //   return window.threekit.player.snapshotAsync({
+            //     size,
+            //     mimeType: `image/${SNAPSHOT_FORMATS[format]}`,
+            //   })
+            // }
+            // function getSnapshots(
+            //   cameras: Array<string | undefined>,
+            //   camerasMap: CamerasMap
+            // ) {
+            //   let snapshots: Array<string> = []
+            //   return cameras.reduce((snapshotPromise, camera) => {
+            //     return snapshotPromise.then(
+            //       () =>
+            //         new Promise(async (resolve) => {
+            //           if (camera)
+            //             await window.threekit.configurator.setConfiguration({
+            //               [attributeName]: camerasMap[camera],
+            //             })
+            //           const snapshotStr = await getSnapshot()
+            //           snapshots.push(snapshotStr)
+            //           resolve(snapshots)
+            //         })
+            //     )
+            //   }, Promise.resolve(snapshots))
+            // }
+            function saveSnapshotToPlatform(snapshot, filename) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var files, response;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                files = (0, utils_1.dataURItoFile)(snapshot, filename);
+                                return [4 /*yield*/, api_1.default.configurations.save({
+                                        assetId: window.threekit.player.assetId,
+                                        configuration: window.threekit.configurator.getConfiguration(),
+                                        files: files,
+                                    })];
+                            case 1:
+                                response = _a.sent();
+                                return [2 /*return*/, "".concat(threekitDomain, "/api/files/hash/").concat(response.data.thumbnail)];
+                        }
+                    });
+                });
+            }
+            function downloadSnapshot(snapshot, filename) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var blob, blobUrl, link, clickHandler;
+                    return __generator(this, function (_a) {
+                        blob = (0, utils_1.dataURItoBlob)(snapshot);
+                        blobUrl = URL.createObjectURL(blob);
+                        link = document.createElement('a');
+                        link.href = blobUrl;
+                        link.download = filename;
+                        clickHandler = function () {
+                            setTimeout(function () {
+                                URL.revokeObjectURL(blobUrl);
+                                link.removeEventListener('click', clickHandler);
+                            }, 150);
+                        };
+                        link.addEventListener('click', clickHandler);
+                        document.body.appendChild(link);
+                        link.click();
+                        return [2 /*return*/];
+                    });
+                });
+            }
+            var threekitDomain, filename, size, format, attributeName, output, cameras, snapshotsRaw, snapshotData, camerasMap_1, currentCamera, cameraPosition, _a, savedSnapshots, snapshotBlobs, snapshotFiles;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        threekitDomain = connection_1.default.getConnection().threekitDomain;
+                        filename = (snapshotsConfig === null || snapshotsConfig === void 0 ? void 0 : snapshotsConfig.filename) || DEFAULT_CAMERA_CONFIG.filename;
+                        size = (snapshotsConfig === null || snapshotsConfig === void 0 ? void 0 : snapshotsConfig.size) || DEFAULT_CAMERA_CONFIG.size;
+                        format = (snapshotsConfig === null || snapshotsConfig === void 0 ? void 0 : snapshotsConfig.format) || DEFAULT_CAMERA_CONFIG.format;
+                        attributeName = (snapshotsConfig === null || snapshotsConfig === void 0 ? void 0 : snapshotsConfig.attributeName) || DEFAULT_CAMERA_CONFIG.attributeName;
+                        output = (snapshotsConfig === null || snapshotsConfig === void 0 ? void 0 : snapshotsConfig.output) || DEFAULT_CAMERA_CONFIG.output;
+                        cameras = Array.isArray(camerasList) ? camerasList : [camerasList];
+                        if (!(cameras.length === 1 && cameras[0] === undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getSnapshot({ size: size, format: format })];
+                    case 1:
+                        snapshotData = _c.sent();
+                        snapshotsRaw = [snapshotData];
+                        return [3 /*break*/, 5];
+                    case 2:
+                        camerasMap_1 = getCamerasMap(attributeName);
+                        if (!camerasMap_1)
+                            return [2 /*return*/, null];
+                        cameras = cameras.filter(function (el) { return el === undefined || Object.keys(camerasMap_1).includes(el); });
+                        currentCamera = getCameraValue(attributeName);
+                        cameraPosition = (0, utils_1.getCameraPosition)(window.threekit.player.camera);
+                        return [4 /*yield*/, this.getSnapshots(cameras, camerasMap_1)];
+                    case 3:
+                        snapshotsRaw = _c.sent();
+                        return [4 /*yield*/, window.threekit.configurator.setConfiguration((_b = {},
+                                _b[attributeName] = currentCamera,
+                                _b))];
+                    case 4:
+                        _c.sent();
+                        (0, utils_1.setCameraPosition)(window.threekit.player.camera, cameraPosition);
+                        _c.label = 5;
+                    case 5:
+                        _a = output;
+                        switch (_a) {
+                            case constants_1.SNAPSHOT_OUTPUTS.url: return [3 /*break*/, 6];
+                            case constants_1.SNAPSHOT_OUTPUTS.download: return [3 /*break*/, 8];
+                            case constants_1.SNAPSHOT_OUTPUTS.blob: return [3 /*break*/, 9];
+                            case constants_1.SNAPSHOT_OUTPUTS.file: return [3 /*break*/, 10];
+                            case constants_1.SNAPSHOT_OUTPUTS.dataUrl: return [3 /*break*/, 11];
+                        }
+                        return [3 /*break*/, 11];
+                    case 6: return [4 /*yield*/, Promise.all(snapshotsRaw.map(function (snapshotBlob, idx) {
+                            var cameraName = (camerasList === null || camerasList === void 0 ? void 0 : camerasList[idx])
+                                ? "-".concat((0, utils_1.regularToKebabCase)(camerasList[idx] || 'default'))
+                                : '';
+                            return saveSnapshotToPlatform(snapshotBlob, "".concat(filename).concat(cameraName, ".").concat(format));
+                        }))];
+                    case 7:
+                        savedSnapshots = _c.sent();
+                        return [2 /*return*/, Promise.resolve(savedSnapshots)];
+                    case 8:
+                        snapshotsRaw.forEach(function (snapshotBlob, idx) {
+                            var cameraName = (camerasList === null || camerasList === void 0 ? void 0 : camerasList[idx])
+                                ? "-".concat((0, utils_1.regularToKebabCase)(camerasList[idx] || 'default'))
+                                : '';
+                            downloadSnapshot(snapshotBlob, "".concat(filename).concat(cameraName, ".").concat(format));
+                        });
+                        return [2 /*return*/, Promise.resolve()];
+                    case 9:
+                        snapshotBlobs = snapshotsRaw.map(function (el) { return (0, utils_1.dataURItoBlob)(el); });
+                        return [2 /*return*/, Promise.resolve(snapshotBlobs)];
+                    case 10:
+                        snapshotFiles = snapshotsRaw.map(function (el, idx) {
+                            var cameraName = (camerasList === null || camerasList === void 0 ? void 0 : camerasList[idx])
+                                ? "-".concat((0, utils_1.regularToKebabCase)(camerasList[idx] || 'default'))
+                                : '';
+                            return (0, utils_1.dataURItoFile)(el, "".concat(filename).concat(cameraName, ".").concat(format));
+                        });
+                        return [2 /*return*/, Promise.resolve(snapshotFiles)];
+                    case 11: return [2 /*return*/, Promise.resolve(snapshotsRaw)];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        }); };
+    }
+    return Snapshots;
+}());
+exports.default = Snapshots;

package/dist/Treble/Treble.d.ts

@@ -1,44 +1,26 @@
 import threekitAPI from '../api';
 import { IThreekitPlayer, IMetadata } from '../threekit';
-import { IConfigurationResponse } from '../http/configurations';
+import { IWishlist } from './Wishlist';
+import Snapshots from './Snapshots';
 interface ITreble {
     player: IThreekitPlayer;
 }
-export declare type ISnapshotsCameras = undefined | string | Array<string | undefined>;
-export interface ITakeSnapshotsConfig {
-    attributeName?: string;
-    output?: string;
-    format?: string;
-    size?: {
-        width: number;
-        height: number;
-    };
-    filename?: string;
-}
 export interface ISaveConfigurationConfig {
     customerId?: string;
     metadata?: IMetadata;
     productVersion?: string;
-    snapshot?: true | {
-        camera: string | undefined;
-        config: ITakeSnapshotsConfig;
-    };
 }
 declare class Treble {
     _api: typeof threekitAPI;
     _player: IThreekitPlayer;
-    private _cameraValues?;
-    private _wishlist?;
+    wishlist: IWishlist;
+    private _snapshots;
+    takeSnapshots: Snapshots['takeSnapshots'];
     constructor({ player }: ITreble);
-    private _getCameraValue;
-    private _getCamerasMap;
-    takeSnapshots(cameras: ISnapshotsCameras, config: ITakeSnapshotsConfig): Promise<void | string[] | Blob[] | null>;
-    saveConfiguration(config?: ISaveConfigurationConfig): Promise<(IConfigurationResponse & {
+    saveConfiguration: (config?: ISaveConfigurationConfig | undefined) => Promise<{
+        resumableUrl: string;
+    } & import("../http/configurations").IConfigurationResponse & {
         thumbnail: string;
-    }) | null>;
-    getWishlist(): Promise<IConfigurationResponse[]>;
-    addToWishlist(config?: ISaveConfigurationConfig): Promise<IConfigurationResponse[]>;
-    removeFromWishlist(idx: number): IConfigurationResponse[];
-    clearWishlist(): IConfigurationResponse[];
+    }>;
 }
 export default Treble;