@snap/camera-kit 0.16.2 → 0.18.0

package/lib/bootstrapCameraKit.js

@@ -1,220 +0,0 @@
-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";
-const logger = getLogger("bootstrapCameraKit");
-// The following errors are not wrapped with BootstrapError and bubble up as is.
-const nonWrappableErrors = [
-    "ConfigurationError",
-    "PlatformNotSupportedError",
-];
-/**
- * Returns true if given error has to be wrapped with BootstrapError.
- */
-function shouldWrapError(error) {
-    if (error instanceof Error) {
-        return !nonWrappableErrors.some((name) => error.name === name);
-    }
-    return true;
-}
-/**
- * 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 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);
-            // Public container holds services which applications can overwrite with their own implementations.
-            const defaultPublicContainer = Container.provides(configurationFactory)
-                .provides(defaultFetchHandlerFactory)
-                .provides(remoteMediaAssetLoaderFactory)
-                .provides(lensSourcesFactory)
-                .provides(remoteApiServicesFactory)
-                .provides(uriHandlersFactory)
-                .provides(externalMetricsSubjectFactory);
-            const publicContainer = provide ? provide(defaultPublicContainer) : defaultPublicContainer;
-            // Now that the client's provide() function has completed and the configuration override is ready,
-            // we create another container to initialize the logger. This ensures that logging is available
-            // as we continue bootstrapping. We don't initialize the logger as part of the defaultPublicContainer
-            // because we don't want applications to provide their own logger implementations,
-            // and we're not interested in errors thrown by their provide() function.
-            // Below is the minimum required container to report errors to Blizzard.
-            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)
-                // We'll run a PartialContainer containing reporters for globally-scoped metrics. Running this container
-                // allows each metric reporter to initialize itself (e.g. by adding event listeners to detect when certain
-                // actions occur). This PartialContainer also includes the service which listens to locally-reported metrics
-                // and sends them to our backend.
-                .run(reportGloballyScopedMetrics)
-                .run(businessEventsReporterFactory);
-            // Run the exception logger so that it can subscribe to log events -- we can't use `Container.run()` because
-            // reportGlobalException is also used as a dependency by other Services (and run does not provide Services,
-            // it just runs them once).
-            telemetryContainer.get(reportGlobalException.token);
-            // At this point, logger is configured to report to console and Blizzard.
-            yield assertPlatformSupported();
-            // LensCore is a foundational component which must be created asynchronously.
-            // But it's annoying for every consumer of LensCore to have to wait on Promise<LensCore>
-            // (which means they become async themselves). So we'll create a DI container which provides Promise<LensCore>,
-            // wait for that promise once here, then create a new DI container that just contains LensCore.
-            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);
-            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;
-        }
-    });
-}
-/**
- * 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 function createExtension() {
-    return new PartialContainer({});
-}
-//# sourceMappingURL=bootstrapCameraKit.js.map

package/lib/bootstrapCameraKit.js.map

@@ -1 +0,0 @@
-{"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 { CameraKit, 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 { CameraKitBootstrapConfiguration, createCameraKitConfigurationFactory } from \"./configuration\";\nimport { 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 { bootstrapError, ConfigurationError, configurationError, PlatformNotSupportedError } 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\";\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\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/lib/clients/createTsProtoClient.d.ts

@@ -1,40 +0,0 @@
-import { grpc } from "@improbable-eng/grpc-web";
-import { Writer } from "protobufjs";
-import { Result } from "../common/result";
-import { Exact, DeepPartial } from "../generated-proto/pb_schema/camera_kit/v3/service";
-import { 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 {};

package/lib/clients/createTsProtoClient.js

@@ -1,52 +0,0 @@
-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;
-        }
-    };
-}
-/**
- * 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 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,
-                });
-            }),
-        ];
-        // Safety: We're mapping from the method definitions object into the GrpcServiceClient object in a manner
-        // that preserves each key in the method definitions object, pairing it with the corresponding
-        // serialization/deserialization logic for that particular method. But in doing this, we lose type
-        // specificity by converting the method definition object to a list of entries, mapping them, and then
-        // converting back into the client object -- so we're forced into this type cast.
-    }));
-}
-//# sourceMappingURL=createTsProtoClient.js.map

package/lib/clients/createTsProtoClient.js.map

@@ -1 +0,0 @@
-{"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;AAED;;;;;;;;;;GAUG;AACH,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;QACF,yGAAyG;QACzG,8FAA8F;QAC9F,kGAAkG;QAClG,sGAAsG;QACtG,iFAAiF;IACrF,CAAC,CAAC,CACsB,CAAC;AACjC,CAAC","sourcesContent":["import { grpc } from \"@improbable-eng/grpc-web\";\nimport { Writer } from \"protobufjs\";\nimport { entries, fromEntries } from \"../common/entries\";\nimport { Result } from \"../common/result\";\nimport { Exact, DeepPartial } from \"../generated-proto/pb_schema/camera_kit/v3/service\";\nimport { 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/lib/clients/grpcHandler.d.ts

@@ -1,26 +0,0 @@
-import { grpc } from "@improbable-eng/grpc-web";
-import { Handler, RequestMetadata } from "../handlers/HandlerChainBuilder";
-import { CameraKitConfiguration } from "../configuration";
-import { Result } from "../common/result";
-import { 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"];
-};

package/lib/clients/grpcHandler.js

@@ -1,90 +0,0 @@
-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";
-/**
- * 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 const grpcHandlerFactory = Injectable("grpcHandlerFactory", [configurationToken, cameraKitServiceFetchHandlerFactory.token], (configuration, handler) => {
-    const host = `https://${configuration.apiHostname}`;
-    // We define our own Transport so that we can use our custom `fetch` implementation. This is important for two
-    // reasons:
-    //   1. Our custom fetch includes features like retries that we want to use for these requests.
-    //   2. Applications may override this fetch implementation (via our DI system) to support more advanced
-    //      use-cases.
-    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/lib/clients/grpcHandler.js.map

@@ -1 +0,0 @@
-{"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 { Handler, RequestMetadata } from \"../handlers/HandlerChainBuilder\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport { CameraKitConfiguration, configurationToken } from \"../configuration\";\nimport { Err, Ok, Result } from \"../common/result\";\nimport { 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/lib/clients/lensesClient.d.ts

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

package/lib/clients/lensesClient.js.map

@@ -1 +0,0 @@
-{"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;AACtF,OAAO,EAAwB,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAe,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIhE,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 { TsProtoServiceClient, createTsProtoClient } from \"./createTsProtoClient\";\nimport { GrpcHandler, 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"]}

package/lib/clients/metricsClient.d.ts

@@ -1,26 +0,0 @@
-import { Subject } from "rxjs";
-import { PageVisibility } from "../common/pageVisibility";
-import { ServerEvent } from "../generated-proto/blizzard/cameraKitEvents";
-import { MetricsDefinition } from "../generated-proto/pb_schema/camera_kit/v3/service";
-import { Metric } from "../metrics/operational/Metric";
-import { TsProtoServiceClient } from "./createTsProtoClient";
-import { GrpcHandler } from "./grpcHandler";
-export declare class MetricsClient {
-    private readonly grpcClient;
-    private readonly businessEventsHandler;
-    private readonly operationalMetricsHandler;
-    constructor(grpcClient: TsProtoServiceClient<typeof MetricsDefinition>, pageVisibility: PageVisibility | false);
-    setBusinessEvents(event: ServerEvent): Promise<void>;
-    setOperationalMetrics(metric: Metric): Promise<void>;
-}
-/** @internal */
-export declare const externalMetricsSubjectFactory: {
-    (): Subject<Metric>;
-    token: "externalMetricsSubject";
-    dependencies: [];
-};
-export declare const metricsClientFactory: {
-    (args_0: Subject<Metric>, args_1: GrpcHandler, args_2: PageVisibility): MetricsClient;
-    token: "metricsClient";
-    dependencies: readonly ["externalMetricsSubject", "grpcHandlerFactory", "pageVisibility"];
-};