@threekit-tools/treble 0.0.57 → 0.0.60

package/dist/components/containers/formInputContainer.js

@@ -29,15 +29,13 @@ var prepAttributeForComponent = function (attribute, config) {
     var descriptionKey = metadataKeyDescription || constants_1.METADATA_RESERVED.description;
     var options;
     var selected = attribute.value;
-    if (attribute.type === constants_1.ATTRIBUTE_TYPES.string) {
-        var stringAttribute = attribute;
-        options = stringAttribute.values.map(function (el) { return (__assign(__assign({}, el), { name: el.label })); });
+    if (attribute.type === 'String') {
+        options = attribute.values.map(function (el) { return (__assign(__assign({}, el), { name: el.label })); });
     }
-    else if (attribute.type === constants_1.ATTRIBUTE_TYPES.asset) {
-        var assetAttribute = attribute;
-        selected = (_a = assetAttribute.value) === null || _a === void 0 ? void 0 : _a.assetId;
-        options = assetAttribute.values
-            ? assetAttribute.values
+    else if (attribute.type === 'Asset') {
+        selected = (_a = attribute.value) === null || _a === void 0 ? void 0 : _a.assetId;
+        options = attribute.values
+            ? attribute.values
                 .map(function (el) { return prepCatalogItem(el); })
                 .sort(function (a, b) {
                 if (!sort || !Object.keys(constants_1.SORT_OPTIONS).includes(sort))
@@ -50,9 +48,8 @@ var prepAttributeForComponent = function (attribute, config) {
             })
             : [];
     }
-    else if (attribute.type === constants_1.ATTRIBUTE_TYPES.color) {
-        var colorAttribute = attribute;
-        selected = (0, utils_1.inflateRgb)(colorAttribute.value);
+    else if (attribute.type === 'Color') {
+        selected = (0, utils_1.inflateRgb)(attribute.value);
     }
     function prepCatalogItem(item) {
         var _a, _b;
@@ -80,9 +77,7 @@ var prepAttributeForComponent = function (attribute, config) {
     return { selected: selected, options: options };
 };
 exports.prepAttributeForComponent = prepAttributeForComponent;
-function formComponentContainer(FormComponent
-// FormComponent: IFormComponent<P>
-) {
+function formComponentContainer(FormComponent) {
     return function (props) {
         var attribute = props.attribute, metadataKeyThumbnail = props.metadataKeyThumbnail, metadataKeyDescription = props.metadataKeyDescription, metadataKeyPrice = props.metadataKeyPrice, hideAttributeTitle = props.hideAttributeTitle, sort = props.sort;
         var isLoading = (0, usePlayerLoadingStatus_1.default)();
@@ -104,7 +99,7 @@ function formComponentContainer(FormComponent
             sort: sort,
         }), selected = _b.selected, options = _b.options;
         var handleSetAttribute = function (value) {
-            return setAttribute && setAttribute(value);
+            return setAttribute === null || setAttribute === void 0 ? void 0 : setAttribute(value);
         };
         var preppedProps = __assign({}, props);
         if (!hideAttributeTitle && !preppedProps.title)

package/dist/connection.d.ts

@@ -1,14 +1,16 @@
-interface IConnectionConfig {
+export interface IConnectionConfig {
     authToken?: string;
     orgId?: string;
     assetId?: string;
     threekitDomain?: string;
+    serverUrl?: string;
 }
 export declare class ThreekitConnection {
     _authToken: string;
     _orgId: string;
     _assetId: string;
     _threekitDomain: string;
+    _serverUrl: string;
     constructor();
     connect(config: IConnectionConfig): Promise<void>;
     getConnection(): {
@@ -16,6 +18,7 @@ export declare class ThreekitConnection {
         orgId: string;
         assetId: string;
         threekitDomain: string;
+        serverUrl: string;
     };
 }
 declare const _default: ThreekitConnection;

package/dist/connection.js

@@ -42,6 +42,7 @@ var ThreekitConnection = /** @class */ (function () {
         this._authToken = '';
         this._orgId = '';
         this._assetId = '';
+        this._serverUrl = '';
         this._threekitDomain = 'https://admin-fts.threekit.com';
     }
     ThreekitConnection.prototype.connect = function (config) {
@@ -53,6 +54,8 @@ var ThreekitConnection = /** @class */ (function () {
                     this._orgId = config.orgId;
                 if (config.assetId)
                     this._assetId = config.assetId;
+                if (config.serverUrl)
+                    this._serverUrl = config.serverUrl;
                 if (config.threekitDomain)
                     this._threekitDomain = "https://".concat(config.threekitDomain);
                 return [2 /*return*/];
@@ -68,6 +71,7 @@ var ThreekitConnection = /** @class */ (function () {
             orgId: this._orgId,
             assetId: this._assetId,
             threekitDomain: this._threekitDomain,
+            serverUrl: this._serverUrl,
         };
     };
     return ThreekitConnection;

package/dist/hooks/useAttribute/index.d.ts

@@ -1,8 +1,8 @@
-import { IThreekitDisplayAttribute, IConfigurationColor } from '../../threekit';
+import { IHydratedAttribute, IConfigurationColor } from '../../threekit';
 export declare type RawAttributeValue = string | number | boolean | IConfigurationColor | File | undefined;
 declare type UseAttributeError = [undefined, undefined];
 declare type UseAttributeSuccess = [
-    IThreekitDisplayAttribute,
+    IHydratedAttribute,
     (val: RawAttributeValue) => Promise<void>
 ];
 declare type UseAttributeHook = UseAttributeError | UseAttributeSuccess;

package/dist/hooks/useAttribute/index.js

@@ -42,13 +42,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var store_1 = require("../../store");
 var attributes_1 = require("../../store/attributes");
 var utils_1 = require("../../utils");
-var constants_1 = require("../../constants");
 var api_1 = __importDefault(require("../../api"));
 var useAttribute = function (attributeName) {
     if (!attributeName)
         return [undefined, undefined];
     var dispatch = (0, store_1.useThreekitDispatch)();
-    var attributes = (0, store_1.useThreekitSelector)(attributes_1.getAttributes);
+    var attributes = (0, store_1.useThreekitSelector)(attributes_1.getHydratedAttributes);
     if (!attributeName || !attributes)
         return [undefined, undefined];
     var attribute = attributes[attributeName];
@@ -60,8 +59,7 @@ var useAttribute = function (attributeName) {
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    if (!(attribute.type === 'Asset' &&
-                        attribute.assetType === constants_1.ASSET_TYPES.upload)) return [3 /*break*/, 4];
+                    if (!(attribute.type === 'Asset' && attribute.assetType === 'upload')) return [3 /*break*/, 4];
                     if (!!value) return [3 /*break*/, 1];
                     preppedValue = (0, utils_1.selectionToConfiguration)('', attribute.type);
                     return [3 /*break*/, 3];

package/dist/hooks/useConfigurator/index.d.ts

@@ -1,7 +1,7 @@
-import { ISetConfiguration, IThreekitDisplayAttribute } from '../../threekit';
+import { ISetConfiguration, IHydratedAttribute } from '../../threekit';
 declare type UseConfiguratorError = [undefined, undefined];
 declare type UseConfiguratorSuccess = [
-    Record<string, IThreekitDisplayAttribute>,
+    Record<string, IHydratedAttribute>,
     (configuration: ISetConfiguration) => void
 ];
 declare type UseConfiguratorHook = UseConfiguratorError | UseConfiguratorSuccess;

package/dist/hooks/useConfigurator/index.js

@@ -4,7 +4,7 @@ var attributes_1 = require("../../store/attributes");
 var store_1 = require("../../store");
 var useConfigurator = function () {
     var dispatch = (0, store_1.useThreekitDispatch)();
-    var attributes = (0, store_1.useThreekitSelector)(attributes_1.getAttributes);
+    var attributes = (0, store_1.useThreekitSelector)(attributes_1.getHydratedAttributes);
     if (!attributes)
         return [undefined, undefined];
     var handleChange = function (configuration) {

package/dist/hooks/useProductCache/index.d.ts

@@ -0,0 +1,14 @@
+import { CachedProduct } from '../../store/product';
+import { IReloadConfig } from '../../store/treble';
+interface CacheData {
+    activeProductIdx: number;
+    cache: Array<Pick<CachedProduct, 'name' | 'label' | 'thumbnail'>>;
+}
+declare type UseProductCache = [
+    CacheData,
+    (config?: string | IReloadConfig) => Promise<void>,
+    (idx: number) => Promise<void>,
+    (idx: number) => Promise<void>
+];
+declare const useProductCache: () => UseProductCache;
+export default useProductCache;

package/dist/hooks/useProductCache/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var product_1 = require("../../store/product");
+var store_1 = require("../../store");
+var useProductCache = function () {
+    var dispatch = (0, store_1.useThreekitDispatch)();
+    var cache = (0, store_1.useThreekitSelector)(product_1.getProductCache);
+    var activeProductIdx = (0, store_1.useThreekitSelector)(product_1.getActiveProductIdx);
+    var data = {
+        cache: cache,
+        activeProductIdx: activeProductIdx,
+    };
+    var handleChangeActiveProduct = function (idx) {
+        if (idx === undefined)
+            return Promise.resolve();
+        if (idx === activeProductIdx)
+            return Promise.resolve();
+        if (!cache || idx >= (cache === null || cache === void 0 ? void 0 : cache.length))
+            return Promise.resolve();
+        return dispatch((0, product_1.changeActiveProductIdx)(idx));
+    };
+    var handleLoadNewProduct = function (config) {
+        return dispatch((0, product_1.loadNewProduct)(config));
+    };
+    var handleRemoveProduct = function (idx) {
+        return dispatch((0, product_1.removeProductIdx)(idx));
+    };
+    return [
+        data,
+        handleLoadNewProduct,
+        handleChangeActiveProduct,
+        handleRemoveProduct,
+    ];
+};
+exports.default = useProductCache;

package/dist/hooks/useSingleAnimation/index.d.ts

@@ -0,0 +1,17 @@
+import { ICoordinates } from '../../threekit';
+interface NodeConfig {
+    nodeId: string;
+    paddingStart: number;
+    paddingEnd: number;
+    delay: number;
+    duration: number;
+    translation: ICoordinates;
+    rotation: ICoordinates;
+    scale: ICoordinates;
+}
+interface AnimationConfig {
+    duration: number;
+    nodes: Array<NodeConfig>;
+}
+declare const useAnimation: (animationConfig: AnimationConfig) => undefined[] | (boolean | (() => Promise<void>))[];
+export default useAnimation;

package/dist/hooks/useSingleAnimation/index.js

@@ -0,0 +1,264 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 react_1 = require("react");
+var useThreekitInitStatus_1 = __importDefault(require("../useThreekitInitStatus"));
+var utils_1 = require("../../utils");
+var prepAnimateConfig = function (config) {
+    return new Promise(function (resolve) { return __awaiter(void 0, void 0, void 0, function () {
+        var totalDuration, player, assetId, nodesRaw, nodes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    totalDuration = config.duration * 1000 || 0;
+                    player = window.threekit.player.enableApi('player');
+                    return [4 /*yield*/, player.getAssetInstance(window.threekit.player.scene.find({
+                            id: window.threekit.player.instanceId,
+                            plug: 'Proxy',
+                            property: 'asset',
+                        }))];
+                case 1:
+                    assetId = _a.sent();
+                    nodesRaw = Object.entries(config.nodes).reduce(function (output, _a) {
+                        var _b;
+                        var name = _a[0], nodeData = _a[1];
+                        var nodeId = window.threekit.player.scene.get({
+                            from: assetId,
+                            name: name,
+                        }).id;
+                        var node = Object.assign({ nodeId: nodeId }, { duration: (nodeData.duration || config.duration || 0) * 1000 }, { paddingStart: (nodeData.delay || 0) * 1000 }, 'translation' in nodeData
+                            ? {
+                                translation: [
+                                    window.threekit.player.scene.get({
+                                        from: assetId,
+                                        id: nodeId,
+                                        plug: 'Transform',
+                                        property: 'translation',
+                                    }),
+                                    Object.assign({ x: 0, y: 0, z: 0 }, nodeData.translation),
+                                ],
+                            }
+                            : {}, 'rotation' in nodeData
+                            ? {
+                                rotation: [
+                                    window.threekit.player.scene.get({
+                                        from: assetId,
+                                        id: nodeId,
+                                        plug: 'Transform',
+                                        property: 'rotation',
+                                    }),
+                                    Object.assign({ x: 0, y: 0, z: 0 }, nodeData.rotation),
+                                ],
+                            }
+                            : {}, 'scale' in nodeData
+                            ? {
+                                scale: [
+                                    window.threekit.player.scene.get({
+                                        from: assetId,
+                                        id: nodeId,
+                                        plug: 'Transform',
+                                        property: 'scale',
+                                    }),
+                                    Object.assign({ x: 0, y: 0, z: 0 }, nodeData.scale),
+                                ],
+                            }
+                            : {});
+                        var duration = node.duration + node.paddingStart;
+                        if (duration > totalDuration)
+                            totalDuration = duration;
+                        return Object.assign(output, (_b = {}, _b[name] = node, _b));
+                    }, {});
+                    nodes = Object.entries(nodesRaw).reduce(function (output, _a) {
+                        var _b;
+                        var nodeName = _a[0], nodeData = _a[1];
+                        var paddingEnd = 0;
+                        if (totalDuration !== nodeData.duration + nodeData.paddingStart)
+                            paddingEnd =
+                                totalDuration - (nodeData.duration + nodeData.paddingStart);
+                        return Object.assign(output, (_b = {},
+                            _b[nodeName] = __assign(__assign({}, nodeData), { paddingEnd: paddingEnd }),
+                            _b));
+                    }, {});
+                    resolve([assetId, totalDuration, nodes]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+};
+var useAnimation = function (animationConfig) {
+    var _a = (0, react_1.useState)(false), animationInProgress = _a[0], setAnimationInProgress = _a[1];
+    var ref = (0, react_1.useRef)({
+        assetId: undefined,
+        startTime: 0,
+        totalDuration: 0,
+        nodes: {},
+        isTransformed: false,
+    });
+    var isLoaded = (0, useThreekitInitStatus_1.default)();
+    if (!isLoaded)
+        return [undefined, undefined];
+    var animateFrame = function (timestamp) {
+        // if (startTime.current === undefined) startTime.current = timestamp;
+        // const elapsed = timestamp - startTime.current;
+        if (ref.current.startTime === undefined)
+            ref.current.startTime = timestamp;
+        var elapsed = timestamp - ref.current.startTime;
+        Object.values(ref.current.nodes).forEach(function (nodeConfig) {
+            if (!ref.current.isTransformed) {
+                //    If its too early we don't animate
+                if (elapsed < nodeConfig.paddingStart)
+                    return;
+                //    If its too early we don't animate
+                if (elapsed > nodeConfig.duration + nodeConfig.paddingStart)
+                    return;
+            }
+            else if (ref.current.isTransformed) {
+                //    If its too early we don't animate
+                if (elapsed < nodeConfig.paddingEnd)
+                    return;
+                //    If its too early we don't animate
+                if (elapsed > nodeConfig.duration + nodeConfig.paddingEnd)
+                    return;
+            }
+            var progressTime = !ref.current.isTransformed
+                ? elapsed - nodeConfig.paddingStart
+                : elapsed - nodeConfig.paddingEnd;
+            var animationPercent = (0, utils_1.easeInOutCubic)(progressTime / nodeConfig.duration);
+            var translation;
+            var rotation;
+            var scale;
+            if ('translation' in nodeConfig) {
+                translation = Object.keys(nodeConfig.translation[1]).reduce(function (output, axis) {
+                    var _a;
+                    var value = !ref.current.isTransformed
+                        ? nodeConfig.translation[0][axis] +
+                            nodeConfig.translation[1][axis] * animationPercent
+                        : nodeConfig.translation[1][axis] +
+                            nodeConfig.translation[0][axis] -
+                            nodeConfig.translation[1][axis] * animationPercent;
+                    return Object.assign(output, (_a = {}, _a[axis] = value, _a));
+                }, {});
+                window.threekit.player.scene.set({
+                    from: ref.current.assetId,
+                    id: nodeConfig.nodeId,
+                    plug: 'Transform',
+                    property: 'translation',
+                }, translation);
+            }
+            if ('rotation' in nodeConfig) {
+                rotation = Object.keys(nodeConfig.rotation[1]).reduce(function (output, axis) {
+                    var _a;
+                    var value = !ref.current.isTransformed
+                        ? nodeConfig.rotation[0][axis] +
+                            nodeConfig.rotation[1][axis] * animationPercent
+                        : nodeConfig.rotation[1][axis] +
+                            nodeConfig.rotation[0][axis] -
+                            nodeConfig.rotation[1][axis] * animationPercent;
+                    return Object.assign(output, (_a = {}, _a[axis] = value, _a));
+                }, {});
+                window.threekit.player.scene.set({
+                    from: ref.current.assetId,
+                    id: nodeConfig.nodeId,
+                    plug: 'Transform',
+                    property: 'rotation',
+                }, rotation);
+            }
+            if ('scale' in nodeConfig) {
+                scale = Object.keys(nodeConfig.scale[1]).reduce(function (output, axis) {
+                    var _a;
+                    var value = !ref.current.isTransformed
+                        ? nodeConfig.scale[0][axis] +
+                            nodeConfig.scale[1][axis] * animationPercent
+                        : nodeConfig.scale[1][axis] +
+                            nodeConfig.scale[0][axis] -
+                            nodeConfig.scale[1][axis] * animationPercent;
+                    return Object.assign(output, (_a = {}, _a[axis] = value, _a));
+                }, {});
+                window.threekit.player.scene.set({
+                    from: ref.current.assetId,
+                    id: nodeConfig.nodeId,
+                    plug: 'Transform',
+                    property: 'scale',
+                }, scale);
+            }
+        });
+        if (elapsed < ref.current.totalDuration) {
+            window.requestAnimationFrame(animateFrame);
+        }
+        else {
+            setAnimationInProgress(false);
+            ref.current.startTime = undefined;
+            ref.current.isTransformed = !ref.current.isTransformed;
+        }
+    };
+    var handleClickAnimate = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    ref.current.startTime = undefined;
+                    if (!!ref.current.nodes) return [3 /*break*/, 2];
+                    return [4 /*yield*/, prepAnimateConfig(animationConfig)];
+                case 1:
+                    _a = _b.sent(), ref.current.assetId = _a[0], ref.current.totalDuration = _a[1], ref.current.nodes = _a[2];
+                    ref.current.isTransformed = false;
+                    _b.label = 2;
+                case 2:
+                    setAnimationInProgress(true);
+                    window.requestAnimationFrame(animateFrame);
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    return [animationInProgress, handleClickAnimate];
+};
+exports.default = useAnimation;

package/dist/hooks/useWishlist/index.d.ts

@@ -1,7 +1,8 @@
-import { ISaveConfigurationConfig, WishlistArray } from '../../Treble';
+import { WishlistArray } from '../../Treble';
+import { ISaveConfiguration } from '../../api/configurations';
 declare type UseWishlistHook = [
     WishlistArray,
-    (config?: ISaveConfigurationConfig) => void,
+    (config?: Omit<ISaveConfiguration, 'configurator'>) => void,
     (idx: number) => void,
     (idx: number) => void,
     (idx: number) => void,

package/dist/hooks/useWishlist/index.js

@@ -14,9 +14,7 @@ var useWishlist = function () {
     var wishlist = (0, store_1.useThreekitSelector)(wishlist_1.getWishlist);
     if (!isLoaded)
         return [undefined, undefined, undefined, undefined, undefined, undefined];
-    var handleAddToWishlist = function (config) {
-        return dispatch((0, wishlist_1.addToWishlist)(config));
-    };
+    var handleAddToWishlist = function (config) { return dispatch((0, wishlist_1.addToWishlist)(config)); };
     var handleRemoveFromWishlist = function (idx) {
         dispatch((0, wishlist_1.removeFromWishlist)(idx));
         message_1.default.info('Item removed from wishlist');

package/dist/http/configurations.d.ts

@@ -13,6 +13,7 @@ export interface IConfigurationResponse {
     shortId: string;
     thumbnail: null | string;
     variant: IConfiguration;
+    attachments: Record<string, string>;
 }
 interface IConfigurationsResponse extends IMultiPageResponse {
     configurations: Array<IConfigurationResponse>;

package/dist/http/index.d.ts

@@ -3,11 +3,13 @@ import * as products from './products';
 import * as configurations from './configurations';
 import * as pricebook from './pricebook';
 import * as catalog from './catalog';
+import * as server from './server';
 declare const _default: {
     orders: typeof orders;
     products: typeof products;
     configurations: typeof configurations;
     pricebook: typeof pricebook;
     catalog: typeof catalog;
+    server: typeof server;
 };
 export default _default;

package/dist/http/index.js

@@ -24,10 +24,12 @@ var products = __importStar(require("./products"));
 var configurations = __importStar(require("./configurations"));
 var pricebook = __importStar(require("./pricebook"));
 var catalog = __importStar(require("./catalog"));
+var server = __importStar(require("./server"));
 exports.default = {
     orders: orders,
     products: products,
     configurations: configurations,
     pricebook: pricebook,
     catalog: catalog,
+    server: server,
 };

package/dist/http/server.d.ts

@@ -0,0 +1,14 @@
+export interface IPostEmailRequest {
+    From: string;
+    To: string;
+    TemplateId: string;
+    TemplateModel: Record<string, any>;
+}
+export interface IPostEmailResponse {
+    To: string;
+    SubmittedAt: string;
+    MessageID: string;
+    ErrorCode: 0;
+    Message: string;
+}
+export declare const postEmail: (data: IPostEmailRequest) => Promise<IPostEmailResponse>;

package/dist/http/server.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postEmail = void 0;
+var axios_1 = __importDefault(require("axios"));
+var connection_1 = __importDefault(require("../connection"));
+var postEmail = function (data) {
+    if (!data)
+        throw new Error('data missing');
+    var serverUrl = connection_1.default.getConnection().serverUrl;
+    if (!serverUrl)
+        throw new Error('missing server-url');
+    return axios_1.default.post("".concat(serverUrl, "/api/email"), data);
+};
+exports.postEmail = postEmail;

package/dist/index.js

@@ -39,6 +39,8 @@ var useShare_1 = __importDefault(require("./hooks/useShare"));
 exports.useShare = useShare_1.default;
 var usePlayerPortal_1 = __importDefault(require("./hooks/usePlayerPortal"));
 exports.usePlayerPortal = usePlayerPortal_1.default;
+// import useSingleAnimation from './hooks/useSingleAnimation';
+// import useProductCache from './hooks/useProductCache';
 //  Components
 var ThreekitProvider_1 = __importDefault(require("./components/ThreekitProvider"));
 exports.ThreekitProvider = ThreekitProvider_1.default;

package/dist/store/attributes.d.ts

@@ -1,5 +1,6 @@
 import { RootState, ThreekitDispatch } from './index';
-import { ISetConfiguration, IThreekitDisplayAttribute } from '../threekit';
+import { ISetConfiguration, IThreekitDisplayAttribute, IHydratedAttribute } from '../threekit';
+import { ITranslationMap } from '../api/products';
 /*****************************************************
  * Types and Interfaces
  ****************************************************/
@@ -15,6 +16,18 @@ declare const reducer: import("redux").Reducer<AttributesState, import("redux").
 /*****************************************************
  * Standard Selectors
  ****************************************************/
-export declare const getAttributes: (state: RootState) => undefined | Record<string, IThreekitDisplayAttribute>;
+export declare const getAttributes: (state: RootState) => AttributesState;
+export declare const getHydratedAttributes: ((state: {
+    treble: import("./treble").TrebleState;
+    product: import("./product").ProductState;
+    attributes: AttributesState;
+    translations: import("./translations").TranslationsState;
+    wishlist: import("../Treble").WishlistArray;
+    price: import("./price").PriceState;
+}) => Record<string, IHydratedAttribute>) & import("reselect").OutputSelectorFields<(args_0: AttributesState, args_1: ITranslationMap | undefined, args_2: string | undefined) => Record<string, IHydratedAttribute> & {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
 export declare const setConfiguration: (config: ISetConfiguration) => (dispatch: ThreekitDispatch) => Promise<void>;
 export default reducer;