@snap/camera-kit 0.17.0 → 0.18.0

package/LICENSE.md

@@ -4583,14 +4583,14 @@ Package Locator:
 --------------------------------------------------------------------------------
 * Declared Licenses *
 This repository uses 2 different licenses :
-- all files in the `lib` directory use a BSD 2-Clause license
+- all files in the `dist` directory use a BSD 2-Clause license
 - all other files use a GPLv2 license, unless explicitly stated otherwise
 
 Relevant license is reminded at the top of each source file,
 and with presence of COPYING or LICENSE file in associated directories.
 
 This model is selected to emphasize that
-files in the `lib` directory are designed to be included into 3rd party applications,
+files in the `dist` directory are designed to be included into 3rd party applications,
 while all other files, in `programs`, `tests` or `examples`,
 receive more limited attention and support for such scenario.
 

package/README.md

@@ -181,7 +181,7 @@ session.pause('capture');
 
 ## Error Handling
 
-Camera Kit Web SDK methods may throw errors, or return rejected Promises -- these are documented in the [API docs](https://kit.snapchat.com/reference/CameraKit/web/0.17.0/index.html). It is good practice to handle such cases, to provide a good experience to your users.
+Camera Kit Web SDK methods may throw errors, or return rejected Promises -- these are documented in the [API docs](https://kit.snapchat.com/reference/CameraKit/web/0.18.0/index.html). It is good practice to handle such cases, to provide a good experience to your users.
 
 Errors may also occur during Lens rendering. For example, Lenses contain their own scripting, which could throw an error. A rendering error could also occur if a Lens attempts to use a feature that is not supported by Camera Kit Web SDK.
 

package/dist/CameraKit.d.ts

@@ -0,0 +1,334 @@
+import type { LensRepository } from "./lens/LensRepository";
+import type { Container } from "./dependency-injection/Container";
+import type { LensCoreError } from "./lens-core-module/lensCoreError";
+import type { LensCore } from "./lens-core-module/lensCore";
+import type { CameraKitSession } from "./session/CameraKitSession";
+import type { RootServices } from "./dependency-injection/RootServices";
+import type { MetricsEventTarget } from "./metrics/metricsEventTarget";
+import { TypedEventTarget } from "./events/TypedEventTarget";
+import type { TypedCustomEvent } from "./events/TypedCustomEvent";
+import type { LensView } from "./metrics/reporters/reportLensView";
+import type { LensWait } from "./metrics/reporters/reportLensWait";
+import type { PageVisibility } from "./common/pageVisibility";
+/**
+ * Lens metrics events.
+ *
+ * These events are emitted by {@link CameraKit} to report lens usage, performance, apply latency, etc.
+ *
+ * @category Lenses
+ * @category Metrics
+ */
+export type LensMetricsEvents = TypedCustomEvent<LensView["name"], LensView> | TypedCustomEvent<LensWait["name"], LensWait>;
+/**
+ * Options available when creating a {@link CameraKitSession}.
+ *
+ * @category Rendering
+ */
+export interface CreateSessionOptions {
+    /**
+     * Optionally provide an existing canvas element, on which the Live RenderTarget will be rendered.
+     *
+     * If this is not provided, CameraKit will create a new canvas element which can be added to the DOM.
+     */
+    liveRenderTarget?: HTMLCanvasElement;
+    /**
+     * Browsers optimize tabs when they are hidden - for example, by pausing the execution of requestAnimationFrame
+     * callbacks.
+     *
+     * If you need the CameraKitSession to continue rendering even when the tab is in the background, set this to true.
+     * There is a small performance penalty, and it's a good practice to only render in the background if absolutely
+     * necessary.
+     */
+    renderWhileTabHidden?: boolean;
+}
+/**
+ * The entry point to the CameraKit SDK's API. Most of CameraKit's features are accessed via this class.
+ *
+ * Applications obtain an instance of CameraKit by calling {@link bootstrapCameraKit}.
+ *
+ * @example
+ * ```ts
+ * const cameraKit = await bootstrapCameraKit(config)
+ * ```
+ *
+ * Then this class can be used to:
+ * - Create a {@link CameraKitSession} instance, which provides the API for setting up media inputs, applying Lenses,
+ * and obtaining rendered `<canvas>` outputs.
+ * - Query for lenses using {@link LensRepository}.
+ * - Listen for lens usage metrics events using {@link MetricsEventTarget}.
+ *
+ * @category Rendering
+ * @category Lenses
+ */
+export declare class CameraKit {
+    /**
+     * Used to query for lenses and lens groups.
+     */
+    readonly lensRepository: LensRepository;
+    private readonly lensCore;
+    private readonly pageVisibility;
+    private readonly container;
+    /** @deprecated Use {@link lensRepository} */
+    readonly lenses: {
+        repository: LensRepository;
+    };
+    /**
+     * Business metrics (e.g. each time a lens is viewed) are emitted here.
+     */
+    readonly metrics: TypedEventTarget<LensMetricsEvents>;
+    private sessions;
+    /** @internal */
+    constructor(
+    /**
+     * Used to query for lenses and lens groups.
+     */
+    lensRepository: LensRepository, lensCore: LensCore, pageVisibility: PageVisibility, container: Container<RootServices>, allMetrics: MetricsEventTarget);
+    /**
+     * Create a CameraKitSession.
+     *
+     * This initializes the rendering engine and returns a {@link CameraKitSession} instance, which provides access
+     * to Lens rendering.
+     *
+     * @example
+     * ```ts
+     * const cameraKit = await bootstrapCameraKit(config)
+     * const session = await cameraKit.createSession()
+     *
+     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)
+     * session.applyLens(lens)
+     * ```
+     *
+     * @param options
+     */
+    createSession({ liveRenderTarget, renderWhileTabHidden, }?: CreateSessionOptions): Promise<CameraKitSession>;
+    /**
+     * Destroys all sessions and frees all resources.
+     */
+    destroy(): Promise<void>;
+}
+/** @internal */
+export declare const cameraKitFactory: {
+    (args_0: LensRepository, args_1: MetricsEventTarget, args_2: {
+        ErrorType: {
+            LensDeserialization: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Validation: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Uncategorized: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            LensExecution: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Abort: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Uninitialized: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        AssetType: {
+            RemoteMediaByUrl: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            DeviceDependent: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Static: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            URL: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            BitmojiDynamicAsset: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        CanvasType: {
+            None: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Preview: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Capture: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            All: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        LensApiVisibility: {
+            Dev: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Private: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Public: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        DeviceClass: {
+            Undefined: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            BarelyWorking: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            LowEnd: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            MidEnd: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            HighEnd: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        RenderLoopMode: {
+            SetTimeout: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            RequestAnimationFrame: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        UserDataAccess: {
+            Restricted: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Unrestricted: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        InterfaceControl: {
+            ToggleCameraButton: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            ImagePicker: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Hint: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Modal: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            LinkBitmojiCallToAction: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            SnapButton: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            PlayButton: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            All: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            ExitFullScreenButton: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            MemoriesButton: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            LensAttachmentButton: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            ReverseCamera: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        InterfaceAction: {
+            EnableHighlight: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            DisableHighlight: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Trigger: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Show: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            Hide: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        ExternalMediaOrientation: {
+            CW0: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            CW90: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            CW180: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            CW270: import("./lens-core-module/generated-types").LensCoreEnumValue;
+        };
+        mainScriptUrlOrBlob: string;
+    } & {
+        getCoreVersion: () => number;
+        getOutputCanvases: () => import("./lens-core-module/generated-types").GetOutputCanvasesOutput;
+        startProfiling: () => void;
+        endProfiling: () => void;
+        registerUriListener: (scheme: string, route: string, listener: import("./lens-core-module/generated-types").UriListener) => void;
+        provideUriResponse: (requestId: string, response: import(".").UriResponse) => void;
+        setRemoteAssetsProvider: (provider: import("./lens-core-module/generated-types").SetRemoteAssetsProviderInput) => void;
+        setRemoteAssetsUploadHandler: (provider: import("./lens-core-module/generated-types").SetRemoteAssetsUploadHandlerInput) => void;
+        provideRemoteAssetsUploadResponse: (assetResponse: import("./lens-core-module/generated-types").ProvideRemoteAssetsUploadResponseInput) => void;
+        registerShowHintCallback: (callback: import("./lens-core-module/generated-types").ShowHintCallback) => void;
+        registerHideHintCallback: (callback: import("./lens-core-module/generated-types").HideHintCallback) => void;
+        registerSavePersistentStoreCallback: (callback: import("./lens-core-module/generated-types").SavePersistentStoreCallback) => void;
+        setInterfaceControlVisibility: (config: import("./lens-core-module/generated-types").SetInterfaceControlVisibilityInput) => void;
+        handleClientInterfaceAction: (config: import("./lens-core-module/generated-types").HandleClientInterfaceActionInput) => void;
+        provideExternalImage: (config: import("./lens-core-module/generated-types").ProvideExternalImageInput) => void;
+        provideExternalVideo: (config: import("./lens-core-module/generated-types").ProvideExternalVideoInput) => void;
+        setScreenDimmingRequestHandler: (callback: import("./lens-core-module/generated-types").ScreenDimmingRequestHandler) => void;
+        setClientInterfaceRequestHandler: (callback: import("./lens-core-module/generated-types").ClientInterfaceRequestHandler) => void;
+        setPreloadedConfiguration: (config: import("./lens-core-module/generated-types").SetPreloadedConfigurationInput) => void;
+        setAllSoundsMuted: (config: import("./lens-core-module/generated-types").SetAllSoundsMutedInput) => void;
+        setSystemFonts: (config: import("./lens-core-module/generated-types").SetSystemFontsInput) => void;
+        registerBeginWebXrHandler: (handler: ((config: import("./lens-core-module/generated-types").BeginWebXrInput) => void) | null) => void;
+        registerEndWebXrHandler: (handler: (() => void) | null) => void;
+    } & {
+        processFrame: (input: Omit<import("./lens-core-module/generated-types").ProcessFrameInput, "onFailure" | "onSuccess">) => Promise<any>;
+        addLens: (input: Omit<import("./lens-core-module/generated-types").AddLensInput, "onFailure" | "onSuccess">) => Promise<any>;
+        replaceLenses: (input: Omit<import("./lens-core-module/generated-types").ReplaceLensesInput, "onFailure" | "onSuccess">) => Promise<any>;
+        removeLens: (input: Omit<import("./lens-core-module/generated-types").RemoveLensInput, "onFailure" | "onSuccess">) => Promise<any>;
+        clearAllLenses: () => Promise<any>;
+        teardown: () => Promise<any>;
+        useMediaElement: (input: Omit<import("./lens-core-module/generated-types").UseMediaElementInput, "onFailure" | "onSuccess">) => Promise<any>;
+        setFPSLimit: (input: Omit<import("./lens-core-module/generated-types").SetFpsLimitInput, "onFailure" | "onSuccess">) => Promise<any>;
+        setRenderLoopMode: (input: Omit<import("./lens-core-module/generated-types").SetRenderLoopInput, "onFailure" | "onSuccess">) => Promise<any>;
+        pauseCanvas: (input: Omit<import("./lens-core-module/generated-types").PauseCanvasInput, "onFailure" | "onSuccess">) => Promise<any>;
+        setRenderSize: (input: Omit<import("./lens-core-module/generated-types").SetRenderSizeMatchInputResolutionInput, "onFailure" | "onSuccess"> | Omit<import("./lens-core-module/generated-types").SetRenderSizeExplicitInput, "onFailure" | "onSuccess">) => Promise<any>;
+        setInputTransform: (input: Omit<import("./lens-core-module/generated-types").SetInputTransformInput, "onFailure" | "onSuccess">) => Promise<any>;
+        imageToYuvBuffer: (input: Omit<import("./lens-core-module/generated-types").ImageToYuvBufferInput, "onFailure" | "onSuccess">) => Promise<ArrayBuffer>;
+        yuvBufferToBitmap: (input: Omit<import("./lens-core-module/generated-types").YuvBufferToBitmapInput, "onFailure" | "onSuccess">) => Promise<ImageBitmap>;
+        setOnFrameProcessedCallback: (input: Omit<import("./lens-core-module/generated-types").SetOnFrameProcessedInput, "onFailure" | "onSuccess">) => Promise<any>;
+        setDeviceClass: (input: Omit<import("./lens-core-module/generated-types").SetDeviceClassInput, "onFailure" | "onSuccess">) => Promise<any>;
+        setAudioParameters: (input: Omit<import("./lens-core-module/generated-types").SetAudioParametersInput, "onFailure" | "onSuccess">) => Promise<any>;
+        processAudioSampleBuffer: (input: Omit<import("./lens-core-module/generated-types").ProcessAudioSampleBufferInput, "onFailure" | "onSuccess">) => Promise<any>;
+    } & {
+        initialize(input: {
+            canvas?: string | HTMLCanvasElement | undefined;
+            outputResolution?: import("./lens-core-module/generated-types").Dimensions | undefined;
+            showFpsPanel?: boolean | undefined;
+            shouldUseWorker?: boolean | undefined;
+            onFrameProcessed?: ((arg: import("./lens-core-module/generated-types").OnFrameProcessedParam) => void) | undefined;
+            xrCapabilities?: import("./lens-core-module/generated-types").XrCapabilities | undefined;
+            exceptionHandler?: ((err: LensCoreError) => void) | undefined;
+        }): Promise<void>;
+        provideRemoteAssetsResponse(input: {
+            assetId: string;
+            assetType: import("./lens-core-module/generated-types").LensCoreEnumValue;
+            assetBuffer?: ArrayBuffer | undefined;
+            assetChecksum?: string | undefined;
+            onFailure?: ((err: LensCoreError) => void) | undefined;
+        }): void;
+        playCanvas(input: Omit<import("./lens-core-module/generated-types").PlayCanvasInput, "onFailure" | "onSuccess" | "onReady">): Promise<void>;
+    } & import("./lens-core-module/lensCore").LensCoreErrorField, args_3: PageVisibility, args_4: Container<{
+        LensRepository: LensRepository;
+    } & {
+        metricsEventTarget: MetricsEventTarget;
+    } & {
+        lensCore: LensCore;
+    } & {
+        pageVisibility: PageVisibility;
+    } & {
+        lensCore: LensCore;
+    } & import("./dependency-injection/RootServices").PublicServices & import("./dependency-injection/types").ServicesFromInjectables<[{
+        (): PageVisibility;
+        token: "pageVisibility";
+        dependencies: [];
+    }, {
+        (): MetricsEventTarget;
+        token: "metricsEventTarget";
+        dependencies: [];
+    }, {
+        (): import("./handlers/requestStateEmittingHandler").RequestStateEventTarget;
+        token: "requestStateEventTarget";
+        dependencies: [];
+    }, {
+        (args_0: import("./configuration").CameraKitConfiguration, args_1: import(".").FetchHandler): import("./handlers/HandlerChainBuilder").Handler<RequestInfo, Response, RequestInit | undefined>;
+        token: "cameraKitServiceFetchHandler";
+        dependencies: readonly ["configuration", "defaultFetchHandler"];
+    }, {
+        (args_0: import("./configuration").CameraKitConfiguration, args_1: import(".").FetchHandler): import("./clients/grpcHandler").GrpcHandler;
+        token: "grpcHandlerFactory";
+        dependencies: readonly ["configuration", "cameraKitServiceFetchHandler"];
+    }, {
+        (args_0: import("./clients/grpcHandler").GrpcHandler): import("./clients/lensesClient").LensesClient;
+        token: "lensesClient";
+        dependencies: readonly ["grpcHandlerFactory"];
+    }, {
+        (args_0: import("./configuration").CameraKitConfiguration, args_1: import("./handlers/requestStateEmittingHandler").RequestStateEventTarget, args_2: import("./clients/metricsClient").MetricsClient): import("./handlers/HandlerChainBuilder").Handler<Partial<import("./generated-proto/pb_schema/cdp/cof/config_request").ConfigTargetingRequest>, import("./generated-proto/pb_schema/cdp/cof/config_response").ConfigTargetingResponse, import("./remote-configuration/cofHandler").Metadata & {
+            signal?: AbortSignal | null | undefined;
+            isSideEffect?: boolean | undefined;
+        }>;
+        token: "cofHandler";
+        dependencies: readonly ["configuration", "requestStateEventTarget", "metricsClient"];
+    }, {
+        (args_0: import("./configuration").CameraKitConfiguration, args_1: import("./handlers/HandlerChainBuilder").Handler<Partial<import("./generated-proto/pb_schema/cdp/cof/config_request").ConfigTargetingRequest>, import("./generated-proto/pb_schema/cdp/cof/config_response").ConfigTargetingResponse, import("./remote-configuration/cofHandler").Metadata & {
+            signal?: AbortSignal | null | undefined;
+            isSideEffect?: boolean | undefined;
+        }>, args_2: import("./clients/grpcHandler").GrpcHandler): import("./remote-configuration/remoteConfiguration").RemoteConfiguration;
+        token: "remoteConfiguration";
+        dependencies: readonly ["configuration", "cofHandler", "grpcHandlerFactory"];
+    }, {
+        (args_0: import("./handlers/requestStateEmittingHandler").RequestStateEventTarget, args_1: import(".").FetchHandler, args_2: import(".").LensSource[], args_3: import("./lens/assets/LensAssetRepository").LensAssetRepository): LensRepository;
+        token: "LensRepository";
+        dependencies: readonly ["requestStateEventTarget", "defaultFetchHandler", "lensSources", "lensAssetRepository"];
+    }, {
+        (args_0: LensCore): import("./persistence/IndexedDBPersistence").IndexedDBPersistence<ArrayBuffer>;
+        token: "lensPersistenceStore";
+        dependencies: readonly ["lensCore"];
+    }, {
+        (args_0: import("rxjs").Subject<import(".").Metric>, args_1: import("./clients/grpcHandler").GrpcHandler, args_2: PageVisibility): import("./clients/metricsClient").MetricsClient;
+        token: "metricsClient";
+        dependencies: readonly ["externalMetricsSubject", "grpcHandlerFactory", "pageVisibility"];
+    }, {
+        (args_0: LensCore, args_1: import(".").AssetLoader, args_2: import(".").AssetLoader, args_3: import(".").AssetLoader, args_4: MetricsEventTarget, args_5: import("./handlers/requestStateEmittingHandler").RequestStateEventTarget): import("./lens/assets/LensAssetRepository").LensAssetRepository;
+        token: "lensAssetRepository";
+        dependencies: readonly ["lensCore", "deviceDependentAssetLoader", "remoteMediaAssetLoader", "staticAssetLoader", "metricsEventTarget", "requestStateEventTarget"];
+    }, {
+        (args_0: import(".").FetchHandler, args_1: import("./remote-configuration/remoteConfiguration").RemoteConfiguration): import(".").AssetLoader;
+        token: "deviceDependentAssetLoader";
+        dependencies: readonly ["defaultFetchHandler", "remoteConfiguration"];
+    }, {
+        (args_0: import(".").FetchHandler): import(".").AssetLoader;
+        token: "staticAssetLoader";
+        dependencies: readonly ["defaultFetchHandler"];
+    }, {
+        (args_0: import("./remote-configuration/remoteConfiguration").RemoteConfiguration, args_1: import("./legal/legalPrompt").LegalPromptFactory): import("@snap/state-management").StateMachine<import("@snap/state-management").Action<"requestLegalPrompt", undefined> | import("@snap/state-management").Action<"accept", string> | import("@snap/state-management").Action<"reject", string>, import("@snap/state-management").State<"unknown", undefined> | import("@snap/state-management").State<"accepted", undefined> | import("@snap/state-management").State<"rejected", undefined>>;
+        token: "legalState";
+        dependencies: readonly ["remoteConfiguration", "legalPrompt"];
+    }, {
+        (): import("./legal/legalPrompt").LegalPromptFactory;
+        token: "legalPrompt";
+        dependencies: [];
+    }, {
+        (): import("rxjs").Observable<import("./logger/logger").LogEntry>;
+        token: "logEntries";
+        dependencies: [];
+    }, {
+        (args_0: import("rxjs").Observable<import("./logger/logger").LogEntry>, args_1: MetricsEventTarget, args_2: import("./clients/metricsClient").MetricsClient): import("./metrics/reporters/reportGlobalException").GlobalExceptionReporter;
+        token: "reportGlobalException";
+        dependencies: readonly ["logEntries", "metricsEventTarget", "metricsClient"];
+    }]>>): CameraKit;
+    token: "CameraKit";
+    dependencies: readonly ["LensRepository", "metricsEventTarget", "lensCore", "pageVisibility", "$container"];
+};
+//# sourceMappingURL=CameraKit.d.ts.map

package/dist/CameraKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CameraKit.d.ts","sourceRoot":"","sources":["../src/CameraKit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGlE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAKnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAUvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAW9D;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACvB,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,GAC5C,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IAErC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,SAAS;IAad;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc;IAEvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAnB9B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,cAAc,CAAA;KAAE,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAA0B;IAE/E,OAAO,CAAC,QAAQ,CAA0B;IAE1C,gBAAgB;;IAEZ;;OAEG;IACM,cAAc,EAAE,cAAc,EAEtB,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,cAAc,EAC9B,SAAS,EAAE,SAAS,CAAC,YAAY,CAAC,EACnD,UAAU,EAAE,kBAAkB;IAUlC;;;;;;;;;;;;;;;;OAgBG;IAEG,aAAa,CAAC,EAChB,gBAAgB,EAChB,oBAAoB,GACvB,GAAE,oBAAyB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyExD;;OAEG;IAEG,OAAO;CAMhB;AAED,gBAAgB;AAChB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB5B,CAAC"}

package/dist/CameraKit.js

@@ -0,0 +1,104 @@
+import { __awaiter, __esDecorate, __runInitializers } from "tslib";
+import { lensRepositoryFactory } from "./lens/LensRepository";
+import { CONTAINER } from "./dependency-injection/Container";
+import { Injectable } from "./dependency-injection/Injectable";
+import { cameraKitSessionFactory } from "./session/CameraKitSession";
+import { registerLensAssetsProvider } from "./lens/assets/LensAssetsProvider";
+import { lensCoreFactory } from "./lens-core-module/loader/lensCoreFactory";
+import { configurationToken } from "./configuration";
+import { registerUriHandlers } from "./extensions/uriHandlersRegister";
+import { metricsEventTargetFactory } from "./metrics/metricsEventTarget";
+import { reportSessionScopedMetrics } from "./metrics/reporters/reporters";
+import { lensStateFactory } from "./session/lensState";
+import { lensKeyboardFactory } from "./session/LensKeyboard";
+import { registerLensClientInterfaceHandler } from "./lens-client-interface/lensClientInterface";
+import { sessionStateFactory } from "./session/sessionState";
+import { lensExecutionError, lensAbortError } from "./namedErrors";
+import { getLogger, resetLogger } from "./logger/logger";
+import { errorLoggingDecorator } from "./logger/errorLoggingDecorator";
+import { TypedEventTarget } from "./events/TypedEventTarget";
+import { pageVisibilityFactory } from "./common/pageVisibility";
+import { setPreloadedConfiguration } from "./remote-configuration/preloadConfiguration";
+const logger = getLogger("CameraKit");
+const publicMetricsEventNames = ["lensView", "lensWait"];
+export let CameraKit = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _createSession_decorators;
+    let _destroy_decorators;
+    return _a = class CameraKit {
+            constructor(lensRepository, lensCore, pageVisibility, container, allMetrics) {
+                this.lensRepository = (__runInitializers(this, _instanceExtraInitializers), lensRepository);
+                this.lensCore = lensCore;
+                this.pageVisibility = pageVisibility;
+                this.container = container;
+                this.metrics = new TypedEventTarget();
+                this.sessions = [];
+                this.lenses = { repository: this.lensRepository };
+                publicMetricsEventNames.forEach((eventName) => {
+                    allMetrics.addEventListener(eventName, (e) => this.metrics.dispatchEvent(e));
+                });
+            }
+            createSession({ liveRenderTarget, renderWhileTabHidden, } = {}) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const exceptionHandler = (error) => {
+                        if (error.name === "LensCoreAbortError") {
+                            logger.error(lensAbortError("Unrecoverable error occurred during lens execution. " +
+                                "The CameraKitSession will be destroyed.", error));
+                        }
+                        else {
+                            logger.error(lensExecutionError("Error occurred during lens execution. " +
+                                "The lens cannot be rendered and will be removed from the CameraKitSession.", error));
+                        }
+                    };
+                    yield this.lensCore.initialize({
+                        canvas: liveRenderTarget,
+                        shouldUseWorker: !renderWhileTabHidden && this.container.get(configurationToken).shouldUseWorker,
+                        exceptionHandler,
+                    });
+                    yield this.lensCore.setRenderLoopMode({
+                        mode: renderWhileTabHidden
+                            ? this.lensCore.RenderLoopMode.SetTimeout
+                            : this.lensCore.RenderLoopMode.RequestAnimationFrame,
+                    });
+                    const sessionContainer = this.container
+                        .copy()
+                        .provides(sessionStateFactory)
+                        .provides(lensStateFactory)
+                        .provides(lensKeyboardFactory)
+                        .provides(cameraKitSessionFactory)
+                        .run(registerLensAssetsProvider)
+                        .run(registerLensClientInterfaceHandler)
+                        .run(setPreloadedConfiguration)
+                        .run(reportSessionScopedMetrics)
+                        .run(registerUriHandlers);
+                    const session = sessionContainer.get(cameraKitSessionFactory.token);
+                    this.sessions.push(session);
+                    return session;
+                });
+            }
+            destroy() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    resetLogger();
+                    this.pageVisibility.destroy();
+                    yield Promise.all(this.sessions.map((session) => session.destroy()));
+                    this.sessions = [];
+                });
+            }
+        },
+        (() => {
+            _createSession_decorators = [errorLoggingDecorator(logger)];
+            _destroy_decorators = [errorLoggingDecorator(logger)];
+            __esDecorate(_a, null, _createSession_decorators, { kind: "method", name: "createSession", static: false, private: false, access: { has: obj => "createSession" in obj, get: obj => obj.createSession } }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _destroy_decorators, { kind: "method", name: "destroy", static: false, private: false, access: { has: obj => "destroy" in obj, get: obj => obj.destroy } }, null, _instanceExtraInitializers);
+        })(),
+        _a;
+})();
+export const cameraKitFactory = Injectable("CameraKit", [
+    lensRepositoryFactory.token,
+    metricsEventTargetFactory.token,
+    lensCoreFactory.token,
+    pageVisibilityFactory.token,
+    CONTAINER,
+], (lensRepository, metrics, lensCore, pageVisibility, container) => new CameraKit(lensRepository, lensCore, pageVisibility, container, metrics));
+//# sourceMappingURL=CameraKit.js.map

package/dist/CameraKit.js.map

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

package/dist/benchmark/benchmarkGflops.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarkGflops.d.ts","sourceRoot":"","sources":["../../src/benchmark/benchmarkGflops.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAoHhG;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,qCAO/B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,EAAE,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC,CAK1F"}