@plattar/plattar-ar-adapter 1.122.3 → 1.123.3

package/dist/ar/launcher-ar.d.ts

@@ -1,6 +1,13 @@
 export declare abstract class LauncherAR {
     constructor();
     abstract init(): Promise<LauncherAR>;
-    abstract launch(): Promise<void>;
     abstract start(): void;
+    abstract canQuicklook(): boolean;
+    abstract canRealityViewer(): boolean;
+    abstract canSceneViewer(): boolean;
+    /**
+     * Initialise and launch with a single function call. this is mostly for convenience.
+     * Use .init() and .start() separately for fine-grained control
+     */
+    launch(): Promise<void>;
 }

package/dist/ar/launcher-ar.js

@@ -3,5 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LauncherAR = void 0;
 class LauncherAR {
     constructor() { }
+    /**
+     * Initialise and launch with a single function call. this is mostly for convenience.
+     * Use .init() and .start() separately for fine-grained control
+     */
+    launch() {
+        return new Promise((accept, reject) => {
+            this.init().then((value) => {
+                value.start();
+                return accept();
+            }).catch(reject);
+        });
+    }
 }
 exports.LauncherAR = LauncherAR;

package/dist/ar/model-ar.d.ts

@@ -17,11 +17,6 @@ export declare class ModelAR extends LauncherAR {
      * cannot be performed.
      */
     init(): Promise<LauncherAR>;
-    /**
-     * Initialise and launch with a single function call. this is mostly for convenience.
-     * Use .init() and .start() separately for fine-grained control
-     */
-    launch(): Promise<void>;
     /**
      * Launches the internal AR instance using an appropriate version of AR Viewers
      */

package/dist/ar/model-ar.js

@@ -35,6 +35,7 @@ class ModelAR extends launcher_ar_1.LauncherAR {
         if (project) {
             analytics = new plattar_analytics_1.Analytics(project.id);
             analytics.origin = plattar_api_1.Server.location().type;
+            analytics.data.push("type", "model-ar");
             analytics.data.push("applicationId", project.id);
             analytics.data.push("applicationTitle", project.attributes.title);
             analytics.data.push("modelId", model.id);
@@ -89,18 +90,6 @@ class ModelAR extends launcher_ar_1.LauncherAR {
             }).catch(reject);
         });
     }
-    /**
-     * Initialise and launch with a single function call. this is mostly for convenience.
-     * Use .init() and .start() separately for fine-grained control
-     */
-    launch() {
-        return new Promise((accept, reject) => {
-            this.init().then((value) => {
-                value.start();
-                return accept();
-            }).catch(reject);
-        });
-    }
     /**
      * Launches the internal AR instance using an appropriate version of AR Viewers
      */

package/dist/ar/product-ar.d.ts

@@ -10,7 +10,7 @@ export declare class ProductAR extends LauncherAR {
     constructor(productID?: string | undefined | null, variationID?: string | undefined | null);
     get productID(): string;
     get variationID(): string;
-    private _setupAnalytics;
+    private _SetupAnalytics;
     /**
      * Initialise the ProductAR instance. This returns a Promise that resolves
      * successfully if initialisation is successful, otherwise it will fail.
@@ -19,11 +19,6 @@ export declare class ProductAR extends LauncherAR {
      * cannot be performed.
      */
     init(): Promise<LauncherAR>;
-    /**
-     * Initialise and launch with a single function call. this is mostly for convenience.
-     * Use .init() and .start() separately for fine-grained control
-     */
-    launch(): Promise<void>;
     /**
      * Launches the internal AR instance using an appropriate version of AR Viewers
      */

package/dist/ar/product-ar.js

@@ -32,7 +32,7 @@ class ProductAR extends launcher_ar_1.LauncherAR {
     get variationID() {
         return this._variationID;
     }
-    _setupAnalytics(product, variation) {
+    _SetupAnalytics(product, variation) {
         let analytics = null;
         const scene = product.relationships.find(plattar_api_1.Scene);
         // setup scene stuff (if any)
@@ -40,6 +40,7 @@ class ProductAR extends launcher_ar_1.LauncherAR {
             analytics = new plattar_analytics_1.Analytics(scene.attributes.application_id);
             analytics.origin = plattar_api_1.Server.location().type;
             this._analytics = analytics;
+            analytics.data.push("type", "product-ar");
             analytics.data.push("sceneId", scene.id);
             analytics.data.push("sceneTitle", scene.attributes.title);
             const application = scene.relationships.find(plattar_api_1.Project);
@@ -100,7 +101,7 @@ class ProductAR extends launcher_ar_1.LauncherAR {
                 if (!model) {
                     return reject(new Error("ProductAR.init() - cannot proceed as ModelFile for selected variation is corrupt"));
                 }
-                this._setupAnalytics(product, variation);
+                this._SetupAnalytics(product, variation);
                 // we need to define our AR module here
                 // we are in Safari/Quicklook mode here
                 if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
@@ -131,18 +132,6 @@ class ProductAR extends launcher_ar_1.LauncherAR {
             }).catch(reject);
         });
     }
-    /**
-     * Initialise and launch with a single function call. this is mostly for convenience.
-     * Use .init() and .start() separately for fine-grained control
-     */
-    launch() {
-        return new Promise((accept, reject) => {
-            this.init().then((value) => {
-                value.start();
-                return accept();
-            }).catch(reject);
-        });
-    }
     /**
      * Launches the internal AR instance using an appropriate version of AR Viewers
      */

package/dist/ar/raw-ar.d.ts

@@ -15,11 +15,6 @@ export declare class RawAR extends LauncherAR {
      * cannot be performed.
      */
     init(): Promise<LauncherAR>;
-    /**
-     * Initialise and launch with a single function call. this is mostly for convenience.
-     * Use .init() and .start() separately for fine-grained control
-     */
-    launch(): Promise<void>;
     /**
      * Launches the internal AR instance using an appropriate version of AR Viewers
      */

package/dist/ar/raw-ar.js

@@ -75,18 +75,6 @@ class RawAR extends launcher_ar_1.LauncherAR {
             return reject(new Error("RawAR.init() - could not initialise AR correctly, check values"));
         });
     }
-    /**
-     * Initialise and launch with a single function call. this is mostly for convenience.
-     * Use .init() and .start() separately for fine-grained control
-     */
-    launch() {
-        return new Promise((accept, reject) => {
-            this.init().then((value) => {
-                value.start();
-                return accept();
-            }).catch(reject);
-        });
-    }
     /**
      * Launches the internal AR instance using an appropriate version of AR Viewers
      */

package/dist/ar/scene-ar.d.ts

@@ -3,7 +3,27 @@ import { LauncherAR } from "./launcher-ar";
  * Performs AR functionality related to Plattar Scenes
  */
 export declare class SceneAR extends LauncherAR {
+    private _analytics;
+    private readonly _sceneID;
+    private _ar;
+    constructor(sceneID?: string | undefined | null);
+    get sceneID(): string;
+    private _SetupAnalytics;
+    /**
+     * Composes a Scene into an AR Model (remote operation) that can be used to launch
+     * an AR File
+     */
+    private _ComposeScene;
+    /**
+     * Initialise the SceneAR instance. This returns a Promise that resolves
+     * successfully if initialisation is successful, otherwise it will fail.
+     *
+     * filure can occur for a number of reasons but it generally means that AR
+     * cannot be performed.
+     */
     init(): Promise<LauncherAR>;
-    launch(): Promise<void>;
     start(): void;
+    canQuicklook(): boolean;
+    canRealityViewer(): boolean;
+    canSceneViewer(): boolean;
 }

package/dist/ar/scene-ar.js

@@ -1,19 +1,162 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SceneAR = void 0;
+const plattar_analytics_1 = require("@plattar/plattar-analytics");
+const plattar_api_1 = require("@plattar/plattar-api");
+const plattar_services_1 = require("@plattar/plattar-services");
+const util_1 = require("../util/util");
+const quicklook_viewer_1 = __importDefault(require("../viewers/quicklook-viewer"));
+const reality_viewer_1 = __importDefault(require("../viewers/reality-viewer"));
+const scene_viewer_1 = __importDefault(require("../viewers/scene-viewer"));
 const launcher_ar_1 = require("./launcher-ar");
 /**
  * Performs AR functionality related to Plattar Scenes
  */
 class SceneAR extends launcher_ar_1.LauncherAR {
-    init() {
-        throw new Error("Method not implemented.");
+    constructor(sceneID = null) {
+        super();
+        // analytics instance
+        this._analytics = null;
+        if (!sceneID) {
+            throw new Error("SceneAR.constructor(sceneID) - sceneID must be defined");
+        }
+        this._sceneID = sceneID;
+        this._ar = null;
+    }
+    get sceneID() {
+        return this._sceneID;
+    }
+    _SetupAnalytics(scene) {
+        let analytics = null;
+        // setup scene stuff (if any)
+        if (scene) {
+            analytics = new plattar_analytics_1.Analytics(scene.attributes.application_id);
+            analytics.origin = plattar_api_1.Server.location().type;
+            this._analytics = analytics;
+            analytics.data.push("type", "scene-ar");
+            analytics.data.push("sceneId", scene.id);
+            analytics.data.push("sceneTitle", scene.attributes.title);
+            const application = scene.relationships.find(plattar_api_1.Project);
+            // setup application stuff (if any)
+            if (application) {
+                analytics.data.push("applicationId", application.id);
+                analytics.data.push("applicationTitle", application.attributes.title);
+            }
+        }
+    }
+    /**
+     * Composes a Scene into an AR Model (remote operation) that can be used to launch
+     * an AR File
+     */
+    _ComposeScene(scene, output) {
+        return new Promise((accept, reject) => {
+            const sceneProducts = scene.relationships.filter(plattar_api_1.SceneProduct);
+            // nothing to do if no AR components can be found
+            if (sceneProducts.length <= 0) {
+                return reject(new Error("SceneAR.ComposeScene() - cannot proceed as scene does not contain AR components"));
+            }
+            // define our configurator
+            const configurator = new plattar_services_1.Configurator();
+            configurator.server = plattar_api_1.Server.location().type;
+            configurator.output = output;
+            // add out scene models
+            sceneProducts.forEach((sceneProduct) => {
+                const product = sceneProduct.relationships.find(plattar_api_1.Product);
+                if (product && product.attributes.product_variation_id) {
+                    configurator.addSceneProduct(sceneProduct.id, product.attributes.product_variation_id);
+                }
+            });
+            return configurator.get().then((result) => {
+                accept(result.filename);
+            }).catch(reject);
+        });
     }
-    launch() {
-        throw new Error("Method not implemented.");
+    /**
+     * Initialise the SceneAR instance. This returns a Promise that resolves
+     * successfully if initialisation is successful, otherwise it will fail.
+     *
+     * filure can occur for a number of reasons but it generally means that AR
+     * cannot be performed.
+     */
+    init() {
+        return new Promise((accept, reject) => {
+            if (!util_1.Util.canAugment()) {
+                return reject(new Error("SceneAR.init() - cannot proceed as AR not available in context"));
+            }
+            const scene = new plattar_api_1.Scene(this.sceneID);
+            scene.include(plattar_api_1.Project);
+            scene.include(plattar_api_1.SceneProduct);
+            scene.include(plattar_api_1.SceneProduct.include(plattar_api_1.Product));
+            scene.get().then((scene) => {
+                this._SetupAnalytics(scene);
+                const sceneOpt = scene.attributes.custom_json || {};
+                // we need to define our AR module here
+                // we are in Safari/Quicklook mode here
+                if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
+                    // we need to launch a VTO experience here
+                    // VTO requires Reality Support
+                    if (sceneOpt.anchor === "face") {
+                        if (util_1.Util.canRealityViewer()) {
+                            return this._ComposeScene(scene, "vto").then((modelUrl) => {
+                                this._ar = new reality_viewer_1.default();
+                                this._ar.modelUrl = modelUrl;
+                                return accept(this);
+                            }).catch(reject);
+                        }
+                        else {
+                            return reject(new Error("SceneAR.init() - cannot proceed as VTO AR requires Reality Viewer support"));
+                        }
+                    }
+                    // otherwise, load the USDZ stuff second if available
+                    if (util_1.Util.canQuicklook()) {
+                        return this._ComposeScene(scene, "usdz").then((modelUrl) => {
+                            this._ar = new quicklook_viewer_1.default();
+                            this._ar.modelUrl = modelUrl;
+                            return accept(this);
+                        }).catch(reject);
+                    }
+                    return reject(new Error("SceneAR.init() - cannot proceed as IOS device does not support AR Mode"));
+                }
+                // check android
+                if (util_1.Util.canSceneViewer()) {
+                    return this._ComposeScene(scene, "glb").then((modelUrl) => {
+                        this._ar = new scene_viewer_1.default();
+                        this._ar.modelUrl = modelUrl;
+                        return accept(this);
+                    }).catch(reject);
+                }
+                // otherwise, we didn't have AR available - it should never really reach this stage as this should be caught
+                // earlier in the process
+                return reject(new Error("SceneAR.init() - could not initialise AR correctly, check values"));
+            }).catch(reject);
+        });
     }
     start() {
-        throw new Error("Method not implemented.");
+        if (!this._ar) {
+            throw new Error("SceneAR.start() - cannot proceed as AR instance is null");
+        }
+        const analytics = this._analytics;
+        if (analytics) {
+            analytics.data.push("device", this._ar.device);
+            analytics.data.push("eventCategory", this._ar.nodeType);
+            analytics.data.push("eventAction", "Start Scene Augment");
+            analytics.write();
+            analytics.startRecordEngagement();
+        }
+        // this was initialised via the init() function
+        this._ar.start();
+    }
+    canQuicklook() {
+        return this._ar && this._ar.nodeType === "Quick Look" ? true : false;
+    }
+    canRealityViewer() {
+        return this._ar && this._ar.nodeType === "Reality Viewer" ? true : false;
+    }
+    canSceneViewer() {
+        return this._ar && this._ar.nodeType === "Scene Viewer" ? true : false;
     }
 }
 exports.SceneAR = SceneAR;

package/dist/embed/controllers/configurator-controller.d.ts

@@ -0,0 +1,17 @@
+import { LauncherAR } from "../../ar/launcher-ar";
+import { PlattarController } from "./plattar-controller";
+/**
+ * Manages an instance of the <plattar-configurator> HTML Element
+ */
+export declare class ConfiguratorController extends PlattarController {
+    private _state;
+    private _element;
+    private _prevQROpt;
+    constructor(parent: HTMLElement);
+    onAttributesUpdated(): void;
+    startQRCode(options: any): Promise<HTMLElement>;
+    startRenderer(): Promise<HTMLElement>;
+    initAR(): Promise<LauncherAR>;
+    removeRenderer(): boolean;
+    get element(): HTMLElement | null;
+}

package/dist/embed/controllers/configurator-controller.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfiguratorController = void 0;
+const plattar_api_1 = require("@plattar/plattar-api");
+const plattar_services_1 = require("@plattar/plattar-services");
+const raw_ar_1 = require("../../ar/raw-ar");
+const util_1 = require("../../util/util");
+const plattar_controller_1 = require("./plattar-controller");
+/**
+ * Manages an instance of the <plattar-configurator> HTML Element
+ */
+class ConfiguratorController extends plattar_controller_1.PlattarController {
+    constructor(parent) {
+        super(parent);
+        this._state = plattar_controller_1.ControllerState.None;
+        this._element = null;
+        this._prevQROpt = null;
+    }
+    onAttributesUpdated() {
+        const state = this._state;
+        // re-render the QR Code when attributes have changed
+        if (state === plattar_controller_1.ControllerState.QRCode) {
+            this.startQRCode(this._prevQROpt);
+            return;
+        }
+    }
+    startQRCode(options) {
+        return new Promise((accept, reject) => {
+            // remove the old renderer instance if any
+            this.removeRenderer();
+            const sceneID = this.getAttribute("scene-id");
+            if (sceneID) {
+                const opt = options || plattar_controller_1.PlattarController.DEFAULT_QR_OPTIONS;
+                const viewer = document.createElement("plattar-qrcode");
+                // required attributes with defaults for plattar-viewer node
+                const width = this.getAttribute("width") || "500px";
+                const height = this.getAttribute("height") || "500px";
+                viewer.setAttribute("width", width);
+                viewer.setAttribute("height", height);
+                if (opt.color) {
+                    viewer.setAttribute("color", opt.color);
+                }
+                if (opt.margin) {
+                    viewer.setAttribute("margin", "" + opt.margin);
+                }
+                if (opt.qrType) {
+                    viewer.setAttribute("qr-type", opt.qrType);
+                }
+                let dst = plattar_api_1.Server.location().base + "renderer/configurator.html?scene_id=" + sceneID;
+                // optional attributes
+                const configState = this.getAttribute("config-state");
+                const showAR = this.getAttribute("show-ar");
+                if (configState) {
+                    dst += "&config_state=" + configState;
+                }
+                if (showAR) {
+                    dst += "&show_ar=" + showAR;
+                }
+                viewer.setAttribute("url", opt.url || dst);
+                viewer.onload = () => {
+                    return accept(viewer);
+                };
+                this.append(viewer);
+                this._element = viewer;
+                this._state = plattar_controller_1.ControllerState.QRCode;
+                this._prevQROpt = opt;
+                return;
+            }
+            return reject(new Error("ConfiguratorController.startQRCode() - minimum required attributes not set, use scene-id as a minimum"));
+        });
+    }
+    startRenderer() {
+        return new Promise((accept, reject) => {
+            // remove the old renderer instance if any
+            this.removeRenderer();
+            const sceneID = this.getAttribute("scene-id");
+            if (sceneID) {
+                // required attributes with defaults for plattar-configurator node
+                const width = this.getAttribute("width") || "500px";
+                const height = this.getAttribute("height") || "500px";
+                const server = this.getAttribute("server") || "production";
+                const viewer = document.createElement("plattar-configurator");
+                viewer.setAttribute("width", width);
+                viewer.setAttribute("height", height);
+                viewer.setAttribute("server", server);
+                viewer.setAttribute("scene-id", sceneID);
+                // optional attributes
+                const configState = this.getAttribute("config-state");
+                const showAR = this.getAttribute("show-ar");
+                if (configState) {
+                    viewer.setAttribute("config-state", configState);
+                }
+                if (showAR) {
+                    viewer.setAttribute("show-ar", showAR);
+                }
+                viewer.onload = () => {
+                    return accept(viewer);
+                };
+                this.append(viewer);
+                this._element = viewer;
+                this._state = plattar_controller_1.ControllerState.Renderer;
+                return;
+            }
+            return reject(new Error("ConfiguratorController.startRenderer() - minimum required attributes not set, use scene-id as a minimum"));
+        });
+    }
+    initAR() {
+        return new Promise((accept, reject) => {
+            if (!util_1.Util.canAugment()) {
+                return reject(new Error("ConfiguratorController.initAR() - cannot proceed as AR not available in context"));
+            }
+            // if scene ID is available and the state is a configurator viewer
+            // we can use the real-time configurator state to launch the AR view
+            const viewer = this.element;
+            const sceneID = this.getAttribute("scene-id");
+            if (viewer && sceneID) {
+                let output = "glb";
+                if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
+                    output = "usdz";
+                }
+                return viewer.messenger.getARFile(output).then((result) => {
+                    const rawAR = new raw_ar_1.RawAR(result.filename);
+                    return rawAR.init().then(accept).catch(reject);
+                }).catch(reject);
+            }
+            const configState = this.getAttribute("config-state");
+            // otherwise scene ID is available to the viewer is not launched
+            // we can use the static configuration state to launch the AR view
+            if (sceneID && configState) {
+                try {
+                    const decodedb64State = atob(configState);
+                    const state = JSON.parse(decodedb64State);
+                    if (state.meta) {
+                        const sceneProductIndex = state.meta.scene_product_index || 0;
+                        const variationIndex = state.meta.product_variation_index || 1;
+                        const states = state.states || [];
+                        if (states.length > 0) {
+                            const configurator = new plattar_services_1.Configurator();
+                            states.forEach((productState) => {
+                                configurator.addSceneProduct(productState[sceneProductIndex], productState[variationIndex]);
+                            });
+                            if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
+                                configurator.output = "usdz";
+                            }
+                            if (util_1.Util.canSceneViewer()) {
+                                configurator.output = "glb";
+                            }
+                            const server = this.getAttribute("server") || "production";
+                            configurator.server = server;
+                            return configurator.get().then((result) => {
+                                const rawAR = new raw_ar_1.RawAR(result.filename);
+                                rawAR.init().then(accept).catch(reject);
+                            }).catch(reject);
+                        }
+                        return reject(new Error("ConfiguratorController.initAR() - invalid config-state does not have any product states"));
+                    }
+                    return reject(new Error("ConfiguratorController.initAR() - invalid config-state for configurator"));
+                }
+                catch (err) {
+                    return reject(err);
+                }
+            }
+            return reject(new Error("ConfiguratorController.initAR() - minimum required attributes not set, use scene-id as a minimum"));
+        });
+    }
+    removeRenderer() {
+        if (this._element) {
+            this._element.remove();
+            this._element = null;
+            return true;
+        }
+        return false;
+    }
+    get element() {
+        return this._element;
+    }
+}
+exports.ConfiguratorController = ConfiguratorController;

package/dist/embed/controllers/plattar-controller.d.ts

@@ -0,0 +1,62 @@
+import { LauncherAR } from "../../ar/launcher-ar";
+export declare enum ControllerState {
+    None = 0,
+    Renderer = 1,
+    QRCode = 2
+}
+/**
+ * All Plattar Controllers are derived from the same interface
+ */
+export declare abstract class PlattarController {
+    /**
+     * Default QR Code rendering options
+     */
+    static get DEFAULT_QR_OPTIONS(): any;
+    private readonly _parent;
+    constructor(parent: HTMLElement);
+    /**
+     * Called by the parent when a HTML Attribute has changed and the controller
+     * requires an update
+     */
+    abstract onAttributesUpdated(): void;
+    /**
+     * Start Rendering a QR Code with the provided options
+     * @param options (optional) - The QR Code Options
+     */
+    abstract startQRCode(options: any | undefined | null): Promise<HTMLElement>;
+    /**
+     * Start the underlying Plattar Renderer for this Controller
+     */
+    abstract startRenderer(): Promise<HTMLElement>;
+    /**
+     * Initialise and start AR mode if available
+     */
+    startAR(): Promise<void>;
+    /**
+     * Initialise and return a launcher that can be used to start AR
+     */
+    abstract initAR(): Promise<LauncherAR>;
+    /**
+     * Removes the currently active renderer view from the DOM
+     */
+    abstract removeRenderer(): boolean;
+    /**
+     * Get the underlying renderer component (if any)
+     */
+    abstract get element(): HTMLElement | null;
+    /**
+     * Returns the Parent Instance
+     */
+    get parent(): HTMLElement;
+    /**
+     * Returns the specified attribute from the parent
+     * @param attribute - The name of thhe attribute
+     * @returns - The attribute value or null
+     */
+    getAttribute(attribute: string): string | null;
+    /**
+     * Appends the provided element into the shadow-root of the parent element
+     * @param element - The element to append
+     */
+    append(element: HTMLElement): void;
+}