@snap/camera-kit 0.17.0 → 0.18.1

package/dist/benchmark/estimateLensPerformanceCluster.d.ts

@@ -0,0 +1,34 @@
+/** @category Bootstrapping and Configuration */
+export type LensPerformanceCluster = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** @internal */
+export type BenchmarkResult = {
+    name: string;
+    value: number;
+};
+/**
+ * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are
+ * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on
+ * low-performance devices).
+ *
+ * The cluster value will be an integer from 1-6 which classifies expected lens performance, where 6 is the highest-
+ * performing cluster and 1 the lowest.
+ *
+ * All the raw benchmark results used to estimate the performance cluster are also included for reporting purposes.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export interface EstimatedLensPerformance {
+    cluster: LensPerformanceCluster;
+    benchmarks: BenchmarkResult[];
+    webglRendererInfo: string;
+}
+/**
+ * Run benchmarks which attempt to predict expected lens performance, and assign a cluster (i.e. a performance rating)
+ * which the CameraKit SDK can use to optimize certain lenses.
+ *
+ * @returns A rating from 1-6, indicating expected Lens performance.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare function estimateLensPerformance(): Promise<EstimatedLensPerformance>;
+//# sourceMappingURL=estimateLensPerformanceCluster.d.ts.map

package/dist/benchmark/estimateLensPerformanceCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimateLensPerformanceCluster.d.ts","sourceRoot":"","sources":["../../src/benchmark/estimateLensPerformanceCluster.ts"],"names":[],"mappings":"AAgBA,gDAAgD;AAChD,MAAM,MAAM,sBAAsB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE/D,gBAAgB;AAChB,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,sBAAsB,CAAC;IAChC,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAyBjF"}

package/dist/benchmark/estimateLensPerformanceCluster.js

@@ -0,0 +1,34 @@
+import { __awaiter } from "tslib";
+import { benchmarkError } from "../namedErrors";
+import { gflopsClusterCenters, benchmarkGflops } from "./benchmarkGflops";
+const findNearest = (n, arr) => arr.reduce((a, b) => (Math.abs(a - n) <= Math.abs(b - n) ? a : b));
+const webglContextAttributes = {
+    alpha: false,
+    antialias: false,
+    premultipliedAlpha: false,
+    preserveDrawingBuffer: false,
+    depth: false,
+    stencil: false,
+    failIfMajorPerformanceCaveat: false,
+    powerPreference: "high-performance",
+};
+export function estimateLensPerformance() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const canvas = document.createElement("canvas");
+        const gl = canvas.getContext("webgl2", webglContextAttributes);
+        if (!gl)
+            throw benchmarkError("WebGL2 is required to compute performance, but it is not supported.");
+        const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+        const webglRendererInfo = debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : "unknown";
+        const gflops = yield benchmarkGflops(gl);
+        const nearestGflopsClusterCenter = findNearest(gflops.value, Array.from(gflopsClusterCenters.keys()));
+        const gflopsCluster = (_a = gflopsClusterCenters.get(nearestGflopsClusterCenter)) !== null && _a !== void 0 ? _a : 0;
+        return {
+            cluster: gflopsCluster,
+            benchmarks: [gflops],
+            webglRendererInfo,
+        };
+    });
+}
+//# sourceMappingURL=estimateLensPerformanceCluster.js.map

package/dist/benchmark/estimateLensPerformanceCluster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimateLensPerformanceCluster.js","sourceRoot":"","sources":["../../src/benchmark/estimateLensPerformanceCluster.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,GAAG,CAAC,CAAS,EAAE,GAAa,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAErH,MAAM,sBAAsB,GAA2B;IACnD,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,KAAK;IAChB,kBAAkB,EAAE,KAAK;IACzB,qBAAqB,EAAE,KAAK;IAC5B,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,KAAK;IACd,4BAA4B,EAAE,KAAK;IACnC,eAAe,EAAE,kBAAkB;CACtC,CAAC;AAkCF,MAAM,UAAgB,uBAAuB;;;QAEzC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChD,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC;QAC/D,IAAI,CAAC,EAAE;YAAE,MAAM,cAAc,CAAC,qEAAqE,CAAC,CAAC;QAErG,MAAM,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC;QAC/D,MAAM,iBAAiB,GAAG,SAAS,CAAC,CAAC,CAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,uBAAuB,CAAY,CAAC,CAAC,CAAC,SAAS,CAAC;QAGjH,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,EAAE,CAAC,CAAC;QAIzC,MAAM,0BAA0B,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAItG,MAAM,aAAa,GAAG,MAAA,oBAAoB,CAAC,GAAG,CAAC,0BAA0B,CAAC,mCAAI,CAAC,CAAC;QAEhF,OAAO;YACH,OAAO,EAAE,aAAa;YACtB,UAAU,EAAE,CAAC,MAAM,CAAC;YACpB,iBAAiB;SACpB,CAAC;;CACL","sourcesContent":["import { benchmarkError } from \"../namedErrors\";\nimport { gflopsClusterCenters, benchmarkGflops } from \"./benchmarkGflops\";\n\nconst findNearest = (n: number, arr: number[]) => arr.reduce((a, b) => (Math.abs(a - n) <= Math.abs(b - n) ? a : b));\n\nconst webglContextAttributes: WebGLContextAttributes = {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: false,\n    powerPreference: \"high-performance\",\n};\n\n/** @category Bootstrapping and Configuration */\nexport type LensPerformanceCluster = 0 | 1 | 2 | 3 | 4 | 5 | 6;\n\n/** @internal */\nexport type BenchmarkResult = { name: string; value: number };\n\n/**\n * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are\n * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on\n * low-performance devices).\n *\n * The cluster value will be an integer from 1-6 which classifies expected lens performance, where 6 is the highest-\n * performing cluster and 1 the lowest.\n *\n * All the raw benchmark results used to estimate the performance cluster are also included for reporting purposes.\n *\n * @category Bootstrapping and Configuration\n */\nexport interface EstimatedLensPerformance {\n    cluster: LensPerformanceCluster;\n    benchmarks: BenchmarkResult[];\n    webglRendererInfo: string;\n}\n\n/**\n * Run benchmarks which attempt to predict expected lens performance, and assign a cluster (i.e. a performance rating)\n * which the CameraKit SDK can use to optimize certain lenses.\n *\n * @returns A rating from 1-6, indicating expected Lens performance.\n *\n * @category Bootstrapping and Configuration\n */\nexport async function estimateLensPerformance(): Promise<EstimatedLensPerformance> {\n    // Prepare performance measurement.\n    const canvas = document.createElement(\"canvas\");\n    const gl = canvas.getContext(\"webgl2\", webglContextAttributes);\n    if (!gl) throw benchmarkError(\"WebGL2 is required to compute performance, but it is not supported.\");\n\n    const debugInfo = gl.getExtension(\"WEBGL_debug_renderer_info\");\n    const webglRendererInfo = debugInfo ? (gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) as string) : \"unknown\";\n\n    // Measure performance (just GFLOPS for now, but could add more benchmarks in the future).\n    const gflops = await benchmarkGflops(gl);\n\n    // Combine performance results and compute a performance rating. Right now we just run a single benchmark, so this\n    // is pretty trivial.\n    const nearestGflopsClusterCenter = findNearest(gflops.value, Array.from(gflopsClusterCenters.keys()));\n\n    // This should always find a value, but just in case something strange happens inside `findNearest`, we'll default\n    // to zero (instead of asserting .get() will always be defined).\n    const gflopsCluster = gflopsClusterCenters.get(nearestGflopsClusterCenter) ?? 0;\n\n    return {\n        cluster: gflopsCluster,\n        benchmarks: [gflops],\n        webglRendererInfo,\n    };\n}\n"]}

package/dist/benchmark/webglUtils.d.ts

@@ -0,0 +1,8 @@
+export declare function createProgram(gl: WebGL2RenderingContext, vertexSource: string, fragmentSource: string): WebGLProgram;
+export declare function createShader(gl: WebGL2RenderingContext, source: string, type: number): WebGLShader;
+export declare function createTexture(gl: WebGL2RenderingContext, width: number, height: number): WebGLTexture;
+export declare function createFramebuffer(gl: WebGL2RenderingContext, texture: WebGLTexture): WebGLFramebuffer;
+export declare function setUniform1i(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, data: number): void;
+export declare function setUniform4f(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, data: [number, number, number, number]): void;
+export declare function promiseSync(gl: WebGL2RenderingContext): Promise<void>;
+//# sourceMappingURL=webglUtils.d.ts.map

package/dist/benchmark/webglUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webglUtils.d.ts","sourceRoot":"","sources":["../../src/benchmark/webglUtils.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,CAAC,EAAE,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,YAAY,CAqBpH;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAYlG;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,sBAAsB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAWrG;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,GAAG,gBAAgB,CAOrG;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEhH;AAED,wBAAgB,YAAY,CACxB,EAAE,EAAE,sBAAsB,EAC1B,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACvC,IAAI,CAEN;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBrE"}

package/dist/bootstrapCameraKit.d.ts

@@ -0,0 +1,97 @@
+import { Container } from "./dependency-injection/Container";
+import type { CameraKit } from "./CameraKit";
+import type { CameraKitBootstrapConfiguration } from "./configuration";
+import type { PublicServices } from "./dependency-injection/RootServices";
+import { PartialContainer } from "./dependency-injection/PartialContainer";
+/**
+ * For more advanced use-cases, this DI Container holds services for which a custom implementation may be provided by
+ * the application.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export type PublicContainer = Container<PublicServices>;
+/**
+ * Bootstrap CameraKit. This will download the WebAssembly code which powers CameraKit's rendering engine, and return
+ * an instance of {@link CameraKit}.
+ *
+ * CameraKit must be provided with some configuration (the application's API token), and there are some additional
+ * configurations which are optional.
+ *
+ * Descriptions of the available configurations can be found in the documentation for
+ * {@link CameraKitBootstrapConfiguration}
+ *
+ * ---
+ *
+ * There is also a second, more advanced way to modify CameraKit to provide greater flexibility to support less common
+ * use cases.
+ *
+ * This requires some knowledge of CameraKit's dependency injection system, and allows applications to provide their
+ * own custom implementations of certain CameraKit components. This functionality will only be needed by applications
+ * with very specific, more advanced requirements.
+ *
+ * @example
+ * ```ts
+ * // The most common way to bootstrap:
+ * const cameraKit = await bootstrapCameraKit({ apiToken: myApiToken })
+ *
+ * // For special advanced use-cases, it is possible to provide custom implementations for certain CameraKit components.
+ * const cameraKit = await bootstrapCameraKit(config, (container) => {
+ *   return container.provides(myCustomRemoteMediaAssetLoaderFactory)
+ * })
+ * ```
+ *
+ * @param configuration Configure CameraKit with e.g. credentials, global resource endpoints, etc.
+ * @param provide Optional function that can make modifications to CameraKit's root DI container.
+ * @returns A {@link CameraKit} instance, which is the entry point to CameraKit's API.
+ *
+ * @throws
+ *  - {@link ConfigurationError} when provided configuration object is invalid
+ *  - {@link PlatformNotSupportedError} when current platform is not supported by CameraKit
+ *  - {@link BootstrapError} when a failure occurs while initializing CameraKit and downloading the render engine
+ * WebAssembly binary.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare function bootstrapCameraKit(configuration: CameraKitBootstrapConfiguration, provide?: (c: PublicContainer) => PublicContainer): Promise<CameraKit>;
+/**
+ * Extensions offer a way to provide custom implementations of certain parts of the CameraKit SDK.
+ *
+ * This enables more advanced use-cases, in which the default behavior of the SDK is substantially altered. For example,
+ * replacing the default implementation that loads remote lens assets with a custom implementation that returns
+ * different assets based on some business logic within the application.
+ *
+ * An extension is implemented as a {@link PartialContainer} – a collection of factory functions, each with its own
+ * dependencies, which each provide some "Service". A Service can be of any type, and the CameraKit SDK defines its
+ * own Services, some of which can be overridden by providing a custom implementation of the type via an extension.
+ *
+ * Here's an example of how extensions might be used:
+ * ```ts
+ * import { bootstrapCameraKit, createExtension, remoteMediaAssetLoaderFactory } from '@snap/camera-kit'
+ *
+ * const myCustomRemoteAssetLoader = Injectable(
+ *   remoteMediaAssetLoaderFactory.token,
+ *   [remoteMediaAssetLoaderFactory.token] as const,
+ *   (defaultLoader: AssetLoader): AssetLoader => {
+ *     return async (asset, lens) => {
+ *       if (lens?.id === MY_SPECIAL_LENS) {
+ *         return (await fetch('my/asset.glb')).arrayBuffer()
+ *       }
+ *       return defaultLoader(asset, lens)
+ *     }
+ *   },
+ * )
+ *
+ * const myExtension = createExtension().provides(myCustomRemoteAssetLoader);
+ * const cameraKit = bootstrapCameraKit(config, container => container.provides(myExtension));
+ * ```
+ *
+ * This also enables greater modularity – the person/team creating the extension can do so in their own package, which
+ * could be shared by many applications that all require the same functionality.
+ *
+ * @returns A {@link PartialContainer} which can be used to create a collection of Services, and can later be provided
+ * to CameraKit's DI container during {@link bootstrapCameraKit}.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export declare function createExtension(): PartialContainer;
+//# sourceMappingURL=bootstrapCameraKit.d.ts.map

package/dist/bootstrapCameraKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrapCameraKit.d.ts","sourceRoot":"","sources":["../src/bootstrapCameraKit.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAS7C,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,iBAAiB,CAAC;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAiD3E;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,cAAc,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAsB,kBAAkB,CACpC,aAAa,EAAE,+BAA+B,EAC9C,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,eAAe,GAClD,OAAO,CAAC,SAAS,CAAC,CA0FpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,eAAe,IAAI,gBAAgB,CAElD"}

package/dist/bootstrapCameraKit.js

@@ -0,0 +1,117 @@
+import { __awaiter } from "tslib";
+import environment from "./environment";
+import lensCoreWasm from "./lensCoreWasmVersions";
+import { lensRepositoryFactory } from "./lens/LensRepository";
+import { Container } from "./dependency-injection/Container";
+import { cameraKitFactory } from "./CameraKit";
+import { lensCoreFactory } from "./lens-core-module/loader/lensCoreFactory";
+import { Injectable } from "./dependency-injection/Injectable";
+import { remoteMediaAssetLoaderFactory } from "./lens/assets/remoteMediaAssetLoaderFactory";
+import { deviceDependentAssetLoaderFactory } from "./lens/assets/deviceDependentAssetLoader";
+import { staticAssetLoaderFactory } from "./lens/assets/staticAssetLoader";
+import { defaultFetchHandlerFactory } from "./handlers/defaultFetchHandler";
+import { cameraKitServiceFetchHandlerFactory } from "./handlers/cameraKitServiceFetchHandlerFactory";
+import { createCameraKitConfigurationFactory } from "./configuration";
+import { PartialContainer } from "./dependency-injection/PartialContainer";
+import { uriHandlersFactory } from "./extensions/UriHandlers";
+import { assert } from "./common/assertions";
+import { isSafeString } from "./common/typeguards";
+import { metricsEventTargetFactory } from "./metrics/metricsEventTarget";
+import { reportGloballyScopedMetrics } from "./metrics/reporters/reporters";
+import { getLogger } from "./logger/logger";
+import { logEntriesFactory } from "./logger/logEntries";
+import { assertPlatformSupported } from "./platform/assertPlatformSupported";
+import { lensPersistenceStoreFactory } from "./lens/LensPersistenceStore";
+import { remoteConfigurationFactory } from "./remote-configuration/remoteConfiguration";
+import { lensAssetRepositoryFactory } from "./lens/assets/LensAssetRepository";
+import { legalStateFactory } from "./legal/legalState";
+import { legalPromptFactory } from "./legal/legalPrompt";
+import { bootstrapError, configurationError } from "./namedErrors";
+import { businessEventsReporterFactory } from "./metrics/businessEventsReporter";
+import { reportGlobalException } from "./metrics/reporters/reportGlobalException";
+import { registerLogEntriesSubscriber } from "./logger/registerLogEntriesSubscriber";
+import { requestStateEventTargetFactory } from "./handlers/requestStateEmittingHandler";
+import { pageVisibilityFactory } from "./common/pageVisibility";
+import { cofHandlerFactory } from "./remote-configuration/cofHandler";
+import { remoteApiServicesFactory } from "./extensions/RemoteApiServices";
+import { lensesClientFactory } from "./clients/lensesClient";
+import { grpcHandlerFactory } from "./clients/grpcHandler";
+import { lensSourcesFactory } from "./lens/LensSource";
+import { cameraKitLensSourceFactory } from "./lens/cameraKitLensSource";
+import { externalMetricsSubjectFactory, metricsClientFactory } from "./clients/metricsClient";
+import { Timer } from "./metrics/operational/Timer";
+import { fetchWatermarkLens } from "./lens/fetchWatermarkLens";
+const logger = getLogger("bootstrapCameraKit");
+const nonWrappableErrors = [
+    "ConfigurationError",
+    "PlatformNotSupportedError",
+];
+function shouldWrapError(error) {
+    if (error instanceof Error) {
+        return !nonWrappableErrors.some((name) => error.name === name);
+    }
+    return true;
+}
+export function bootstrapCameraKit(configuration, provide) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.info(`Camera Kit SDK: ${environment.PACKAGE_VERSION} (${lensCoreWasm.version}/${lensCoreWasm.buildNumber})`);
+        try {
+            const bootstrapLatency = new Timer("bootstrap_time");
+            assert(isSafeString(configuration.apiToken), configurationError("Invalid or unsafe apiToken provided."));
+            const configurationFactory = createCameraKitConfigurationFactory(configuration);
+            const defaultPublicContainer = Container.provides(configurationFactory)
+                .provides(defaultFetchHandlerFactory)
+                .provides(remoteMediaAssetLoaderFactory)
+                .provides(lensSourcesFactory)
+                .provides(remoteApiServicesFactory)
+                .provides(uriHandlersFactory)
+                .provides(externalMetricsSubjectFactory);
+            const publicContainer = provide ? provide(defaultPublicContainer) : defaultPublicContainer;
+            const telemetryContainer = Container.provides(publicContainer)
+                .provides(pageVisibilityFactory)
+                .provides(cameraKitServiceFetchHandlerFactory)
+                .provides(grpcHandlerFactory)
+                .provides(metricsClientFactory)
+                .provides(logEntriesFactory)
+                .run(registerLogEntriesSubscriber)
+                .provides(requestStateEventTargetFactory)
+                .provides(metricsEventTargetFactory)
+                .provides(reportGlobalException)
+                .provides(cofHandlerFactory)
+                .provides(remoteConfigurationFactory)
+                .provides(legalPromptFactory)
+                .provides(legalStateFactory)
+                .run(reportGloballyScopedMetrics)
+                .run(businessEventsReporterFactory);
+            telemetryContainer.get(reportGlobalException.token);
+            yield assertPlatformSupported();
+            const lensCore = yield telemetryContainer.provides(lensCoreFactory).get(lensCoreFactory.token);
+            const container = telemetryContainer
+                .provides(Injectable(lensCoreFactory.token, () => lensCore))
+                .provides(lensesClientFactory)
+                .provides(cameraKitLensSourceFactory)
+                .provides(lensPersistenceStoreFactory)
+                .provides(deviceDependentAssetLoaderFactory)
+                .provides(staticAssetLoaderFactory)
+                .provides(lensAssetRepositoryFactory)
+                .provides(lensRepositoryFactory)
+                .provides(cameraKitFactory)
+                .run(fetchWatermarkLens);
+            const cameraKit = container.get(cameraKitFactory.token);
+            bootstrapLatency.measure();
+            container.get(metricsClientFactory.token).setOperationalMetrics(bootstrapLatency);
+            return cameraKit;
+        }
+        catch (error) {
+            if (shouldWrapError(error)) {
+                error = bootstrapError("Error occurred during Camera Kit bootstrapping.", error);
+            }
+            logger.error(error);
+            throw error;
+        }
+    });
+}
+export function createExtension() {
+    return new PartialContainer({});
+}
+//# sourceMappingURL=bootstrapCameraKit.js.map

package/dist/bootstrapCameraKit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrapCameraKit.js","sourceRoot":"","sources":["../src/bootstrapCameraKit.ts"],"names":[],"mappings":"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","sourcesContent":["import environment from \"./environment\";\nimport lensCoreWasm from \"./lensCoreWasmVersions\";\nimport { lensRepositoryFactory } from \"./lens/LensRepository\";\nimport { Container } from \"./dependency-injection/Container\";\nimport type { CameraKit } from \"./CameraKit\";\nimport { cameraKitFactory } from \"./CameraKit\";\nimport { lensCoreFactory } from \"./lens-core-module/loader/lensCoreFactory\";\nimport { Injectable } from \"./dependency-injection/Injectable\";\nimport { remoteMediaAssetLoaderFactory } from \"./lens/assets/remoteMediaAssetLoaderFactory\";\nimport { deviceDependentAssetLoaderFactory } from \"./lens/assets/deviceDependentAssetLoader\";\nimport { staticAssetLoaderFactory } from \"./lens/assets/staticAssetLoader\";\nimport { defaultFetchHandlerFactory } from \"./handlers/defaultFetchHandler\";\nimport { cameraKitServiceFetchHandlerFactory } from \"./handlers/cameraKitServiceFetchHandlerFactory\";\nimport type { CameraKitBootstrapConfiguration } from \"./configuration\";\nimport { createCameraKitConfigurationFactory } from \"./configuration\";\nimport type { PublicServices } from \"./dependency-injection/RootServices\";\nimport { PartialContainer } from \"./dependency-injection/PartialContainer\";\nimport { uriHandlersFactory } from \"./extensions/UriHandlers\";\nimport { assert } from \"./common/assertions\";\nimport { isSafeString } from \"./common/typeguards\";\nimport { metricsEventTargetFactory } from \"./metrics/metricsEventTarget\";\nimport { reportGloballyScopedMetrics } from \"./metrics/reporters/reporters\";\nimport { getLogger } from \"./logger/logger\";\nimport { logEntriesFactory } from \"./logger/logEntries\";\nimport { assertPlatformSupported } from \"./platform/assertPlatformSupported\";\nimport { lensPersistenceStoreFactory } from \"./lens/LensPersistenceStore\";\nimport { remoteConfigurationFactory } from \"./remote-configuration/remoteConfiguration\";\nimport { lensAssetRepositoryFactory } from \"./lens/assets/LensAssetRepository\";\nimport { legalStateFactory } from \"./legal/legalState\";\nimport { legalPromptFactory } from \"./legal/legalPrompt\";\nimport type { ConfigurationError, PlatformNotSupportedError } from \"./namedErrors\";\nimport { bootstrapError, configurationError } from \"./namedErrors\";\nimport { businessEventsReporterFactory } from \"./metrics/businessEventsReporter\";\nimport { reportGlobalException } from \"./metrics/reporters/reportGlobalException\";\nimport { registerLogEntriesSubscriber } from \"./logger/registerLogEntriesSubscriber\";\nimport { requestStateEventTargetFactory } from \"./handlers/requestStateEmittingHandler\";\nimport { pageVisibilityFactory } from \"./common/pageVisibility\";\nimport { cofHandlerFactory } from \"./remote-configuration/cofHandler\";\nimport { remoteApiServicesFactory } from \"./extensions/RemoteApiServices\";\nimport { lensesClientFactory } from \"./clients/lensesClient\";\nimport { grpcHandlerFactory } from \"./clients/grpcHandler\";\nimport { lensSourcesFactory } from \"./lens/LensSource\";\nimport { cameraKitLensSourceFactory } from \"./lens/cameraKitLensSource\";\nimport { externalMetricsSubjectFactory, metricsClientFactory } from \"./clients/metricsClient\";\nimport { Timer } from \"./metrics/operational/Timer\";\nimport { fetchWatermarkLens } from \"./lens/fetchWatermarkLens\";\n\nconst logger = getLogger(\"bootstrapCameraKit\");\n\n// The following errors are not wrapped with BootstrapError and bubble up as is.\nconst nonWrappableErrors: [ConfigurationError[\"name\"], PlatformNotSupportedError[\"name\"]] = [\n    \"ConfigurationError\",\n    \"PlatformNotSupportedError\",\n];\n\n/**\n * Returns true if given error has to be wrapped with BootstrapError.\n */\nfunction shouldWrapError(error: unknown): boolean {\n    if (error instanceof Error) {\n        return !nonWrappableErrors.some((name) => error.name === name);\n    }\n    return true;\n}\n\n/**\n * For more advanced use-cases, this DI Container holds services for which a custom implementation may be provided by\n * the application.\n *\n * @category Bootstrapping and Configuration\n */\nexport type PublicContainer = Container<PublicServices>;\n\n/**\n * Bootstrap CameraKit. This will download the WebAssembly code which powers CameraKit's rendering engine, and return\n * an instance of {@link CameraKit}.\n *\n * CameraKit must be provided with some configuration (the application's API token), and there are some additional\n * configurations which are optional.\n *\n * Descriptions of the available configurations can be found in the documentation for\n * {@link CameraKitBootstrapConfiguration}\n *\n * ---\n *\n * There is also a second, more advanced way to modify CameraKit to provide greater flexibility to support less common\n * use cases.\n *\n * This requires some knowledge of CameraKit's dependency injection system, and allows applications to provide their\n * own custom implementations of certain CameraKit components. This functionality will only be needed by applications\n * with very specific, more advanced requirements.\n *\n * @example\n * ```ts\n * // The most common way to bootstrap:\n * const cameraKit = await bootstrapCameraKit({ apiToken: myApiToken })\n *\n * // For special advanced use-cases, it is possible to provide custom implementations for certain CameraKit components.\n * const cameraKit = await bootstrapCameraKit(config, (container) => {\n *   return container.provides(myCustomRemoteMediaAssetLoaderFactory)\n * })\n * ```\n *\n * @param configuration Configure CameraKit with e.g. credentials, global resource endpoints, etc.\n * @param provide Optional function that can make modifications to CameraKit's root DI container.\n * @returns A {@link CameraKit} instance, which is the entry point to CameraKit's API.\n *\n * @throws\n *  - {@link ConfigurationError} when provided configuration object is invalid\n *  - {@link PlatformNotSupportedError} when current platform is not supported by CameraKit\n *  - {@link BootstrapError} when a failure occurs while initializing CameraKit and downloading the render engine\n * WebAssembly binary.\n *\n * @category Bootstrapping and Configuration\n */\nexport async function bootstrapCameraKit(\n    configuration: CameraKitBootstrapConfiguration,\n    provide?: (c: PublicContainer) => PublicContainer\n): Promise<CameraKit> {\n    console.info(\n        `Camera Kit SDK: ${environment.PACKAGE_VERSION} (${lensCoreWasm.version}/${lensCoreWasm.buildNumber})`\n    );\n\n    try {\n        const bootstrapLatency = new Timer(\"bootstrap_time\");\n\n        assert(isSafeString(configuration.apiToken), configurationError(\"Invalid or unsafe apiToken provided.\"));\n\n        const configurationFactory = createCameraKitConfigurationFactory(configuration);\n\n        // Public container holds services which applications can overwrite with their own implementations.\n        const defaultPublicContainer = Container.provides(configurationFactory)\n            .provides(defaultFetchHandlerFactory)\n            .provides(remoteMediaAssetLoaderFactory)\n            .provides(lensSourcesFactory)\n            .provides(remoteApiServicesFactory)\n            .provides(uriHandlersFactory)\n            .provides(externalMetricsSubjectFactory);\n\n        const publicContainer = provide ? provide(defaultPublicContainer) : defaultPublicContainer;\n\n        // Now that the client's provide() function has completed and the configuration override is ready,\n        // we create another container to initialize the logger. This ensures that logging is available\n        // as we continue bootstrapping. We don't initialize the logger as part of the defaultPublicContainer\n        // because we don't want applications to provide their own logger implementations,\n        // and we're not interested in errors thrown by their provide() function.\n        // Below is the minimum required container to report errors to Blizzard.\n        const telemetryContainer = Container.provides(publicContainer)\n            .provides(pageVisibilityFactory)\n            .provides(cameraKitServiceFetchHandlerFactory)\n            .provides(grpcHandlerFactory)\n            .provides(metricsClientFactory)\n            .provides(logEntriesFactory)\n            .run(registerLogEntriesSubscriber)\n            .provides(requestStateEventTargetFactory)\n            .provides(metricsEventTargetFactory)\n            .provides(reportGlobalException)\n            .provides(cofHandlerFactory)\n            .provides(remoteConfigurationFactory)\n            .provides(legalPromptFactory)\n            .provides(legalStateFactory)\n            // We'll run a PartialContainer containing reporters for globally-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). This PartialContainer also includes the service which listens to locally-reported metrics\n            // and sends them to our backend.\n            .run(reportGloballyScopedMetrics)\n            .run(businessEventsReporterFactory);\n\n        // Run the exception logger so that it can subscribe to log events -- we can't use `Container.run()` because\n        // reportGlobalException is also used as a dependency by other Services (and run does not provide Services,\n        // it just runs them once).\n        telemetryContainer.get(reportGlobalException.token);\n\n        // At this point, logger is configured to report to console and Blizzard.\n\n        await assertPlatformSupported();\n\n        // LensCore is a foundational component which must be created asynchronously.\n        // But it's annoying for every consumer of LensCore to have to wait on Promise<LensCore>\n        // (which means they become async themselves). So we'll create a DI container which provides Promise<LensCore>,\n        // wait for that promise once here, then create a new DI container that just contains LensCore.\n        const lensCore = await telemetryContainer.provides(lensCoreFactory).get(lensCoreFactory.token);\n\n        const container = telemetryContainer\n            .provides(Injectable(lensCoreFactory.token, () => lensCore))\n            .provides(lensesClientFactory)\n            .provides(cameraKitLensSourceFactory)\n            .provides(lensPersistenceStoreFactory)\n            .provides(deviceDependentAssetLoaderFactory)\n            .provides(staticAssetLoaderFactory)\n            .provides(lensAssetRepositoryFactory)\n            .provides(lensRepositoryFactory)\n            .provides(cameraKitFactory)\n            .run(fetchWatermarkLens);\n\n        const cameraKit = container.get(cameraKitFactory.token);\n\n        bootstrapLatency.measure();\n        container.get(metricsClientFactory.token).setOperationalMetrics(bootstrapLatency);\n\n        return cameraKit;\n    } catch (error) {\n        if (shouldWrapError(error)) {\n            error = bootstrapError(\"Error occurred during Camera Kit bootstrapping.\", error);\n        }\n        logger.error(error);\n        throw error;\n    }\n}\n\n/**\n * Extensions offer a way to provide custom implementations of certain parts of the CameraKit SDK.\n *\n * This enables more advanced use-cases, in which the default behavior of the SDK is substantially altered. For example,\n * replacing the default implementation that loads remote lens assets with a custom implementation that returns\n * different assets based on some business logic within the application.\n *\n * An extension is implemented as a {@link PartialContainer} – a collection of factory functions, each with its own\n * dependencies, which each provide some \"Service\". A Service can be of any type, and the CameraKit SDK defines its\n * own Services, some of which can be overridden by providing a custom implementation of the type via an extension.\n *\n * Here's an example of how extensions might be used:\n * ```ts\n * import { bootstrapCameraKit, createExtension, remoteMediaAssetLoaderFactory } from '@snap/camera-kit'\n *\n * const myCustomRemoteAssetLoader = Injectable(\n *   remoteMediaAssetLoaderFactory.token,\n *   [remoteMediaAssetLoaderFactory.token] as const,\n *   (defaultLoader: AssetLoader): AssetLoader => {\n *     return async (asset, lens) => {\n *       if (lens?.id === MY_SPECIAL_LENS) {\n *         return (await fetch('my/asset.glb')).arrayBuffer()\n *       }\n *       return defaultLoader(asset, lens)\n *     }\n *   },\n * )\n *\n * const myExtension = createExtension().provides(myCustomRemoteAssetLoader);\n * const cameraKit = bootstrapCameraKit(config, container => container.provides(myExtension));\n * ```\n *\n * This also enables greater modularity – the person/team creating the extension can do so in their own package, which\n * could be shared by many applications that all require the same functionality.\n *\n * @returns A {@link PartialContainer} which can be used to create a collection of Services, and can later be provided\n * to CameraKit's DI container during {@link bootstrapCameraKit}.\n *\n * @category Bootstrapping and Configuration\n */\nexport function createExtension(): PartialContainer {\n    return new PartialContainer({});\n}\n"]}

package/dist/clients/createTsProtoClient.d.ts

@@ -0,0 +1,41 @@
+import type { grpc } from "@improbable-eng/grpc-web";
+import type { Writer } from "protobufjs";
+import type { Result } from "../common/result";
+import type { Exact, DeepPartial } from "../generated-proto/pb_schema/camera_kit/v3/service";
+import type { GrpcHandler } from "./grpcHandler";
+type TsProtoServiceDefinition<Methods extends TsProtoMethods> = {
+    name: string;
+    fullName: string;
+    methods: Methods;
+};
+type TsProtoMethods = {
+    [methodName: string]: TsProtoMethodDefinition<any, any>;
+};
+type TsProtoMethodDefinition<Request, Response> = {
+    name: string;
+    requestType: TsProtoMessage<Request>;
+    responseType: TsProtoMessage<Response>;
+};
+type TsProtoMessage<M> = {
+    encode: (message: M) => Writer;
+    decode: (message: Uint8Array) => M;
+    fromPartial: (partialMessage: any) => M;
+};
+export type TsProtoServiceClient<S extends TsProtoServiceDefinition<any>> = {
+    [MethodName in keyof S["methods"]]: InferTsProtoMethod<S["methods"][MethodName]>;
+};
+type InferTsProtoMethod<M extends TsProtoMethodDefinition<any, any>> = M extends TsProtoMethodDefinition<infer Request, infer Response> ? <I extends Exact<DeepPartial<Request>, I>>(request: I) => Promise<Result<grpc.UnaryOutput<Response & grpc.ProtobufMessage>, grpc.UnaryOutput<Response & grpc.ProtobufMessage>>> : never;
+/**
+ * Convert a service definition generated by ts-proto (using the `outputServices=generic-definitions` CLI option) into
+ * a working client.
+ *
+ * @param serviceDefinition
+ * @param handler
+ * @returns A client that can make requests to a remote service by sending Protobuf-encoded messages over HTTP using the
+ * grpc-web package.
+ *
+ * @internal
+ */
+export declare function createTsProtoClient<S extends TsProtoServiceDefinition<TsProtoMethods>>(serviceDefinition: S, handler: GrpcHandler): TsProtoServiceClient<S>;
+export {};
+//# sourceMappingURL=createTsProtoClient.d.ts.map

package/dist/clients/createTsProtoClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTsProtoClient.d.ts","sourceRoot":"","sources":["../../src/clients/createTsProtoClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AAC7F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,KAAK,wBAAwB,CAAC,OAAO,SAAS,cAAc,IAAI;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,cAAc,GAAG;IAAE,CAAC,UAAU,EAAE,MAAM,GAAG,uBAAuB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC;AAElF,KAAK,uBAAuB,CAAC,OAAO,EAAE,QAAQ,IAAI;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;CAC1C,CAAC;AAEF,KAAK,cAAc,CAAC,CAAC,IAAI;IACrB,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC;IAC/B,MAAM,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,CAAC,CAAC;IACnC,WAAW,EAAE,CAAC,cAAc,EAAE,GAAG,KAAK,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,wBAAwB,CAAC,GAAG,CAAC,IAAI;KACvE,UAAU,IAAI,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,CAAC;CACnF,CAAC;AAEF,KAAK,kBAAkB,CAAC,CAAC,SAAS,uBAAuB,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,SAAS,uBAAuB,CACpG,MAAM,OAAO,EACb,MAAM,QAAQ,CACjB,GACK,CAAC,CAAC,SAAS,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,EACrC,OAAO,EAAE,CAAC,KACT,OAAO,CACR,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAC/G,GACD,KAAK,CAAC;AAsBZ;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,wBAAwB,CAAC,cAAc,CAAC,EAClF,iBAAiB,EAAE,CAAC,EACpB,OAAO,EAAE,WAAW,GACrB,oBAAoB,CAAC,CAAC,CAAC,CAuBzB"}

package/dist/clients/createTsProtoClient.js

@@ -0,0 +1,36 @@
+import { __awaiter } from "tslib";
+import { entries, fromEntries } from "../common/entries";
+function messageClass(message, data) {
+    return class Message {
+        constructor() {
+            Object.assign(this, message.fromPartial(data));
+        }
+        static deserializeBinary(data) {
+            return new (messageClass(message, message.decode(data)))();
+        }
+        serializeBinary() {
+            return message.encode(this).finish();
+        }
+        toObject() {
+            return this;
+        }
+    };
+}
+export function createTsProtoClient(serviceDefinition, handler) {
+    return fromEntries(entries(serviceDefinition.methods).map(([methodName, methodDefinition]) => {
+        return [
+            methodName,
+            (request) => __awaiter(this, void 0, void 0, function* () {
+                const requestType = messageClass(methodDefinition.requestType, request);
+                const responseType = messageClass(methodDefinition.responseType, {});
+                return handler({
+                    serviceName: serviceDefinition.fullName,
+                    methodName: methodDefinition.name,
+                    requestType,
+                    responseType,
+                });
+            }),
+        ];
+    }));
+}
+//# sourceMappingURL=createTsProtoClient.js.map

package/dist/clients/createTsProtoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTsProtoClient.js","sourceRoot":"","sources":["../../src/clients/createTsProtoClient.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAwCzD,SAAS,YAAY,CAAI,OAA0B,EAAE,IAAO;IACxD,OAAO,MAAM,OAAO;QAChB;YACI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,CAAC,iBAAiB,CAAC,IAAgB;YACrC,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAa,CAAC;QAC1E,CAAC;QAED,eAAe;YACX,OAAO,OAAO,CAAC,MAAM,CAAC,IAAW,CAAC,CAAC,MAAM,EAAE,CAAC;QAChD,CAAC;QAED,QAAQ;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;KACJ,CAAC;AACN,CAAC;AAaD,MAAM,UAAU,mBAAmB,CAC/B,iBAAoB,EACpB,OAAoB;IAEpB,OAAO,WAAW,CACd,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,gBAAgB,CAAC,EAAE,EAAE;QACtE,OAAO;YACH,UAAU;YACV,CAAO,OAAgB,EAAE,EAAE;gBACvB,MAAM,WAAW,GAAG,YAAY,CAAC,gBAAgB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBACxE,MAAM,YAAY,GAAG,YAAY,CAAC,gBAAgB,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;gBACrE,OAAO,OAAO,CAAC;oBACX,WAAW,EAAE,iBAAiB,CAAC,QAAQ;oBACvC,UAAU,EAAE,gBAAgB,CAAC,IAAI;oBACjC,WAAW;oBACX,YAAY;iBACf,CAAC,CAAC;YACP,CAAC,CAAA;SACJ,CAAC;IAMN,CAAC,CAAC,CACsB,CAAC;AACjC,CAAC","sourcesContent":["import type { grpc } from \"@improbable-eng/grpc-web\";\nimport type { Writer } from \"protobufjs\";\nimport { entries, fromEntries } from \"../common/entries\";\nimport type { Result } from \"../common/result\";\nimport type { Exact, DeepPartial } from \"../generated-proto/pb_schema/camera_kit/v3/service\";\nimport type { GrpcHandler } from \"./grpcHandler\";\n\ntype TsProtoServiceDefinition<Methods extends TsProtoMethods> = {\n    name: string;\n    fullName: string;\n    methods: Methods;\n};\n\ntype TsProtoMethods = { [methodName: string]: TsProtoMethodDefinition<any, any> };\n\ntype TsProtoMethodDefinition<Request, Response> = {\n    name: string;\n    requestType: TsProtoMessage<Request>;\n    responseType: TsProtoMessage<Response>;\n};\n\ntype TsProtoMessage<M> = {\n    encode: (message: M) => Writer;\n    decode: (message: Uint8Array) => M;\n    fromPartial: (partialMessage: any) => M;\n};\n\nexport type TsProtoServiceClient<S extends TsProtoServiceDefinition<any>> = {\n    [MethodName in keyof S[\"methods\"]]: InferTsProtoMethod<S[\"methods\"][MethodName]>;\n};\n\ntype InferTsProtoMethod<M extends TsProtoMethodDefinition<any, any>> = M extends TsProtoMethodDefinition<\n    infer Request,\n    infer Response\n>\n    ? <I extends Exact<DeepPartial<Request>, I>>(\n          request: I\n      ) => Promise<\n          Result<grpc.UnaryOutput<Response & grpc.ProtobufMessage>, grpc.UnaryOutput<Response & grpc.ProtobufMessage>>\n      >\n    : never;\n\nfunction messageClass<M>(message: TsProtoMessage<M>, data: M): grpc.ProtobufMessageClass<grpc.ProtobufMessage> {\n    return class Message implements grpc.ProtobufMessage {\n        constructor() {\n            Object.assign(this, message.fromPartial(data));\n        }\n\n        static deserializeBinary(data: Uint8Array): Message {\n            return new (messageClass(message, message.decode(data)))() as Message;\n        }\n\n        serializeBinary(): Uint8Array {\n            return message.encode(this as any).finish();\n        }\n\n        toObject(): this {\n            return this;\n        }\n    };\n}\n\n/**\n * Convert a service definition generated by ts-proto (using the `outputServices=generic-definitions` CLI option) into\n * a working client.\n *\n * @param serviceDefinition\n * @param handler\n * @returns A client that can make requests to a remote service by sending Protobuf-encoded messages over HTTP using the\n * grpc-web package.\n *\n * @internal\n */\nexport function createTsProtoClient<S extends TsProtoServiceDefinition<TsProtoMethods>>(\n    serviceDefinition: S,\n    handler: GrpcHandler\n): TsProtoServiceClient<S> {\n    return fromEntries(\n        entries(serviceDefinition.methods).map(([methodName, methodDefinition]) => {\n            return [\n                methodName,\n                async (request: unknown) => {\n                    const requestType = messageClass(methodDefinition.requestType, request);\n                    const responseType = messageClass(methodDefinition.responseType, {});\n                    return handler({\n                        serviceName: serviceDefinition.fullName,\n                        methodName: methodDefinition.name,\n                        requestType,\n                        responseType,\n                    });\n                },\n            ];\n            // Safety: We're mapping from the method definitions object into the GrpcServiceClient object in a manner\n            // that preserves each key in the method definitions object, pairing it with the corresponding\n            // serialization/deserialization logic for that particular method. But in doing this, we lose type\n            // specificity by converting the method definition object to a list of entries, mapping them, and then\n            // converting back into the client object -- so we're forced into this type cast.\n        })\n    ) as TsProtoServiceClient<S>;\n}\n"]}

package/dist/clients/grpcHandler.d.ts

@@ -0,0 +1,27 @@
+import { grpc } from "@improbable-eng/grpc-web";
+import type { Handler, RequestMetadata } from "../handlers/HandlerChainBuilder";
+import type { CameraKitConfiguration } from "../configuration";
+import type { Result } from "../common/result";
+import type { FetchHandler } from "../handlers/defaultFetchHandler";
+export interface GrpcRequest {
+    serviceName: string;
+    methodName: string;
+    requestType: grpc.ProtobufMessageClass<grpc.ProtobufMessage>;
+    responseType: grpc.ProtobufMessageClass<grpc.ProtobufMessage>;
+}
+export type GrpcHandler = Handler<GrpcRequest, GrpcResult, RequestMetadata>;
+export type GrpcResult = Result<grpc.UnaryOutput<grpc.ProtobufMessage> & {
+    status: grpc.Code.OK;
+}, grpc.UnaryOutput<grpc.ProtobufMessage>>;
+/**
+ * An Injectable handler that can make requests to the CameraKit backend service via grpc-web. This handler can be
+ * passed to {@link createTsProtoClient} to produce a well-typed service client.
+ *
+ * @internal
+ */
+export declare const grpcHandlerFactory: {
+    (args_0: CameraKitConfiguration, args_1: FetchHandler): GrpcHandler;
+    token: "grpcHandlerFactory";
+    dependencies: readonly ["configuration", "cameraKitServiceFetchHandler"];
+};
+//# sourceMappingURL=grpcHandler.d.ts.map

package/dist/clients/grpcHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpcHandler.d.ts","sourceRoot":"","sources":["../../src/clients/grpcHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,MAAM,WAAW,WAAW;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC7D,YAAY,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;CACjE;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;AAE5E,MAAM,MAAM,UAAU,GAAG,MAAM,CAC3B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAA;CAAE,EACjE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,CACzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;CA+E9B,CAAC"}

package/dist/clients/grpcHandler.js

@@ -0,0 +1,79 @@
+import { __awaiter } from "tslib";
+import { grpc } from "@improbable-eng/grpc-web";
+import { Injectable } from "../dependency-injection/Injectable";
+import { configurationToken } from "../configuration";
+import { Err, Ok } from "../common/result";
+import { cameraKitServiceFetchHandlerFactory } from "../handlers/cameraKitServiceFetchHandlerFactory";
+export const grpcHandlerFactory = Injectable("grpcHandlerFactory", [configurationToken, cameraKitServiceFetchHandlerFactory.token], (configuration, handler) => {
+    const host = `https://${configuration.apiHostname}`;
+    const transport = (options) => {
+        let metadata = undefined;
+        const controller = globalThis.AbortController ? new AbortController() : undefined;
+        let cancelled = false;
+        return {
+            sendMessage(msgBytes) {
+                var _a;
+                handler(options.url, {
+                    headers: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.toHeaders()) !== null && _a !== void 0 ? _a : {},
+                    method: "POST",
+                    body: msgBytes,
+                    signal: controller === null || controller === void 0 ? void 0 : controller.signal,
+                })
+                    .then((response) => {
+                    options.onHeaders(new grpc.Metadata(response.headers), response.status);
+                    return response.arrayBuffer();
+                })
+                    .then((body) => {
+                    if (cancelled)
+                        return;
+                    options.onChunk(new Uint8Array(body));
+                    options.onEnd();
+                })
+                    .catch((error) => {
+                    if (cancelled)
+                        return;
+                    cancelled = true;
+                    options.onEnd(error);
+                });
+            },
+            start(m) {
+                metadata = m;
+            },
+            finishSend() { },
+            cancel() {
+                if (cancelled)
+                    return;
+                cancelled = true;
+                controller === null || controller === void 0 ? void 0 : controller.abort();
+            },
+        };
+    };
+    return (request) => __awaiter(void 0, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            grpc.unary({
+                methodName: request.methodName,
+                service: { serviceName: request.serviceName },
+                requestStream: false,
+                responseStream: false,
+                requestType: request.requestType,
+                responseType: request.responseType,
+            }, {
+                request: new request.requestType(),
+                host,
+                onEnd: (response) => {
+                    if (isUnaryOutputOk(response)) {
+                        resolve(Ok(response));
+                    }
+                    else {
+                        resolve(Err(response));
+                    }
+                },
+                transport,
+            });
+        });
+    });
+});
+function isUnaryOutputOk(value) {
+    return value.status === grpc.Code.OK;
+}
+//# sourceMappingURL=grpcHandler.js.map

package/dist/clients/grpcHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpcHandler.js","sourceRoot":"","sources":["../../src/clients/grpcHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import { grpc } from \"@improbable-eng/grpc-web\";\nimport type { Handler, RequestMetadata } from \"../handlers/HandlerChainBuilder\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport type { CameraKitConfiguration } from \"../configuration\";\nimport { configurationToken } from \"../configuration\";\nimport type { Result } from \"../common/result\";\nimport { Err, Ok } from \"../common/result\";\nimport type { FetchHandler } from \"../handlers/defaultFetchHandler\";\nimport { cameraKitServiceFetchHandlerFactory } from \"../handlers/cameraKitServiceFetchHandlerFactory\";\n\nexport interface GrpcRequest {\n    serviceName: string;\n    methodName: string;\n    requestType: grpc.ProtobufMessageClass<grpc.ProtobufMessage>;\n    responseType: grpc.ProtobufMessageClass<grpc.ProtobufMessage>;\n}\n\nexport type GrpcHandler = Handler<GrpcRequest, GrpcResult, RequestMetadata>;\n\nexport type GrpcResult = Result<\n    grpc.UnaryOutput<grpc.ProtobufMessage> & { status: grpc.Code.OK },\n    grpc.UnaryOutput<grpc.ProtobufMessage>\n>;\n\n/**\n * An Injectable handler that can make requests to the CameraKit backend service via grpc-web. This handler can be\n * passed to {@link createTsProtoClient} to produce a well-typed service client.\n *\n * @internal\n */\nexport const grpcHandlerFactory = Injectable(\n    \"grpcHandlerFactory\",\n    [configurationToken, cameraKitServiceFetchHandlerFactory.token] as const,\n    (configuration: CameraKitConfiguration, handler: FetchHandler): GrpcHandler => {\n        const host = `https://${configuration.apiHostname}`;\n\n        // We define our own Transport so that we can use our custom `fetch` implementation. This is important for two\n        // reasons:\n        //   1. Our custom fetch includes features like retries that we want to use for these requests.\n        //   2. Applications may override this fetch implementation (via our DI system) to support more advanced\n        //      use-cases.\n        const transport: grpc.TransportFactory = (options) => {\n            let metadata: grpc.Metadata | undefined = undefined;\n            const controller = globalThis.AbortController ? new AbortController() : undefined;\n            let cancelled = false;\n            return {\n                sendMessage(msgBytes) {\n                    handler(options.url, {\n                        headers: metadata?.toHeaders() ?? {},\n                        method: \"POST\",\n                        body: msgBytes,\n                        signal: controller?.signal,\n                    })\n                        .then((response) => {\n                            options.onHeaders(new grpc.Metadata(response.headers), response.status);\n                            return response.arrayBuffer();\n                        })\n                        .then((body) => {\n                            if (cancelled) return;\n                            options.onChunk(new Uint8Array(body));\n                            options.onEnd();\n                        })\n                        .catch((error) => {\n                            if (cancelled) return;\n                            cancelled = true;\n                            options.onEnd(error);\n                        });\n                },\n\n                start(m) {\n                    metadata = m;\n                },\n\n                finishSend() {},\n\n                cancel() {\n                    if (cancelled) return;\n                    cancelled = true;\n                    controller?.abort();\n                },\n            };\n        };\n\n        return async (request) =>\n            new Promise((resolve) => {\n                grpc.unary(\n                    {\n                        methodName: request.methodName,\n                        service: { serviceName: request.serviceName },\n                        requestStream: false,\n                        responseStream: false,\n                        requestType: request.requestType,\n                        responseType: request.responseType,\n                    },\n                    {\n                        request: new request.requestType(),\n                        host,\n                        onEnd: (response) => {\n                            if (isUnaryOutputOk(response)) {\n                                resolve(Ok(response));\n                            } else {\n                                resolve(Err(response));\n                            }\n                        },\n                        transport,\n                    }\n                );\n            });\n    }\n);\n\nfunction isUnaryOutputOk(\n    value: grpc.UnaryOutput<grpc.ProtobufMessage>\n): value is grpc.UnaryOutput<grpc.ProtobufMessage> & { status: grpc.Code.OK } {\n    return value.status === grpc.Code.OK;\n}\n"]}

package/dist/clients/lensesClient.d.ts

@@ -0,0 +1,10 @@
+import { LensesDefinition } from "../generated-proto/pb_schema/camera_kit/v3/service";
+import type { TsProtoServiceClient } from "./createTsProtoClient";
+import type { GrpcHandler } from "./grpcHandler";
+export type LensesClient = TsProtoServiceClient<typeof LensesDefinition>;
+export declare const lensesClientFactory: {
+    (args_0: GrpcHandler): LensesClient;
+    token: "lensesClient";
+    dependencies: readonly ["grpcHandlerFactory"];
+};
+//# sourceMappingURL=lensesClient.d.ts.map

package/dist/clients/lensesClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lensesClient.d.ts","sourceRoot":"","sources":["../../src/clients/lensesClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,MAAM,MAAM,YAAY,GAAG,oBAAoB,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEzE,eAAO,MAAM,mBAAmB;;;;CAI/B,CAAC"}

package/dist/clients/lensesClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lensesClient.js","sourceRoot":"","sources":["../../src/clients/lensesClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAC;AAEtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAInD,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CACzC,cAAc,EACd,CAAC,kBAAkB,CAAC,KAAK,CAAU,EACnC,CAAC,WAAwB,EAAgB,EAAE,CAAC,mBAAmB,CAAC,gBAAgB,EAAE,WAAW,CAAC,CACjG,CAAC","sourcesContent":["import { Injectable } from \"../dependency-injection/Injectable\";\nimport { LensesDefinition } from \"../generated-proto/pb_schema/camera_kit/v3/service\";\nimport type { TsProtoServiceClient } from \"./createTsProtoClient\";\nimport { createTsProtoClient } from \"./createTsProtoClient\";\nimport type { GrpcHandler } from \"./grpcHandler\";\nimport { grpcHandlerFactory } from \"./grpcHandler\";\n\nexport type LensesClient = TsProtoServiceClient<typeof LensesDefinition>;\n\nexport const lensesClientFactory = Injectable(\n    \"lensesClient\",\n    [grpcHandlerFactory.token] as const,\n    (grpcHandler: GrpcHandler): LensesClient => createTsProtoClient(LensesDefinition, grpcHandler)\n);\n"]}