@snap/camera-kit 0.7.0

package/lib/CameraKit.d.ts

@@ -0,0 +1,170 @@
+import { LensRepository } from "./lens/LensRepository";
+import { Container } from "./dependency-injection/Container";
+import { LensCoreModule } from "./lens-core-module/generated-types";
+import { CameraKitSession } from "./session/CameraKitSession";
+import { RootServices } from "./dependency-injection/RootServices";
+import { MetricsEventTarget } from "./metrics/metricsEventTarget";
+import { TypedEventTarget } from "./events/TypedEventTarget";
+import { TypedCustomEvent } from "./events/TypedCustomEvent";
+import { LensView } from "./metrics/reporters/reportLensView";
+import { LensWait } from "./metrics/reporters/reportLensWait";
+/**
+ * Lens metrics events.
+ *
+ * These events are emitted by {@link CameraKit} to report lens usage, performance, apply latency, etc.
+ *
+ * @category Lenses
+ * @category Metrics
+ */
+export declare type LensMetricsEvents = TypedCustomEvent<LensView["name"], LensView> | TypedCustomEvent<LensWait["name"], LensWait>;
+/**
+ * Options available when creating a {@link CameraKitSession}.
+ *
+ * @category Rendering
+ */
+export interface CreateSessionOptions {
+    /**
+     * Optionally provide an existing canvas element, on which the Live RenderTarget will be rendered.
+     *
+     * If this is not provided, CameraKit will create a new canvas element which can be added to the DOM.
+     */
+    liveRenderTarget?: HTMLCanvasElement;
+    /**
+     * Browsers optimize tabs when they are hidden - for example, by pausing the execution of requestAnimationFrame
+     * callbacks.
+     *
+     * If you need the CameraKitSession to continue rendering even when the tab is in the background, set this to true.
+     * There is a small performance penalty, and it's a good practice to only render in the background if absolutely
+     * necessary.
+     */
+    renderWhileTabHidden?: boolean;
+}
+/**
+ * The entry point to the CameraKit SDK's API. Most of CameraKit's features are accessed via this class.
+ *
+ * Applications obtain an instance of CameraKit by calling {@link bootstrapCameraKit}.
+ *
+ * @example
+ * ```ts
+ * const cameraKit = await bootstrapCameraKit(config)
+ * ```
+ *
+ * Then this class can be used to:
+ * - Create a {@link CameraKitSession} instance, which provides the API for setting up media inputs, applying Lenses,
+ * and obtaining rendered `<canvas>` outputs.
+ * - Query for lenses using {@link LensRepository}.
+ * - Listen for lens usage metrics events using {@link MetricsEventTarget}.
+ *
+ * @category Rendering
+ * @category Lenses
+ */
+export declare class CameraKit {
+    /**
+     * Used to query for lenses and lens groups.
+     */
+    readonly lensRepository: LensRepository;
+    private readonly lensCore;
+    private readonly container;
+    /** @deprecated Use {@link lensRepository} */
+    readonly lenses: {
+        repository: LensRepository;
+    };
+    /**
+     * Business metrics (e.g. each time a lens is viewed) are emitted here.
+     */
+    readonly metrics: TypedEventTarget<LensMetricsEvents>;
+    /** @internal */
+    constructor(
+    /**
+     * Used to query for lenses and lens groups.
+     */
+    lensRepository: LensRepository, lensCore: LensCoreModule, container: Container<RootServices>, allMetrics: MetricsEventTarget);
+    /**
+     * Create a CameraKitSession.
+     *
+     * This initializes the rendering engine and returns a {@link CameraKitSession} instance, which provides access
+     * to Lens rendering.
+     *
+     * @example
+     * ```ts
+     * const cameraKit = await bootstrapCameraKit(config)
+     * const session = await cameraKit.createSession()
+     *
+     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)
+     * session.applyLens(lens)
+     * ```
+     *
+     * @param options
+     */
+    createSession({ liveRenderTarget, renderWhileTabHidden, }?: CreateSessionOptions): Promise<CameraKitSession>;
+}
+/** @internal */
+export declare const cameraKitFactory: {
+    (args_0: LensRepository, args_1: MetricsEventTarget, args_2: LensCoreModule, args_3: Container<{
+        LensRepository: LensRepository;
+    } & {
+        metricsEventTarget: MetricsEventTarget;
+    } & {
+        lensCore: LensCoreModule;
+    } & {
+        lensCore: LensCoreModule;
+    } & import("./dependency-injection/RootServices").PublicServices & import("./dependency-injection/types").ServicesFromInjectables<[{
+        (): MetricsEventTarget;
+        token: "metricsEventTarget";
+        dependencies: [];
+    }, {
+        (args_0: import("./configuration").CameraKitConfiguration, args_1: import("./handlers").FetchHandler<Response>): import("./handlers/HandlerChainBuilder").Handler<RequestInfo, Response, RequestInit | undefined>;
+        token: "cameraKitServiceFetchHandler";
+        dependencies: readonly ["configuration", "defaultFetchHandler"];
+    }, {
+        (args_0: import("./configuration").CameraKitConfiguration): import("./remote-configuration/remoteConfiguration").RemoteConfiguration;
+        token: "remoteConfiguration";
+        dependencies: readonly ["configuration"];
+    }, {
+        (args_0: import("./handlers").FetchHandler<Response>, args_1: import("./handlers").FetchHandler<Response>, args_2: import("./lens").LensSources, args_3: import("./lens").LensAssetRepository): LensRepository;
+        token: "LensRepository";
+        dependencies: readonly ["cameraKitServiceFetchHandler", "defaultFetchHandler", "lensSources", "lensAssetRepository"];
+    }, {
+        (args_0: LensCoreModule): import("./persistence/IndexedDBPersistence").IndexedDBPersistence<ArrayBuffer>;
+        token: "lensPersistenceStore";
+        dependencies: readonly ["lensCore"];
+    }, {
+        (args_0: import("./handlers").FetchHandler<Response>): import("./handlers/HandlerChainBuilder").Handler<RequestInfo, Response, RequestInit | undefined>;
+        token: "metricsHandler";
+        dependencies: readonly ["cameraKitServiceFetchHandler"];
+    }, {
+        (args_0: import("./handlers").FetchHandler<Response>): import("./metrics/operationalMetricsReporter").OperationalMetricsReporter;
+        token: "operationalMetricsReporter";
+        dependencies: readonly ["metricsHandler"];
+    }, {
+        (args_0: LensCoreModule, args_1: import("./lens").AssetLoader, args_2: import("./lens").AssetLoader, args_3: import("./lens").AssetLoader, args_4: MetricsEventTarget): import("./lens").LensAssetRepository;
+        token: "lensAssetRepository";
+        dependencies: readonly ["lensCore", "deviceDependentAssetLoader", "remoteMediaAssetLoader", "staticAssetLoader", "metricsEventTarget"];
+    }, {
+        (args_0: import("./handlers").FetchHandler<Response>, args_1: import("./remote-configuration/remoteConfiguration").RemoteConfiguration): import("./lens").AssetLoader;
+        token: "deviceDependentAssetLoader";
+        dependencies: readonly ["defaultFetchHandler", "remoteConfiguration"];
+    }, {
+        (args_0: import("./handlers").FetchHandler<Response>): import("./lens").AssetLoader;
+        token: "staticAssetLoader";
+        dependencies: readonly ["defaultFetchHandler"];
+    }, {
+        (args_0: import("./remote-configuration/remoteConfiguration").RemoteConfiguration, args_1: import("./legal/legalPrompt").LegalPrompt): import("@snap/state-management").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>>;
+        token: "legalState";
+        dependencies: readonly ["remoteConfiguration", "legalPrompt"];
+    }, {
+        (): import("./legal/legalPrompt").LegalPrompt;
+        token: "legalPrompt";
+        dependencies: [];
+    }, {
+        (): import("rxjs").Observable<import("./logger/logger").LogEntry>;
+        token: "logEntries";
+        dependencies: [];
+    }, {
+        (args_0: import("rxjs").Observable<import("./logger/logger").LogEntry>, args_1: MetricsEventTarget, args_2: import("./metrics/operationalMetricsReporter").OperationalMetricsReporter): import("./metrics/reporters/reportGlobalException").GlobalExceptionReporter;
+        token: "reportGlobalException";
+        dependencies: readonly ["logEntries", "metricsEventTarget", "operationalMetricsReporter"];
+    }]>>): CameraKit;
+    token: "CameraKit";
+    dependencies: readonly ["LensRepository", "metricsEventTarget", "lensCore", "$container"];
+};

package/lib/CameraKit.js

@@ -0,0 +1,145 @@
+import { __awaiter, __decorate, __metadata } from "tslib";
+import { lensRepositoryFactory } from "./lens/LensRepository";
+import { CONTAINER } from "./dependency-injection/Container";
+import { Injectable } from "./dependency-injection/Injectable";
+import { cameraKitSessionFactory } from "./session/CameraKitSession";
+import { registerLensAssetsProvider } from "./lens/assets/LensAssetsProvider";
+import { lensCoreFactory } from "./lens-core-module/loader/lensCoreFactory";
+import { configurationToken } from "./configuration";
+import { registerUriHandlers } from "./extensions/UriHandlers";
+import { metricsEventTargetFactory } from "./metrics/metricsEventTarget";
+import { reportSessionScopedMetrics } from "./metrics/reporters/reporters";
+import { lensStateFactory } from "./session/lensState";
+import { lensKeyboardFactory } from "./session/LensKeyboard";
+import { registerLensClientInterfaceHandler } from "./lens-client-interface/lensClientInterface";
+import { sessionStateFactory } from "./session/sessionState";
+import { lensExecutionError } from "./namedErrors";
+import { getLogger } from "./logger/logger";
+import { errorLoggingDecorator } from "./logger/errorLoggingDecorator";
+import { TypedEventTarget } from "./events/TypedEventTarget";
+const logger = getLogger("CameraKit");
+const log = errorLoggingDecorator(logger);
+/**
+ * Metrics event names that are exposed to apps.
+ */
+const publicMetricsEventNames = ["lensView", "lensWait"];
+/**
+ * The entry point to the CameraKit SDK's API. Most of CameraKit's features are accessed via this class.
+ *
+ * Applications obtain an instance of CameraKit by calling {@link bootstrapCameraKit}.
+ *
+ * @example
+ * ```ts
+ * const cameraKit = await bootstrapCameraKit(config)
+ * ```
+ *
+ * Then this class can be used to:
+ * - Create a {@link CameraKitSession} instance, which provides the API for setting up media inputs, applying Lenses,
+ * and obtaining rendered `<canvas>` outputs.
+ * - Query for lenses using {@link LensRepository}.
+ * - Listen for lens usage metrics events using {@link MetricsEventTarget}.
+ *
+ * @category Rendering
+ * @category Lenses
+ */
+export class CameraKit {
+    /** @internal */
+    constructor(
+    /**
+     * Used to query for lenses and lens groups.
+     */
+    lensRepository, lensCore, container, allMetrics) {
+        this.lensRepository = lensRepository;
+        this.lensCore = lensCore;
+        this.container = container;
+        /**
+         * Business metrics (e.g. each time a lens is viewed) are emitted here.
+         */
+        this.metrics = new TypedEventTarget();
+        this.lenses = { repository: this.lensRepository };
+        // Proxy only a subset of all metrics events to the public-facing emitter -- applications don't need to
+        // know about most events.
+        publicMetricsEventNames.forEach((eventName) => {
+            allMetrics.addEventListener(eventName, (e) => this.metrics.dispatchEvent(e));
+        });
+    }
+    /**
+     * Create a CameraKitSession.
+     *
+     * This initializes the rendering engine and returns a {@link CameraKitSession} instance, which provides access
+     * to Lens rendering.
+     *
+     * @example
+     * ```ts
+     * const cameraKit = await bootstrapCameraKit(config)
+     * const session = await cameraKit.createSession()
+     *
+     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)
+     * session.applyLens(lens)
+     * ```
+     *
+     * @param options
+     */
+    createSession({ liveRenderTarget, renderWhileTabHidden, } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Any error happened during lens rendering can be processed by subscribing to sessionErrors
+            const exceptionHandler = (e) => logger.error(lensExecutionError("Lens execution error.", e));
+            /**
+             * If/when we add support for multiple concurrent sessions, we'll need to create a copy of the LensCore WASM
+             * module. If we move managing web workers into JS, spawing a new worker thread with its own copy of LensCore
+             * probably becomes a lot more straightforward.
+             *
+             * Currently chromium has a bug preventing rendering while tab is hidden when LensCore is in worker mode.
+             * In order to process tab while it is hidden, the current stopgap is to pass in renderWhileTabHidden as true,
+             * which will initiate session in non worker mode, and set the RenderLoopMode to `SetTimeout`.
+             */
+            yield new Promise((onSuccess, onFailure) => {
+                this.lensCore.initialize({
+                    canvas: liveRenderTarget,
+                    shouldUseWorker: !renderWhileTabHidden && this.container.get(configurationToken).shouldUseWorker,
+                    exceptionHandler,
+                    onSuccess,
+                    onFailure,
+                });
+            });
+            yield new Promise((onSuccess, onFailure) => {
+                this.lensCore.setRenderLoopMode({
+                    mode: renderWhileTabHidden
+                        ? this.lensCore.RenderLoopMode.SetTimeout
+                        : this.lensCore.RenderLoopMode.RequestAnimationFrame,
+                    onSuccess,
+                    onFailure,
+                });
+            });
+            // Each session gets its own DI Container – some Services provided by this Container may be shared with the
+            // root CameraKit Container, but others may be scoped to the session by passing their token to `copy()`.
+            const sessionContainer = this.container
+                // Right now this is a no-op. If/when we add support for multiple concurrent sessions, we may end up
+                // scoping LensCore to the session.
+                .copy()
+                .provides(sessionStateFactory)
+                .provides(lensStateFactory)
+                .provides(lensKeyboardFactory)
+                .provides(cameraKitSessionFactory)
+                .run(registerLensAssetsProvider)
+                .run(registerLensClientInterfaceHandler)
+                // We'll run a PartialContainer containing reporters for session-scoped metrics. Running this container
+                // allows each metric reporter to initialize itself (e.g. by adding event listeners to detect when certain
+                // actions occur).
+                .run(reportSessionScopedMetrics)
+                // UriHandlers may have dependencies on session-scoped services (e.g. LensState, LensKeyboard), so they'll
+                // be registered with LensCore here.
+                .run(registerUriHandlers);
+            return sessionContainer.get(cameraKitSessionFactory.token);
+        });
+    }
+}
+__decorate([
+    log,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CameraKit.prototype, "createSession", null);
+/** @internal */
+export const cameraKitFactory = Injectable("CameraKit", [lensRepositoryFactory.token, metricsEventTargetFactory.token, lensCoreFactory.token, CONTAINER], (lensRepository, metrics, lensCore, container) => new CameraKit(lensRepository, lensCore, container, metrics));
+//# sourceMappingURL=CameraKit.js.map

package/lib/CameraKit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CameraKit.js","sourceRoot":"","sources":["../src/CameraKit.ts"],"names":[],"mappings":"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","sourcesContent":["import { lensRepositoryFactory, LensRepository } from \"./lens/LensRepository\";\nimport { CONTAINER, Container } from \"./dependency-injection/Container\";\nimport { Injectable } from \"./dependency-injection/Injectable\";\nimport { LensCoreError, LensCoreModule } from \"./lens-core-module/generated-types\";\nimport { CameraKitSession, cameraKitSessionFactory } from \"./session/CameraKitSession\";\nimport { registerLensAssetsProvider } from \"./lens/assets/LensAssetsProvider\";\nimport { lensCoreFactory } from \"./lens-core-module/loader/lensCoreFactory\";\nimport { configurationToken } from \"./configuration\";\nimport { RootServices } from \"./dependency-injection/RootServices\";\nimport { registerUriHandlers } from \"./extensions/UriHandlers\";\nimport { MetricsEventTarget, metricsEventTargetFactory } from \"./metrics/metricsEventTarget\";\nimport { reportSessionScopedMetrics } from \"./metrics/reporters/reporters\";\nimport { lensStateFactory } from \"./session/lensState\";\nimport { lensKeyboardFactory } from \"./session/LensKeyboard\";\nimport { registerLensClientInterfaceHandler } from \"./lens-client-interface/lensClientInterface\";\nimport { sessionStateFactory } from \"./session/sessionState\";\nimport { lensExecutionError } from \"./namedErrors\";\nimport { getLogger } from \"./logger/logger\";\nimport { errorLoggingDecorator } from \"./logger/errorLoggingDecorator\";\nimport { TypedEventTarget } from \"./events/TypedEventTarget\";\nimport { TypedCustomEvent } from \"./events/TypedCustomEvent\";\nimport { LensView } from \"./metrics/reporters/reportLensView\";\nimport { LensWait } from \"./metrics/reporters/reportLensWait\";\n\nconst logger = getLogger(\"CameraKit\");\nconst log = errorLoggingDecorator(logger);\n\n/**\n * Metrics event names that are exposed to apps.\n */\nconst publicMetricsEventNames: Array<LensMetricsEvents[\"detail\"][\"name\"]> = [\"lensView\", \"lensWait\"];\n\n/**\n * Lens metrics events.\n *\n * These events are emitted by {@link CameraKit} to report lens usage, performance, apply latency, etc.\n *\n * @category Lenses\n * @category Metrics\n */\nexport type LensMetricsEvents =\n    | TypedCustomEvent<LensView[\"name\"], LensView>\n    | TypedCustomEvent<LensWait[\"name\"], LensWait>;\n\n/**\n * Options available when creating a {@link CameraKitSession}.\n *\n * @category Rendering\n */\nexport interface CreateSessionOptions {\n    /**\n     * Optionally provide an existing canvas element, on which the Live RenderTarget will be rendered.\n     *\n     * If this is not provided, CameraKit will create a new canvas element which can be added to the DOM.\n     */\n    liveRenderTarget?: HTMLCanvasElement;\n\n    /**\n     * Browsers optimize tabs when they are hidden - for example, by pausing the execution of requestAnimationFrame\n     * callbacks.\n     *\n     * If you need the CameraKitSession to continue rendering even when the tab is in the background, set this to true.\n     * There is a small performance penalty, and it's a good practice to only render in the background if absolutely\n     * necessary.\n     */\n    renderWhileTabHidden?: boolean;\n}\n\n/**\n * The entry point to the CameraKit SDK's API. Most of CameraKit's features are accessed via this class.\n *\n * Applications obtain an instance of CameraKit by calling {@link bootstrapCameraKit}.\n *\n * @example\n * ```ts\n * const cameraKit = await bootstrapCameraKit(config)\n * ```\n *\n * Then this class can be used to:\n * - Create a {@link CameraKitSession} instance, which provides the API for setting up media inputs, applying Lenses,\n * and obtaining rendered `<canvas>` outputs.\n * - Query for lenses using {@link LensRepository}.\n * - Listen for lens usage metrics events using {@link MetricsEventTarget}.\n *\n * @category Rendering\n * @category Lenses\n */\nexport class CameraKit {\n    /** @deprecated Use {@link lensRepository} */\n    readonly lenses: { repository: LensRepository };\n\n    /**\n     * Business metrics (e.g. each time a lens is viewed) are emitted here.\n     */\n    readonly metrics: TypedEventTarget<LensMetricsEvents> = new TypedEventTarget();\n\n    /** @internal */\n    constructor(\n        /**\n         * Used to query for lenses and lens groups.\n         */\n        readonly lensRepository: LensRepository,\n\n        private readonly lensCore: LensCoreModule,\n        private readonly container: Container<RootServices>,\n        allMetrics: MetricsEventTarget\n    ) {\n        this.lenses = { repository: this.lensRepository };\n        // Proxy only a subset of all metrics events to the public-facing emitter -- applications don't need to\n        // know about most events.\n        publicMetricsEventNames.forEach((eventName) => {\n            allMetrics.addEventListener(eventName, (e) => this.metrics.dispatchEvent(e));\n        });\n    }\n\n    /**\n     * Create a CameraKitSession.\n     *\n     * This initializes the rendering engine and returns a {@link CameraKitSession} instance, which provides access\n     * to Lens rendering.\n     *\n     * @example\n     * ```ts\n     * const cameraKit = await bootstrapCameraKit(config)\n     * const session = await cameraKit.createSession()\n     *\n     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)\n     * session.applyLens(lens)\n     * ```\n     *\n     * @param options\n     */\n    @log\n    async createSession({\n        liveRenderTarget,\n        renderWhileTabHidden,\n    }: CreateSessionOptions = {}): Promise<CameraKitSession> {\n        // Any error happened during lens rendering can be processed by subscribing to sessionErrors\n        const exceptionHandler = (e: LensCoreError) => logger.error(lensExecutionError(\"Lens execution error.\", e));\n\n        /**\n         * If/when we add support for multiple concurrent sessions, we'll need to create a copy of the LensCore WASM\n         * module. If we move managing web workers into JS, spawing a new worker thread with its own copy of LensCore\n         * probably becomes a lot more straightforward.\n         *\n         * Currently chromium has a bug preventing rendering while tab is hidden when LensCore is in worker mode.\n         * In order to process tab while it is hidden, the current stopgap is to pass in renderWhileTabHidden as true,\n         * which will initiate session in non worker mode, and set the RenderLoopMode to `SetTimeout`.\n         */\n        await new Promise<void>((onSuccess, onFailure) => {\n            this.lensCore.initialize({\n                canvas: liveRenderTarget,\n                shouldUseWorker: !renderWhileTabHidden && this.container.get(configurationToken).shouldUseWorker,\n                exceptionHandler,\n                onSuccess,\n                onFailure,\n            });\n        });\n\n        await new Promise<void>((onSuccess, onFailure) => {\n            this.lensCore.setRenderLoopMode({\n                mode: renderWhileTabHidden\n                    ? this.lensCore.RenderLoopMode.SetTimeout\n                    : this.lensCore.RenderLoopMode.RequestAnimationFrame,\n                onSuccess,\n                onFailure,\n            });\n        });\n\n        // Each session gets its own DI Container – some Services provided by this Container may be shared with the\n        // root CameraKit Container, but others may be scoped to the session by passing their token to `copy()`.\n        const sessionContainer = this.container\n            // Right now this is a no-op. If/when we add support for multiple concurrent sessions, we may end up\n            // scoping LensCore to the session.\n            .copy()\n\n            .provides(sessionStateFactory)\n            .provides(lensStateFactory)\n            .provides(lensKeyboardFactory)\n            .provides(cameraKitSessionFactory)\n\n            .run(registerLensAssetsProvider)\n            .run(registerLensClientInterfaceHandler)\n\n            // We'll run a PartialContainer containing reporters for session-scoped metrics. Running this container\n            // allows each metric reporter to initialize itself (e.g. by adding event listeners to detect when certain\n            // actions occur).\n            .run(reportSessionScopedMetrics)\n\n            // UriHandlers may have dependencies on session-scoped services (e.g. LensState, LensKeyboard), so they'll\n            // be registered with LensCore here.\n            .run(registerUriHandlers);\n\n        return sessionContainer.get(cameraKitSessionFactory.token);\n    }\n}\n\n/** @internal */\nexport const cameraKitFactory = Injectable(\n    \"CameraKit\",\n    [lensRepositoryFactory.token, metricsEventTargetFactory.token, lensCoreFactory.token, CONTAINER] as const,\n    (\n        lensRepository: LensRepository,\n        metrics: MetricsEventTarget,\n        lensCore: LensCoreModule,\n        container: Container<RootServices>\n    ) => new CameraKit(lensRepository, lensCore, container, metrics)\n);\n"]}

package/lib/__tests__/data.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { ContentProto, LensProto } from "../lens";
+import { LensCoreModule, AssetType as LensCoreAssetType } from "../lens-core-module/generated-types";
+export declare const falsyValues: readonly [false, null, undefined, 0, ""];
+export declare const truthyValues: readonly [true, 1, {}, Date, readonly []];
+export declare function createLensFixture(name: string, content?: Partial<ContentProto>): LensProto;
+export declare type LensCoreMock = Pick<jest.Mocked<LensCoreModule>, "AssetType" | "CanvasType" | "InterfaceAction" | "InterfaceControl" | "ExternalMediaOrientation" | "initialize" | "setRemoteAssetsProvider" | "provideRemoteAssetsResponse" | "getOutputCanvases" | "setRenderLoopMode" | "RenderLoopMode" | "setOnFrameProcessedCallback" | "setClientInterfaceRequestHandler" | "provideExternalImage" | "provideExternalVideo" | "registerSavePersistentStoreCallback">;
+export declare const AssetType: Record<keyof LensCoreModule["AssetType"], LensCoreAssetType>;
+export declare function createLensCore(): LensCoreMock;

package/lib/__tests__/data.js

@@ -0,0 +1,50 @@
+/* eslint-disable max-len */
+import { Lens_CameraFacing } from "../lens";
+export const falsyValues = [false, null, undefined, 0, ""];
+export const truthyValues = [true, 1, {}, new Date(), []];
+export function createLensFixture(name, content) {
+    return {
+        id: name,
+        name,
+        vendorData: {},
+        content: Object.assign({ iconUrlBolt: "https://bolt.com/iconUrl1", lnsSha256: "", lnsUrlBolt: "", preview: { imageUrl: "https://bolt.com/previewUrl1" }, assetManifest: [], defaultHintId: "", hintTranslations: {} }, content),
+        isThirdParty: false,
+        cameraFacingPreference: Lens_CameraFacing.UNRECOGNIZED,
+        featureMetadata: [],
+        lensCreator: {
+            displayName: "",
+        },
+    };
+}
+// NOTE: type of the record ensures newly added asset types break compilation
+export const AssetType = {
+    DeviceDependent: { value: 3 },
+    RemoteMediaByUrl: { value: 6 },
+    Static: { value: 1 },
+    URL: { value: 2 },
+    BitmojiDynamicAsset: { value: 4 },
+};
+export function createLensCore() {
+    return {
+        AssetType,
+        CanvasType: { Preview: { value: 1 }, Capture: { value: 2 }, None: { value: 0 }, All: { value: 3 } },
+        RenderLoopMode: { SetTimeout: { value: 1 }, RequestAnimationFrame: { value: 0 } },
+        // https://github.sc-corp.net/Snapchat/LensCore/blob/502b54b9a663203bcdf3b90c63214cdf8cc1e713/Src/CoreManager/ClientInterfaceDelegate.hpp#L39
+        InterfaceAction: { Show: { value: 3 } },
+        // https://github.sc-corp.net/Snapchat/LensCore/blob/502b54b9a663203bcdf3b90c63214cdf8cc1e713/Src/CoreManager/ClientInterfaceDelegate.hpp#L21
+        InterfaceControl: { ImagePicker: { value: 1 } },
+        // https://github.sc-corp.net/Snapchat/LensCore/blob/2d538ecc41f67dd2c199e0ff0eefd96aac6f22dc/Src/Common/IExternalMediaFilePickedObserver.h#L21
+        ExternalMediaOrientation: { CW0: { value: 0 }, CW90: { value: 1 }, CW180: { value: 2 }, CW270: { value: 3 } },
+        initialize: jest.fn(),
+        setRemoteAssetsProvider: jest.fn(),
+        provideRemoteAssetsResponse: jest.fn(),
+        getOutputCanvases: jest.fn(),
+        setRenderLoopMode: jest.fn(),
+        setOnFrameProcessedCallback: jest.fn(),
+        setClientInterfaceRequestHandler: jest.fn(),
+        provideExternalImage: jest.fn(),
+        provideExternalVideo: jest.fn(),
+        registerSavePersistentStoreCallback: jest.fn(),
+    };
+}
+//# sourceMappingURL=data.js.map

package/lib/__tests__/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","sourceRoot":"","sources":["../../src/__tests__/data.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport { ContentProto, LensProto, Lens_CameraFacing } from \"../lens\";\nimport { LensCoreModule, AssetType as LensCoreAssetType } from \"../lens-core-module/generated-types\";\n\nexport const falsyValues = [false, null, undefined, 0, \"\"] as const;\nexport const truthyValues = [true, 1, {}, new Date(), []] as const;\n\nexport function createLensFixture(name: string, content?: Partial<ContentProto>): LensProto {\n    return {\n        id: name,\n        name,\n        vendorData: {},\n        content: {\n            iconUrlBolt: \"https://bolt.com/iconUrl1\",\n            lnsSha256: \"\",\n            lnsUrlBolt: \"\",\n            preview: { imageUrl: \"https://bolt.com/previewUrl1\" },\n            assetManifest: [],\n            defaultHintId: \"\",\n            hintTranslations: {},\n            ...content,\n        },\n        isThirdParty: false,\n        cameraFacingPreference: Lens_CameraFacing.UNRECOGNIZED,\n        featureMetadata: [],\n        lensCreator: {\n            displayName: \"\",\n        },\n    };\n}\n\nexport type LensCoreMock = Pick<\n    jest.Mocked<LensCoreModule>,\n    | \"AssetType\"\n    | \"CanvasType\"\n    | \"InterfaceAction\"\n    | \"InterfaceControl\"\n    | \"ExternalMediaOrientation\"\n    | \"initialize\"\n    | \"setRemoteAssetsProvider\"\n    | \"provideRemoteAssetsResponse\"\n    | \"getOutputCanvases\"\n    | \"setRenderLoopMode\"\n    | \"RenderLoopMode\"\n    | \"setOnFrameProcessedCallback\"\n    | \"setClientInterfaceRequestHandler\"\n    | \"provideExternalImage\"\n    | \"provideExternalVideo\"\n    | \"registerSavePersistentStoreCallback\"\n>;\n\n// NOTE: type of the record ensures newly added asset types break compilation\nexport const AssetType: Record<keyof LensCoreModule[\"AssetType\"], LensCoreAssetType> = {\n    DeviceDependent: { value: 3 },\n    RemoteMediaByUrl: { value: 6 },\n    Static: { value: 1 },\n    URL: { value: 2 },\n    BitmojiDynamicAsset: { value: 4 },\n};\n\nexport function createLensCore(): LensCoreMock {\n    return {\n        AssetType,\n        CanvasType: { Preview: { value: 1 }, Capture: { value: 2 }, None: { value: 0 }, All: { value: 3 } },\n        RenderLoopMode: { SetTimeout: { value: 1 }, RequestAnimationFrame: { value: 0 } },\n        // https://github.sc-corp.net/Snapchat/LensCore/blob/502b54b9a663203bcdf3b90c63214cdf8cc1e713/Src/CoreManager/ClientInterfaceDelegate.hpp#L39\n        InterfaceAction: { Show: { value: 3 } } as any,\n        // https://github.sc-corp.net/Snapchat/LensCore/blob/502b54b9a663203bcdf3b90c63214cdf8cc1e713/Src/CoreManager/ClientInterfaceDelegate.hpp#L21\n        InterfaceControl: { ImagePicker: { value: 1 } } as any,\n        // https://github.sc-corp.net/Snapchat/LensCore/blob/2d538ecc41f67dd2c199e0ff0eefd96aac6f22dc/Src/Common/IExternalMediaFilePickedObserver.h#L21\n        ExternalMediaOrientation: { CW0: { value: 0 }, CW90: { value: 1 }, CW180: { value: 2 }, CW270: { value: 3 } },\n        initialize: jest.fn(),\n        setRemoteAssetsProvider: jest.fn(),\n        provideRemoteAssetsResponse: jest.fn(),\n        getOutputCanvases: jest.fn(),\n        setRenderLoopMode: jest.fn(),\n        setOnFrameProcessedCallback: jest.fn(),\n        setClientInterfaceRequestHandler: jest.fn(),\n        provideExternalImage: jest.fn(),\n        provideExternalVideo: jest.fn(),\n        registerSavePersistentStoreCallback: jest.fn(),\n    };\n}\n"]}

package/lib/__tests__/deferred.d.ts

@@ -0,0 +1,16 @@
+export declare type Deferred<T> = Promise<T> & {
+    resolve: (v: T) => Promise<void>;
+    reject: (e: unknown) => Promise<void>;
+};
+/**
+ * Creates a promise that can be resolved/rejected manually later.
+ *```ts
+ * const promise = createDeferred();
+ * // when some piece of code awaits the promise:
+ * await promise
+ * // we can resovle that promise when it is more suitable for us:
+ * await promise.resolve();
+ *```
+ * @returns A promise wtih resolve() and reject() methods.
+ */
+export declare function createDeferred<T>(): Deferred<T>;

package/lib/__tests__/deferred.js

@@ -0,0 +1,29 @@
+/**
+ * Creates a promise that can be resolved/rejected manually later.
+ *```ts
+ * const promise = createDeferred();
+ * // when some piece of code awaits the promise:
+ * await promise
+ * // we can resovle that promise when it is more suitable for us:
+ * await promise.resolve();
+ *```
+ * @returns A promise wtih resolve() and reject() methods.
+ */
+export function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    promise.resolve = (v) => {
+        resolve(v);
+        return promise;
+    };
+    promise.reject = (reason) => {
+        reject(reason);
+        return promise;
+    };
+    return promise;
+}
+//# sourceMappingURL=deferred.js.map

package/lib/__tests__/deferred.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred.js","sourceRoot":"","sources":["../../src/__tests__/deferred.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc;IAC1B,IAAI,OAAuB,CAAC;IAC5B,IAAI,MAA8B,CAAC;IACnC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAI,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QACxC,OAAO,GAAG,GAAG,CAAC;QACd,MAAM,GAAG,GAAG,CAAC;IACjB,CAAC,CAAC,CAAC;IACF,OAAe,CAAC,OAAO,GAAG,CAAC,CAAI,EAAE,EAAE;QAChC,OAAO,CAAC,CAAC,CAAC,CAAC;QACX,OAAO,OAAO,CAAC;IACnB,CAAC,CAAC;IACD,OAAe,CAAC,MAAM,GAAG,CAAC,MAAe,EAAE,EAAE;QAC1C,MAAM,CAAC,MAAM,CAAC,CAAC;QACf,OAAO,OAAO,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,OAAsB,CAAC;AAClC,CAAC","sourcesContent":["export type Deferred<T> = Promise<T> & { resolve: (v: T) => Promise<void>; reject: (e: unknown) => Promise<void> };\n\n/**\n * Creates a promise that can be resolved/rejected manually later.\n *```ts\n * const promise = createDeferred();\n * // when some piece of code awaits the promise:\n * await promise\n * // we can resovle that promise when it is more suitable for us:\n * await promise.resolve();\n *```\n * @returns A promise wtih resolve() and reject() methods.\n */\nexport function createDeferred<T>(): Deferred<T> {\n    let resolve: (v: T) => void;\n    let reject: (reason?: any) => void;\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    (promise as any).resolve = (v: T) => {\n        resolve(v);\n        return promise;\n    };\n    (promise as any).reject = (reason: unknown) => {\n        reject(reason);\n        return promise;\n    };\n    return promise as Deferred<T>;\n}\n"]}

package/lib/__tests__/jest.matchers.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="jest" />
+declare global {
+    namespace jest {
+        interface Expect {
+            errorContaining<T extends (string | ErrorLike)[]>(...errors: T): T;
+        }
+        interface Matchers<R> {
+            toBeCalledBefore(secondMock: jest.Mock): R;
+            toEqualError(...errors: string[] | ErrorLike[]): R;
+        }
+    }
+}
+declare type ErrorLike = {
+    message: string;
+    name: string;
+};
+export {};

package/lib/__tests__/jest.matchers.js

@@ -0,0 +1,67 @@
+function areErrorsEqual(error, errorOrMessageOrName) {
+    if (typeof errorOrMessageOrName === "string") {
+        return error.message === errorOrMessageOrName || error.name === errorOrMessageOrName;
+    }
+    return error.message === errorOrMessageOrName.message && error.name === errorOrMessageOrName.name;
+}
+function expectErrorsToEqual(utils, error, ...errors) {
+    expect(error).toBeInstanceOf(Error);
+    for (const errorOrMessage of errors) {
+        if (!areErrorsEqual(error, errorOrMessage)) {
+            const receivedMessage = utils.printReceived(error.message);
+            const receivedName = utils.printReceived(error.name);
+            const expected = utils.printExpected(errorOrMessage);
+            throw new Error(`Expected ${receivedMessage} error message (or ${receivedName} error name) to equal ${expected}.`);
+        }
+        error = error.cause;
+    }
+}
+const smallest = (numbers) => numbers.reduce((a, b) => (a < b ? a : b));
+const toBeCalledBeforeMessage = (pass, a, b) => () => `Expected first mock to${pass ? " not" : ""} have been called before second. First mock call order:\n` +
+    `\t${a}\nSecond mock call order:\n\t${b}`;
+expect.extend({
+    /**
+     * Usage: expect(mockA).toBeCalledBefore(mockB)
+     */
+    toBeCalledBefore(firstMock, secondMock) {
+        expect(firstMock).toBeCalled();
+        expect(secondMock).toBeCalled();
+        const firstOrder = smallest(firstMock.mock.invocationCallOrder);
+        const secondOrder = smallest(secondMock.mock.invocationCallOrder);
+        const pass = firstOrder < secondOrder;
+        return { pass, message: toBeCalledBeforeMessage(pass, firstOrder, secondOrder) };
+    },
+    /**
+     * Use .toEqualError() to compare error objects.
+     * This is useful for comparing nested error objects.
+     * @param actualError Error object.
+     * @param expectedErrors Error like objects, messages or names. Multiple values represent nested error chain.
+     */
+    toEqualError(actualError, ...expectedErrors) {
+        try {
+            expectErrorsToEqual(this.utils, actualError, ...expectedErrors);
+            return {
+                pass: true,
+                message: () => "",
+            };
+        }
+        catch (e) {
+            return {
+                pass: false,
+                message: () => e.message,
+            };
+        }
+    },
+    /**
+     * Allows to do expecations like expect(fn).toBeCalledWith(expect.errorContaining("BOOM!"))
+     */
+    errorContaining(actualError, ...expectedErrors) {
+        expectErrorsToEqual(this.utils, actualError, ...expectedErrors);
+        return {
+            pass: true,
+            message: () => "",
+        };
+    },
+});
+export {};
+//# sourceMappingURL=jest.matchers.js.map

package/lib/__tests__/jest.matchers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.matchers.js","sourceRoot":"","sources":["../../src/__tests__/jest.matchers.ts"],"names":[],"mappings":"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","sourcesContent":["declare global {\n    namespace jest {\n        interface Expect {\n            errorContaining<T extends (string | ErrorLike)[]>(...errors: T): T;\n        }\n        interface Matchers<R> {\n            toBeCalledBefore(secondMock: jest.Mock): R;\n            toEqualError(...errors: string[] | ErrorLike[]): R;\n        }\n    }\n}\n\ntype ErrorLike = { message: string; name: string };\n\nfunction areErrorsEqual(error: Error, errorOrMessageOrName: string | ErrorLike) {\n    if (typeof errorOrMessageOrName === \"string\") {\n        return error.message === errorOrMessageOrName || error.name === errorOrMessageOrName;\n    }\n    return error.message === errorOrMessageOrName.message && error.name === errorOrMessageOrName.name;\n}\n\nfunction expectErrorsToEqual(utils: jest.MatcherUtils[\"utils\"], error: any, ...errors: (string | ErrorLike)[]) {\n    expect(error).toBeInstanceOf(Error);\n    for (const errorOrMessage of errors) {\n        if (!areErrorsEqual(error, errorOrMessage)) {\n            const receivedMessage = utils.printReceived(error.message);\n            const receivedName = utils.printReceived(error.name);\n            const expected = utils.printExpected(errorOrMessage);\n            throw new Error(\n                `Expected ${receivedMessage} error message (or ${receivedName} error name) to equal ${expected}.`\n            );\n        }\n        error = error.cause;\n    }\n}\n\nconst smallest = (numbers: number[]) => numbers.reduce((a, b) => (a < b ? a : b));\nconst toBeCalledBeforeMessage = (pass: boolean, a: number, b: number) => () =>\n    `Expected first mock to${pass ? \" not\" : \"\"} have been called before second. First mock call order:\\n` +\n    `\\t${a}\\nSecond mock call order:\\n\\t${b}`;\nexpect.extend({\n    /**\n     * Usage: expect(mockA).toBeCalledBefore(mockB)\n     */\n    toBeCalledBefore(firstMock: jest.Mock, secondMock: jest.Mock) {\n        expect(firstMock).toBeCalled();\n        expect(secondMock).toBeCalled();\n        const firstOrder = smallest(firstMock.mock.invocationCallOrder);\n        const secondOrder = smallest(secondMock.mock.invocationCallOrder);\n        const pass = firstOrder < secondOrder;\n        return { pass, message: toBeCalledBeforeMessage(pass, firstOrder, secondOrder) };\n    },\n\n    /**\n     * Use .toEqualError() to compare error objects.\n     * This is useful for comparing nested error objects.\n     * @param actualError Error object.\n     * @param expectedErrors Error like objects, messages or names. Multiple values represent nested error chain.\n     */\n    toEqualError(actualError: any, ...expectedErrors: string[] | ErrorLike[]) {\n        try {\n            expectErrorsToEqual(this.utils, actualError, ...expectedErrors);\n            return {\n                pass: true,\n                message: () => \"\",\n            };\n        } catch (e) {\n            return {\n                pass: false,\n                message: () => (e as any).message,\n            };\n        }\n    },\n\n    /**\n     * Allows to do expecations like expect(fn).toBeCalledWith(expect.errorContaining(\"BOOM!\"))\n     */\n    errorContaining(actualError: Error, ...expectedErrors: (string | ErrorLike)[]) {\n        expectErrorsToEqual(this.utils, actualError, ...expectedErrors);\n        return {\n            pass: true,\n            message: () => \"\",\n        };\n    },\n});\n\n// TS compiler needs to identify this as a module, which requires an import/export statement -- otherwise it will not\n// allow augmenting the global scope with additional type definitions.\nexport {};\n"]}

package/lib/assertPlatformSupported.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Assert current platform is supported.
+ */
+export declare function assertPlatformSupported(): void;

package/lib/assertPlatformSupported.js

@@ -0,0 +1,10 @@
+import { assert } from "./common/assertions";
+import { platformNotSupportedError } from "./namedErrors";
+/**
+ * Assert current platform is supported.
+ */
+export function assertPlatformSupported() {
+    const canvas = document.createElement("canvas");
+    assert(!!canvas.getContext("webgl2") || !!canvas.getContext("webgl"), platformNotSupportedError("Cannot bootstrap the SDK because the browser does not support WebGL canvas rendering context."));
+}
+//# sourceMappingURL=assertPlatformSupported.js.map

package/lib/assertPlatformSupported.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertPlatformSupported.js","sourceRoot":"","sources":["../src/assertPlatformSupported.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D;;GAEG;AACH,MAAM,UAAU,uBAAuB;IACnC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,CACF,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,EAC7D,yBAAyB,CACrB,+FAA+F,CAClG,CACJ,CAAC;AACN,CAAC","sourcesContent":["import { assert } from \"./common/assertions\";\nimport { platformNotSupportedError } from \"./namedErrors\";\n\n/**\n * Assert current platform is supported.\n */\nexport function assertPlatformSupported() {\n    const canvas = document.createElement(\"canvas\");\n    assert(\n        !!canvas.getContext(\"webgl2\") || !!canvas.getContext(\"webgl\"),\n        platformNotSupportedError(\n            \"Cannot bootstrap the SDK because the browser does not support WebGL canvas rendering context.\"\n        )\n    );\n}\n"]}

package/lib/benchmark/benchmarkGflops.d.ts

@@ -0,0 +1,16 @@
+import { BenchmarkResult, LensPerformanceCluster } from "./estimateLensPerformanceCluster";
+/**
+ * These are obtained from historical performance data gathered from end-user devices. Keys are gflops, values are the
+ * corresponding performance rating.
+ *
+ * To compute the performance rating given a gflops value, find the nearest key in this map and look up the rating.
+ */
+export declare const gflopsClusterCenters: Map<number, LensPerformanceCluster>;
+/**
+ * This benchmark is the same that's run on non-web (e.g. native mobile) platforms, and produces results that can be
+ * compared to those gathered on those platforms – this allows us to cluster results and determine a performance rating
+ * based on historical data gathered elsewhere.
+ *
+ * @internal
+ */
+export declare function benchmarkGflops(gl: WebGL2RenderingContext): Promise<BenchmarkResult>;