@snap/camera-kit 0.7.0

package/lib/session/LensKeyboard.d.ts

@@ -0,0 +1,89 @@
+import { TypedCustomEvent } from "../events/TypedCustomEvent";
+import { TypedEventListener, TypedEventListenerOptions } from "../events/TypedEventTarget";
+import { UriHandler } from "../extensions/UriHandlers";
+import { Lens } from "../lens/Lens";
+import { LensState } from "./lensState";
+/**
+ * Events emitted by {@link Keyboard}.
+ */
+export declare type KeyboardEvents = TypedCustomEvent<"active", {
+    element: HTMLTextAreaElement;
+    active: boolean;
+    lens?: Lens;
+}>;
+/**
+ * Keyboard is an API enabling lenses to consume and render user-generated text.
+ *
+ * Applications that wish to use lenses that expect user-generated text will need to use this API to integrate text
+ * input into their user experience.
+ *
+ * There are two ways to do this:
+ * 1. Add the provided DOM element (an HTMLTextAreaElement) to the page. When the user updates this element with text,
+ * that text will be sent to the currently active lens.
+ * 2. Use the {@link sendInputToLens} method to send text strings to the currently active lens directly.
+ *
+ * Lenses will also signal to the application when text input is expected -- applications should add an event listener
+ * and ensure the user is able to input text when the `active` event is received.
+ *
+ * @example
+ * ```ts
+ * cameraKitSession.keyboard.addEventListener('active', ({ detail }) => {
+ *   const { element, active } = detail
+ *   if (active) document.body.appendChild(element)
+ *   else element.remove()
+ * })
+ * ```
+ *
+ * @category Lenses
+ */
+export declare type Keyboard = {
+    addEventListener: (type: "active", callback: TypedEventListener<KeyboardEvents>, options?: TypedEventListenerOptions) => void;
+    removeEventListener: (type: "active", callback: TypedEventListener<KeyboardEvents>) => void;
+    /**
+     * Get an HTMLTextAreaElement that communicates text to the active Lens.
+     */
+    getElement: () => HTMLTextAreaElement;
+    /**
+     * Send text to the active Lens. Also updates the provided HTMLTextAreaElement.
+     *
+     * @param text String to render. This can include escape sequences, such as the newline character ( \n ) for
+     * multi-line input.
+     */
+    sendInputToLens: (text: string) => void;
+    /**
+     * Clears the provided HTMLTextAreaElement, and emits the "active" event with `active == false`, allowing the
+     * application to e.g. remove relevant text input elements from the DOM.
+     */
+    dismiss: () => void;
+};
+/** @internal */
+export declare class LensKeyboard {
+    private readonly lensState;
+    readonly uriHandler: UriHandler;
+    private readonly events;
+    private readonly element;
+    private active;
+    private handleReply;
+    constructor(lensState: LensState);
+    dismiss(): void;
+    getElement(): HTMLTextAreaElement;
+    sendInputToLens(text: string): void;
+    addEventListener(type: "active", callback: TypedEventListener<KeyboardEvents>, options?: TypedEventListenerOptions): void;
+    removeEventListener(type: "active", callback: TypedEventListener<KeyboardEvents>): void;
+    toPublicInterface(): Keyboard;
+    private updateStatus;
+}
+/**
+ * @internal
+ */
+export declare const lensKeyboardFactory: {
+    (args_0: import("@snap/state-management").StateMachine<import("@snap/state-management").Action<"applyLens", {
+        lens: Lens;
+        launchParams?: import("..").LensLaunchParams | undefined;
+    }> | import("@snap/state-management").Action<"downloadComplete", Lens> | import("@snap/state-management").Action<"turnedOn", Lens> | import("@snap/state-management").Action<"resourcesLoaded", Lens> | import("@snap/state-management").Action<"firstFrameProcessed", Lens> | import("@snap/state-management").Action<"applyLensComplete", Lens> | import("@snap/state-management").Action<"applyLensFailed", {
+        error: import("./lensState").LensErrors;
+        lens: Lens;
+    }> | import("@snap/state-management").Action<"removeLens", undefined> | import("@snap/state-management").Action<"turnedOff", Lens> | import("@snap/state-management").Action<"removeLensComplete", undefined> | import("@snap/state-management").Action<"removeLensFailed", Error>, import("@snap/state-management").State<"noLensApplied", undefined> | import("@snap/state-management").State<"applyingLens", Lens> | import("@snap/state-management").State<"lensApplied", Lens>>): LensKeyboard;
+    token: "lensKeyboard";
+    dependencies: readonly ["lensState"];
+};

package/lib/session/LensKeyboard.js

@@ -0,0 +1,95 @@
+import { isState, forActions } from "@snap/state-management";
+import { Injectable } from "../dependency-injection/Injectable";
+import { TypedCustomEvent } from "../events/TypedCustomEvent";
+import { TypedEventTarget } from "../events/TypedEventTarget";
+import { lensStateFactory } from "./lensState";
+/** @internal */
+export class LensKeyboard {
+    constructor(lensState) {
+        this.lensState = lensState;
+        this.active = false;
+        this.element = document.createElement("textarea");
+        this.element.addEventListener("keypress", (event) => {
+            if (event.code === "Enter" && !event.shiftKey) {
+                event.preventDefault();
+                this.handleReply(this.element.value);
+            }
+        });
+        this.events = new TypedEventTarget();
+        this.handleReply = () => { };
+        this.uriHandler = {
+            uri: "app://textInput/requestKeyboard",
+            handleRequest: (_request, reply) => {
+                this.element.autofocus = true;
+                this.handleReply = (text) => {
+                    const opt = {
+                        text: text,
+                        start: text.length,
+                        end: text.length,
+                        done: true,
+                        shouldNotify: true,
+                    };
+                    const output = new TextEncoder().encode(JSON.stringify(opt));
+                    reply({
+                        code: 200,
+                        description: "",
+                        contentType: "application/json",
+                        data: output,
+                    });
+                };
+                this.active = true;
+                this.updateStatus();
+                this.element.focus();
+            },
+        };
+        lensState.events.pipe(forActions("turnedOff")).subscribe(() => {
+            this.dismiss();
+        });
+    }
+    dismiss() {
+        if (this.active) {
+            this.active = false;
+            this.element.value = "";
+            this.updateStatus();
+        }
+    }
+    getElement() {
+        return this.element;
+    }
+    sendInputToLens(text) {
+        this.element.value = text;
+        this.handleReply(text);
+    }
+    addEventListener(type, callback, options) {
+        this.events.addEventListener(type, callback, options);
+    }
+    removeEventListener(type, callback) {
+        this.events.removeEventListener(type, callback);
+    }
+    toPublicInterface() {
+        return {
+            addEventListener: this.addEventListener.bind(this),
+            removeEventListener: this.removeEventListener.bind(this),
+            getElement: this.getElement.bind(this),
+            sendInputToLens: this.sendInputToLens.bind(this),
+            dismiss: this.dismiss.bind(this),
+        };
+    }
+    updateStatus() {
+        const state = this.lensState.getState();
+        // If lens keyboard status is changing, we know a lens must be applied.
+        if (isState(state, "noLensApplied"))
+            return;
+        this.events.dispatchEvent(new TypedCustomEvent("active", {
+            element: this.element,
+            active: this.active,
+            // If the keyboard is up, it has been triggered by an active lens.
+            lens: state.data,
+        }));
+    }
+}
+/**
+ * @internal
+ */
+export const lensKeyboardFactory = Injectable("lensKeyboard", [lensStateFactory.token], (lensState) => new LensKeyboard(lensState));
+//# sourceMappingURL=LensKeyboard.js.map

package/lib/session/LensKeyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LensKeyboard.js","sourceRoot":"","sources":["../../src/session/LensKeyboard.ts"],"names":[],"mappings":"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","sourcesContent":["import { isState, forActions } from \"@snap/state-management\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport { TypedCustomEvent } from \"../events/TypedCustomEvent\";\nimport { TypedEventListener, TypedEventListenerOptions, TypedEventTarget } from \"../events/TypedEventTarget\";\nimport { UriHandler } from \"../extensions/UriHandlers\";\nimport { Lens } from \"../lens/Lens\";\nimport { LensState, lensStateFactory } from \"./lensState\";\n\n/**\n * Events emitted by {@link Keyboard}.\n */\nexport type KeyboardEvents = TypedCustomEvent<\n    \"active\",\n    {\n        element: HTMLTextAreaElement;\n        active: boolean;\n        lens?: Lens;\n    }\n>;\n\n/**\n * Keyboard is an API enabling lenses to consume and render user-generated text.\n *\n * Applications that wish to use lenses that expect user-generated text will need to use this API to integrate text\n * input into their user experience.\n *\n * There are two ways to do this:\n * 1. Add the provided DOM element (an HTMLTextAreaElement) to the page. When the user updates this element with text,\n * that text will be sent to the currently active lens.\n * 2. Use the {@link sendInputToLens} method to send text strings to the currently active lens directly.\n *\n * Lenses will also signal to the application when text input is expected -- applications should add an event listener\n * and ensure the user is able to input text when the `active` event is received.\n *\n * @example\n * ```ts\n * cameraKitSession.keyboard.addEventListener('active', ({ detail }) => {\n *   const { element, active } = detail\n *   if (active) document.body.appendChild(element)\n *   else element.remove()\n * })\n * ```\n *\n * @category Lenses\n */\nexport type Keyboard = {\n    addEventListener: (\n        type: \"active\",\n        callback: TypedEventListener<KeyboardEvents>,\n        options?: TypedEventListenerOptions\n    ) => void;\n    removeEventListener: (type: \"active\", callback: TypedEventListener<KeyboardEvents>) => void;\n\n    /**\n     * Get an HTMLTextAreaElement that communicates text to the active Lens.\n     */\n    getElement: () => HTMLTextAreaElement;\n\n    /**\n     * Send text to the active Lens. Also updates the provided HTMLTextAreaElement.\n     *\n     * @param text String to render. This can include escape sequences, such as the newline character ( \\n ) for\n     * multi-line input.\n     */\n    sendInputToLens: (text: string) => void;\n\n    /**\n     * Clears the provided HTMLTextAreaElement, and emits the \"active\" event with `active == false`, allowing the\n     * application to e.g. remove relevant text input elements from the DOM.\n     */\n    dismiss: () => void;\n};\n\n/** @internal */\nexport class LensKeyboard {\n    public readonly uriHandler: UriHandler;\n    private readonly events: TypedEventTarget<KeyboardEvents>;\n    private readonly element: HTMLTextAreaElement;\n    private active: boolean;\n    private handleReply: (text: string) => void;\n\n    constructor(private readonly lensState: LensState) {\n        this.active = false;\n        this.element = document.createElement(\"textarea\");\n        this.element.addEventListener(\"keypress\", (event: KeyboardEvent) => {\n            if (event.code === \"Enter\" && !event.shiftKey) {\n                event.preventDefault();\n                this.handleReply(this.element.value);\n            }\n        });\n        this.events = new TypedEventTarget<KeyboardEvents>();\n        this.handleReply = () => {};\n        this.uriHandler = {\n            uri: \"app://textInput/requestKeyboard\",\n            handleRequest: (_request, reply) => {\n                this.element.autofocus = true;\n                this.handleReply = (text: string) => {\n                    const opt = {\n                        text: text,\n                        start: text.length,\n                        end: text.length,\n                        done: true,\n                        shouldNotify: true,\n                    };\n                    const output = new TextEncoder().encode(JSON.stringify(opt));\n                    reply({\n                        code: 200,\n                        description: \"\",\n                        contentType: \"application/json\",\n                        data: output,\n                    });\n                };\n                this.active = true;\n                this.updateStatus();\n                this.element.focus();\n            },\n        };\n        lensState.events.pipe(forActions(\"turnedOff\")).subscribe(() => {\n            this.dismiss();\n        });\n    }\n\n    dismiss(): void {\n        if (this.active) {\n            this.active = false;\n            this.element.value = \"\";\n            this.updateStatus();\n        }\n    }\n\n    getElement(): HTMLTextAreaElement {\n        return this.element;\n    }\n\n    sendInputToLens(text: string): void {\n        this.element.value = text;\n        this.handleReply(text);\n    }\n\n    addEventListener(\n        type: \"active\",\n        callback: TypedEventListener<KeyboardEvents>,\n        options?: TypedEventListenerOptions\n    ): void {\n        this.events.addEventListener(type, callback, options);\n    }\n\n    removeEventListener(type: \"active\", callback: TypedEventListener<KeyboardEvents>): void {\n        this.events.removeEventListener(type, callback);\n    }\n\n    toPublicInterface(): Keyboard {\n        return {\n            addEventListener: this.addEventListener.bind(this),\n            removeEventListener: this.removeEventListener.bind(this),\n            getElement: this.getElement.bind(this),\n            sendInputToLens: this.sendInputToLens.bind(this),\n            dismiss: this.dismiss.bind(this),\n        };\n    }\n\n    private updateStatus(): void {\n        const state = this.lensState.getState();\n        // If lens keyboard status is changing, we know a lens must be applied.\n        if (isState(state, \"noLensApplied\")) return;\n        this.events.dispatchEvent(\n            new TypedCustomEvent(\"active\", {\n                element: this.element,\n                active: this.active,\n                // If the keyboard is up, it has been triggered by an active lens.\n                lens: state.data,\n            })\n        );\n    }\n}\n\n/**\n * @internal\n */\nexport const lensKeyboardFactory = Injectable(\n    \"lensKeyboard\",\n    [lensStateFactory.token] as const,\n    (lensState: LensState) => new LensKeyboard(lensState)\n);\n"]}

package/lib/session/LensPerformanceMeasurement.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @category Rendering
+ * @category Metrics
+ */
+export interface ComputedFrameMetrics {
+    avgFps: number;
+    lensFrameProcessingTimeMsAvg: number;
+    lensFrameProcessingTimeMsStd: number;
+}
+/**
+ * Represents an ongoing measurement of rendering metrics.
+ *
+ * An instance of this class is obtained by calling {@link LensPerformanceMetrics.beginMeasurement}. Then it may be
+ * used to record rendering performance metrics, reset measurement, or end the measurement.
+ *
+ * @category Rendering
+ * @category Metrics
+ */
+export declare class LensPerformanceMeasurement {
+    private instances;
+    private state;
+    private priorFrameCompletedTime?;
+    constructor(instances: Set<LensPerformanceMeasurement>);
+    /** @internal */
+    update(processingTimeMs: number): void;
+    /**
+     * Return a {@link ComputedFrameMetrics} object, containing lens performance metrics.
+     *
+     * This method may be called multiple times, each time reporting values computed since the time when this instance
+     * was created.
+     */
+    measure(): ComputedFrameMetrics;
+    /**
+     * Reset the measured perforamance statistics (averages, std deviations). This is equivalent to using
+     * {@link LensPerformanceMetrics.beginMeasurement} to create a new LensPerformanceMeasurement instance, but may be
+     * more convenient.
+     */
+    reset(): void;
+    /**
+     * Stop measuring performance statistics.
+     *
+     * This instance will not be garbage collected until this method is called. Therefore it is important to call this
+     * method at the appropriate time to avoid leaking memory -- particularly if your application creates many
+     * LensPerformanceMeasurement instances.
+     */
+    end(): void;
+    /**
+     * In order to calculate the mean, variance, and standard deviation for the processing times
+     *  we are using Welford's online algorithm.
+     * https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
+     *
+     * @param processingTimeMs Processing time that is returned from registered callback
+     */
+    private computeRunningStats;
+}

package/lib/session/LensPerformanceMeasurement.js

@@ -0,0 +1,91 @@
+const defaultFrameMetricsState = {
+    avgFps: 0,
+    averageProcessingTime: 0,
+    procFrameCount: 0,
+    procFrameMean: 0,
+    procFrameD2: 0,
+};
+// This duration is chosen to be larger than we expect frame processing to reasonably take on any device, but smaller
+// than the duration of a manual rendering pause (e.g. a user clicking a pause button followed by a play button).
+//
+// This also defines the min avgFps that will be reported – if we see avgFps at `1 / frameDurationThresholdSec`
+// consistently, it's safe to assume actual fps is probably even lower.
+const frameDurationThreshold = 1;
+/**
+ * Represents an ongoing measurement of rendering metrics.
+ *
+ * An instance of this class is obtained by calling {@link LensPerformanceMetrics.beginMeasurement}. Then it may be
+ * used to record rendering performance metrics, reset measurement, or end the measurement.
+ *
+ * @category Rendering
+ * @category Metrics
+ */
+export class LensPerformanceMeasurement {
+    constructor(instances) {
+        this.instances = instances;
+        this.state = Object.assign({}, defaultFrameMetricsState);
+        this.instances.add(this);
+    }
+    /** @internal */
+    update(processingTimeMs) {
+        this.computeRunningStats(processingTimeMs);
+    }
+    /**
+     * Return a {@link ComputedFrameMetrics} object, containing lens performance metrics.
+     *
+     * This method may be called multiple times, each time reporting values computed since the time when this instance
+     * was created.
+     */
+    measure() {
+        return {
+            avgFps: this.state.avgFps,
+            lensFrameProcessingTimeMsAvg: this.state.procFrameMean,
+            lensFrameProcessingTimeMsStd: Math.sqrt(this.state.procFrameD2 / this.state.procFrameCount),
+        };
+    }
+    /**
+     * Reset the measured perforamance statistics (averages, std deviations). This is equivalent to using
+     * {@link LensPerformanceMetrics.beginMeasurement} to create a new LensPerformanceMeasurement instance, but may be
+     * more convenient.
+     */
+    reset() {
+        this.state = Object.assign({}, defaultFrameMetricsState);
+    }
+    /**
+     * Stop measuring performance statistics.
+     *
+     * This instance will not be garbage collected until this method is called. Therefore it is important to call this
+     * method at the appropriate time to avoid leaking memory -- particularly if your application creates many
+     * LensPerformanceMeasurement instances.
+     */
+    end() {
+        this.instances.delete(this);
+    }
+    /**
+     * In order to calculate the mean, variance, and standard deviation for the processing times
+     *  we are using Welford's online algorithm.
+     * https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
+     *
+     * @param processingTimeMs Processing time that is returned from registered callback
+     */
+    computeRunningStats(processingTimeMs) {
+        // calculate mean and delta squared for variance and standard deviation
+        const delta = processingTimeMs - this.state.procFrameMean;
+        this.state.procFrameCount += 1;
+        this.state.procFrameMean += delta / this.state.procFrameCount;
+        const delta2 = processingTimeMs - this.state.procFrameMean;
+        this.state.procFrameD2 += delta * delta2;
+        // Determine average fps
+        if (this.priorFrameCompletedTime === undefined) {
+            this.priorFrameCompletedTime = performance.now();
+        }
+        else {
+            const frameDurationSec = (performance.now() - this.priorFrameCompletedTime) / 1000;
+            if (frameDurationSec < frameDurationThreshold) {
+                this.state.avgFps = (this.state.avgFps + 1 / frameDurationSec) / 2;
+            }
+            this.priorFrameCompletedTime = performance.now();
+        }
+    }
+}
+//# sourceMappingURL=LensPerformanceMeasurement.js.map

package/lib/session/LensPerformanceMeasurement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LensPerformanceMeasurement.js","sourceRoot":"","sources":["../../src/session/LensPerformanceMeasurement.ts"],"names":[],"mappings":"AAQA,MAAM,wBAAwB,GAAsB;IAChD,MAAM,EAAE,CAAC;IACT,qBAAqB,EAAE,CAAC;IACxB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,WAAW,EAAE,CAAC;CACjB,CAAC;AAEF,qHAAqH;AACrH,iHAAiH;AACjH,EAAE;AACF,+GAA+G;AAC/G,uEAAuE;AACvE,MAAM,sBAAsB,GAAW,CAAC,CAAC;AAYzC;;;;;;;;GAQG;AACH,MAAM,OAAO,0BAA0B;IAInC,YAAoB,SAA0C;QAA1C,cAAS,GAAT,SAAS,CAAiC;QAHtD,UAAK,qBAA2B,wBAAwB,EAAG;QAI/D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED,gBAAgB;IAChB,MAAM,CAAC,gBAAwB;QAC3B,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACH,OAAO;QACH,OAAO;YACH,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;YACzB,4BAA4B,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa;YACtD,4BAA4B,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;SAC9F,CAAC;IACN,CAAC;IAED;;;;OAIG;IACH,KAAK;QACD,IAAI,CAAC,KAAK,qBAAQ,wBAAwB,CAAE,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACH,GAAG;QACC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IACD;;;;;;OAMG;IACK,mBAAmB,CAAC,gBAAwB;QAChD,uEAAuE;QACvE,MAAM,KAAK,GAAG,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;QAC1D,IAAI,CAAC,KAAK,CAAC,cAAc,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;QAE9D,MAAM,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;QAC3D,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,KAAK,GAAG,MAAM,CAAC;QAEzC,wBAAwB;QACxB,IAAI,IAAI,CAAC,uBAAuB,KAAK,SAAS,EAAE;YAC5C,IAAI,CAAC,uBAAuB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;SACpD;aAAM;YACH,MAAM,gBAAgB,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAAC;YACnF,IAAI,gBAAgB,GAAG,sBAAsB,EAAE;gBAC3C,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;aACtE;YACD,IAAI,CAAC,uBAAuB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;SACpD;IACL,CAAC;CACJ","sourcesContent":["interface FrameMetricsState {\n    avgFps: number;\n    averageProcessingTime: number;\n    procFrameCount: number;\n    procFrameMean: number;\n    procFrameD2: number;\n}\n\nconst defaultFrameMetricsState: FrameMetricsState = {\n    avgFps: 0,\n    averageProcessingTime: 0,\n    procFrameCount: 0,\n    procFrameMean: 0,\n    procFrameD2: 0,\n};\n\n// This duration is chosen to be larger than we expect frame processing to reasonably take on any device, but smaller\n// than the duration of a manual rendering pause (e.g. a user clicking a pause button followed by a play button).\n//\n// This also defines the min avgFps that will be reported – if we see avgFps at `1 / frameDurationThresholdSec`\n// consistently, it's safe to assume actual fps is probably even lower.\nconst frameDurationThreshold: number = 1;\n\n/**\n * @category Rendering\n * @category Metrics\n */\nexport interface ComputedFrameMetrics {\n    avgFps: number;\n    lensFrameProcessingTimeMsAvg: number;\n    lensFrameProcessingTimeMsStd: number;\n}\n\n/**\n * Represents an ongoing measurement of rendering metrics.\n *\n * An instance of this class is obtained by calling {@link LensPerformanceMetrics.beginMeasurement}. Then it may be\n * used to record rendering performance metrics, reset measurement, or end the measurement.\n *\n * @category Rendering\n * @category Metrics\n */\nexport class LensPerformanceMeasurement {\n    private state: FrameMetricsState = { ...defaultFrameMetricsState };\n    private priorFrameCompletedTime?: number;\n\n    constructor(private instances: Set<LensPerformanceMeasurement>) {\n        this.instances.add(this);\n    }\n\n    /** @internal */\n    update(processingTimeMs: number): void {\n        this.computeRunningStats(processingTimeMs);\n    }\n\n    /**\n     * Return a {@link ComputedFrameMetrics} object, containing lens performance metrics.\n     *\n     * This method may be called multiple times, each time reporting values computed since the time when this instance\n     * was created.\n     */\n    measure(): ComputedFrameMetrics {\n        return {\n            avgFps: this.state.avgFps,\n            lensFrameProcessingTimeMsAvg: this.state.procFrameMean,\n            lensFrameProcessingTimeMsStd: Math.sqrt(this.state.procFrameD2 / this.state.procFrameCount),\n        };\n    }\n\n    /**\n     * Reset the measured perforamance statistics (averages, std deviations). This is equivalent to using\n     * {@link LensPerformanceMetrics.beginMeasurement} to create a new LensPerformanceMeasurement instance, but may be\n     * more convenient.\n     */\n    reset(): void {\n        this.state = { ...defaultFrameMetricsState };\n    }\n\n    /**\n     * Stop measuring performance statistics.\n     *\n     * This instance will not be garbage collected until this method is called. Therefore it is important to call this\n     * method at the appropriate time to avoid leaking memory -- particularly if your application creates many\n     * LensPerformanceMeasurement instances.\n     */\n    end(): void {\n        this.instances.delete(this);\n    }\n    /**\n     * In order to calculate the mean, variance, and standard deviation for the processing times\n     *  we are using Welford's online algorithm.\n     * https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm\n     *\n     * @param processingTimeMs Processing time that is returned from registered callback\n     */\n    private computeRunningStats(processingTimeMs: number) {\n        // calculate mean and delta squared for variance and standard deviation\n        const delta = processingTimeMs - this.state.procFrameMean;\n        this.state.procFrameCount += 1;\n        this.state.procFrameMean += delta / this.state.procFrameCount;\n\n        const delta2 = processingTimeMs - this.state.procFrameMean;\n        this.state.procFrameD2 += delta * delta2;\n\n        // Determine average fps\n        if (this.priorFrameCompletedTime === undefined) {\n            this.priorFrameCompletedTime = performance.now();\n        } else {\n            const frameDurationSec = (performance.now() - this.priorFrameCompletedTime) / 1000;\n            if (frameDurationSec < frameDurationThreshold) {\n                this.state.avgFps = (this.state.avgFps + 1 / frameDurationSec) / 2;\n            }\n            this.priorFrameCompletedTime = performance.now();\n        }\n    }\n}\n"]}

package/lib/session/LensPerformanceMetrics.d.ts

@@ -0,0 +1,31 @@
+import { LensCoreModule } from "../lens-core-module";
+import { LensPerformanceMeasurement } from "./LensPerformanceMeasurement";
+/**
+ * Use to measure lens rendering performance.
+ *
+ * The {@link LensPerformanceMetrics.beginMeasurement} method is used to start measuring rendering performance. After
+ * a measurement has begun, performance metrics can be read using {@link LensPerformanceMeasurement}.
+ *
+ * @example
+ * ```ts
+ * const measurement = cameraKitSession.metrics.beginMeasurement()
+ * // some time later
+ * console.log(measurement.measure())
+ * ```
+ *
+ * @category Rendering
+ * @category Metrics
+ */
+export declare class LensPerformanceMetrics {
+    private lensCore;
+    private readonly measurementInstances;
+    /** @internal */
+    constructor(lensCore: LensCoreModule);
+    /**
+     * Begin a measurement window, during which time rendering metrics will be gathered.
+     *
+     * @returns A {@link LensPerformanceMeasurement} representing an ongoing measurement of aggregated rendering
+     * metrics, from which specific metrics can be obtained.
+     */
+    beginMeasurement(): LensPerformanceMeasurement;
+}

package/lib/session/LensPerformanceMetrics.js

@@ -0,0 +1,58 @@
+import { __decorate, __metadata } from "tslib";
+import { errorLoggingDecorator } from "../logger/errorLoggingDecorator";
+import { getLogger } from "../logger/logger";
+import { LensPerformanceMeasurement } from "./LensPerformanceMeasurement";
+const logger = getLogger("RenderingMetrics");
+const log = errorLoggingDecorator(logger);
+/**
+ * Use to measure lens rendering performance.
+ *
+ * The {@link LensPerformanceMetrics.beginMeasurement} method is used to start measuring rendering performance. After
+ * a measurement has begun, performance metrics can be read using {@link LensPerformanceMeasurement}.
+ *
+ * @example
+ * ```ts
+ * const measurement = cameraKitSession.metrics.beginMeasurement()
+ * // some time later
+ * console.log(measurement.measure())
+ * ```
+ *
+ * @category Rendering
+ * @category Metrics
+ */
+export class LensPerformanceMetrics {
+    /** @internal */
+    constructor(lensCore) {
+        this.lensCore = lensCore;
+        this.measurementInstances = new Set();
+        this.lensCore.setOnFrameProcessedCallback({
+            onFrameProcessed: ({ processingTimeMs }) => {
+                try {
+                    for (const measurement of this.measurementInstances.values()) {
+                        measurement.update(processingTimeMs);
+                    }
+                }
+                catch (error) {
+                    logger.error(error);
+                }
+            },
+            onFailure: (error) => logger.error(`Failed registering setOnFrameProcessedCallback with error: ${error.message}`),
+        });
+    }
+    /**
+     * Begin a measurement window, during which time rendering metrics will be gathered.
+     *
+     * @returns A {@link LensPerformanceMeasurement} representing an ongoing measurement of aggregated rendering
+     * metrics, from which specific metrics can be obtained.
+     */
+    beginMeasurement() {
+        return new LensPerformanceMeasurement(this.measurementInstances);
+    }
+}
+__decorate([
+    log,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", LensPerformanceMeasurement)
+], LensPerformanceMetrics.prototype, "beginMeasurement", null);
+//# sourceMappingURL=LensPerformanceMetrics.js.map

package/lib/session/LensPerformanceMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LensPerformanceMetrics.js","sourceRoot":"","sources":["../../src/session/LensPerformanceMetrics.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,MAAM,MAAM,GAAG,SAAS,CAAC,kBAAkB,CAAC,CAAC;AAC7C,MAAM,GAAG,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,sBAAsB;IAG/B,gBAAgB;IAChB,YAAoB,QAAwB;QAAxB,aAAQ,GAAR,QAAQ,CAAgB;QACxC,IAAI,CAAC,oBAAoB,GAAG,IAAI,GAAG,EAAE,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC;YACtC,gBAAgB,EAAE,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE;gBACvC,IAAI;oBACA,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,EAAE;wBAC1D,WAAW,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;qBACxC;iBACJ;gBAAC,OAAO,KAAK,EAAE;oBACZ,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;iBACvB;YACL,CAAC;YACD,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CACjB,MAAM,CAAC,KAAK,CAAC,8DAA8D,KAAK,CAAC,OAAO,EAAE,CAAC;SAClG,CAAC,CAAC;IACP,CAAC;IAED;;;;;OAKG;IAEH,gBAAgB;QACZ,OAAO,IAAI,0BAA0B,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACrE,CAAC;CACJ;AAJG;IAAC,GAAG;;;oCACgB,0BAA0B;8DAE7C","sourcesContent":["import { errorLoggingDecorator } from \"../logger/errorLoggingDecorator\";\nimport { LensCoreModule } from \"../lens-core-module\";\nimport { getLogger } from \"../logger/logger\";\nimport { LensPerformanceMeasurement } from \"./LensPerformanceMeasurement\";\n\nconst logger = getLogger(\"RenderingMetrics\");\nconst log = errorLoggingDecorator(logger);\n\n/**\n * Use to measure lens rendering performance.\n *\n * The {@link LensPerformanceMetrics.beginMeasurement} method is used to start measuring rendering performance. After\n * a measurement has begun, performance metrics can be read using {@link LensPerformanceMeasurement}.\n *\n * @example\n * ```ts\n * const measurement = cameraKitSession.metrics.beginMeasurement()\n * // some time later\n * console.log(measurement.measure())\n * ```\n *\n * @category Rendering\n * @category Metrics\n */\nexport class LensPerformanceMetrics {\n    private readonly measurementInstances: Set<LensPerformanceMeasurement>;\n\n    /** @internal */\n    constructor(private lensCore: LensCoreModule) {\n        this.measurementInstances = new Set();\n        this.lensCore.setOnFrameProcessedCallback({\n            onFrameProcessed: ({ processingTimeMs }) => {\n                try {\n                    for (const measurement of this.measurementInstances.values()) {\n                        measurement.update(processingTimeMs);\n                    }\n                } catch (error) {\n                    logger.error(error);\n                }\n            },\n            onFailure: (error) =>\n                logger.error(`Failed registering setOnFrameProcessedCallback with error: ${error.message}`),\n        });\n    }\n\n    /**\n     * Begin a measurement window, during which time rendering metrics will be gathered.\n     *\n     * @returns A {@link LensPerformanceMeasurement} representing an ongoing measurement of aggregated rendering\n     * metrics, from which specific metrics can be obtained.\n     */\n    @log\n    beginMeasurement(): LensPerformanceMeasurement {\n        return new LensPerformanceMeasurement(this.measurementInstances);\n    }\n}\n"]}

package/lib/session/index.d.ts

@@ -0,0 +1 @@
+export { Keyboard } from "./LensKeyboard";

package/lib/session/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/lib/session/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"","sourcesContent":["export { Keyboard } from \"./LensKeyboard\";\n"]}

package/lib/session/lensState.d.ts

@@ -0,0 +1,29 @@
+import { StateMachine } from "@snap/state-management";
+import { Lens } from "../lens/Lens";
+import { LensRepository } from "../lens/LensRepository";
+import { LensCoreModule } from "../lens-core-module";
+import { IndexedDBPersistence } from "../persistence/IndexedDBPersistence";
+import { LensLaunchParams } from "../lens/LensLaunchParams";
+import { LensAssetRepository } from "../lens/assets/LensAssetRepository";
+import { LegalError, LensContentValidationError, LensError } from "../namedErrors";
+declare const createLensState: () => StateMachine<import("@snap/state-management").Action<"applyLens", {
+    lens: Lens;
+    launchParams?: LensLaunchParams | undefined;
+}> | import("@snap/state-management").Action<"downloadComplete", Lens> | import("@snap/state-management").Action<"turnedOn", Lens> | import("@snap/state-management").Action<"resourcesLoaded", Lens> | import("@snap/state-management").Action<"firstFrameProcessed", Lens> | import("@snap/state-management").Action<"applyLensComplete", Lens> | import("@snap/state-management").Action<"applyLensFailed", {
+    error: LensErrors;
+    lens: Lens;
+}> | import("@snap/state-management").Action<"removeLens", undefined> | import("@snap/state-management").Action<"turnedOff", Lens> | import("@snap/state-management").Action<"removeLensComplete", undefined> | import("@snap/state-management").Action<"removeLensFailed", Error>, import("@snap/state-management").State<"noLensApplied", undefined> | import("@snap/state-management").State<"applyingLens", Lens> | import("@snap/state-management").State<"lensApplied", Lens>>;
+export declare type LensErrors = LegalError | LensContentValidationError | LensError;
+export declare type LensState = ReturnType<typeof createLensState>;
+export declare const lensStateFactory: {
+    (args_0: LensCoreModule, args_1: LensRepository, args_2: LensAssetRepository, args_3: IndexedDBPersistence<ArrayBuffer>, args_4: StateMachine<import("@snap/state-management").Action<"requestLegalPrompt", undefined> | import("@snap/state-management").Action<"accept", string> | import("@snap/state-management").Action<"reject", string>, import("@snap/state-management").State<"unknown", undefined> | import("@snap/state-management").State<"accepted", undefined> | import("@snap/state-management").State<"rejected", undefined>>): StateMachine<import("@snap/state-management").Action<"applyLens", {
+        lens: Lens;
+        launchParams?: LensLaunchParams | undefined;
+    }> | import("@snap/state-management").Action<"downloadComplete", Lens> | import("@snap/state-management").Action<"turnedOn", Lens> | import("@snap/state-management").Action<"resourcesLoaded", Lens> | import("@snap/state-management").Action<"firstFrameProcessed", Lens> | import("@snap/state-management").Action<"applyLensComplete", Lens> | import("@snap/state-management").Action<"applyLensFailed", {
+        error: LensErrors;
+        lens: Lens;
+    }> | import("@snap/state-management").Action<"removeLens", undefined> | import("@snap/state-management").Action<"turnedOff", Lens> | import("@snap/state-management").Action<"removeLensComplete", undefined> | import("@snap/state-management").Action<"removeLensFailed", Error>, import("@snap/state-management").State<"noLensApplied", undefined> | import("@snap/state-management").State<"applyingLens", Lens> | import("@snap/state-management").State<"lensApplied", Lens>>;
+    token: "lensState";
+    dependencies: readonly ["lensCore", "LensRepository", "lensAssetRepository", "lensPersistenceStore", "legalState"];
+};
+export {};