@snap/camera-kit 0.7.0

package/lib/lensCoreWasmVersions.json

@@ -0,0 +1,5 @@
+{
+    "version": "204",
+    "buildNumber": "79",
+    "baseUrl": "https://cf-st.sc-cdn.net/d/iEUhGJVwtLtAdTgiqHdLk?go=IgsKCTIBBEgBUFxgAQ%3D%3D&uc=92"
+}

package/lib/logger/errorLoggingDecorator.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from "./logger";
+/**
+ * Creates a class member decorator that logs errors thrown during the member invocation.
+ * If the member returns a Promise, promise rejections are handled.
+ * Any caught errors are re-thrown.
+ * @param logger The logger to report errors to.
+ * @return A decorator function.
+ */
+export declare function errorLoggingDecorator(logger: Logger): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/lib/logger/errorLoggingDecorator.js

@@ -0,0 +1,32 @@
+/**
+ * Creates a class member decorator that logs errors thrown during the member invocation.
+ * If the member returns a Promise, promise rejections are handled.
+ * Any caught errors are re-thrown.
+ * @param logger The logger to report errors to.
+ * @return A decorator function.
+ */
+export function errorLoggingDecorator(logger) {
+    const handleError = (error) => logger.error(error);
+    return function (_target, _propertyKey, descriptor) {
+        const methodName = descriptor.value ? "value" : "get";
+        const originalMethod = descriptor[methodName];
+        descriptor[methodName] = function (...args) {
+            try {
+                // "this" refers to original scope this function is called in
+                const result = originalMethod.apply(this, args);
+                if (result instanceof Promise) {
+                    // in case of a promise we don't return our promise chain
+                    // that logs an error because we want callers to handle the error as well
+                    result.catch(handleError);
+                }
+                return result;
+            }
+            catch (error) {
+                handleError(error);
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=errorLoggingDecorator.js.map

package/lib/logger/errorLoggingDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorLoggingDecorator.js","sourceRoot":"","sources":["../../src/logger/errorLoggingDecorator.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAc;IAChD,MAAM,WAAW,GAAG,CAAC,KAAc,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC5D,OAAO,UAAU,OAAY,EAAE,YAAoB,EAAE,UAA8B;QAC/E,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC;QACtD,MAAM,cAAc,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QAC9C,UAAU,CAAC,UAAU,CAAC,GAAG,UAAU,GAAG,IAAW;YAC7C,IAAI;gBACA,6DAA6D;gBAC7D,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBAChD,IAAI,MAAM,YAAY,OAAO,EAAE;oBAC3B,yDAAyD;oBACzD,yEAAyE;oBACzE,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;iBAC7B;gBACD,OAAO,MAAM,CAAC;aACjB;YAAC,OAAO,KAAK,EAAE;gBACZ,WAAW,CAAC,KAAK,CAAC,CAAC;gBACnB,MAAM,KAAK,CAAC;aACf;QACL,CAAC,CAAC;QACF,OAAO,UAAU,CAAC;IACtB,CAAC,CAAC;AACN,CAAC","sourcesContent":["import { Logger } from \"./logger\";\n\n/**\n * Creates a class member decorator that logs errors thrown during the member invocation.\n * If the member returns a Promise, promise rejections are handled.\n * Any caught errors are re-thrown.\n * @param logger The logger to report errors to.\n * @return A decorator function.\n */\nexport function errorLoggingDecorator(logger: Logger) {\n    const handleError = (error: unknown) => logger.error(error);\n    return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {\n        const methodName = descriptor.value ? \"value\" : \"get\";\n        const originalMethod = descriptor[methodName];\n        descriptor[methodName] = function (...args: any[]) {\n            try {\n                // \"this\" refers to original scope this function is called in\n                const result = originalMethod.apply(this, args);\n                if (result instanceof Promise) {\n                    // in case of a promise we don't return our promise chain\n                    // that logs an error because we want callers to handle the error as well\n                    result.catch(handleError);\n                }\n                return result;\n            } catch (error) {\n                handleError(error);\n                throw error;\n            }\n        };\n        return descriptor;\n    };\n}\n"]}

package/lib/logger/logEntries.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The factory creates new logEntries subject.
+ *
+ * NOTE: The factory calls `initLogger()`, which overrides the global `logEntrySubject`.
+ * This is currently necessary to avoid sharing the same subject between multiple `CameraKit` instances.
+ * In the future, we may throw an error when bootstrapping more than a single `CameraKit`,
+ * that will allow us to have a single log entry subject.
+ *
+ * @internal
+ */
+export declare const logEntriesFactory: {
+    (): import("rxjs").Observable<import("./logger").LogEntry>;
+    token: "logEntries";
+    dependencies: [];
+};

package/lib/logger/logEntries.js

@@ -0,0 +1,14 @@
+import { Injectable } from "../dependency-injection/Injectable";
+import { initLogger } from "./logger";
+/**
+ * The factory creates new logEntries subject.
+ *
+ * NOTE: The factory calls `initLogger()`, which overrides the global `logEntrySubject`.
+ * This is currently necessary to avoid sharing the same subject between multiple `CameraKit` instances.
+ * In the future, we may throw an error when bootstrapping more than a single `CameraKit`,
+ * that will allow us to have a single log entry subject.
+ *
+ * @internal
+ */
+export const logEntriesFactory = Injectable("logEntries", () => initLogger().asObservable());
+//# sourceMappingURL=logEntries.js.map

package/lib/logger/logEntries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logEntries.js","sourceRoot":"","sources":["../../src/logger/logEntries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,CAAC,CAAC","sourcesContent":["import { Injectable } from \"../dependency-injection/Injectable\";\nimport { initLogger } from \"./logger\";\n\n/**\n * The factory creates new logEntries subject.\n *\n * NOTE: The factory calls `initLogger()`, which overrides the global `logEntrySubject`.\n * This is currently necessary to avoid sharing the same subject between multiple `CameraKit` instances.\n * In the future, we may throw an error when bootstrapping more than a single `CameraKit`,\n * that will allow us to have a single log entry subject.\n *\n * @internal\n */\nexport const logEntriesFactory = Injectable(\"logEntries\", () => initLogger().asObservable());\n"]}

package/lib/logger/logger.d.ts

@@ -0,0 +1,35 @@
+import { Subject } from "rxjs";
+/**
+ * This map associates log level names with their corresponding level value.
+ * This means that a configured log level will match all log entries with a level value greater than
+ * or equal to the configured value.
+ */
+export declare const logLevelMap: {
+    error: number;
+    warn: number;
+    log: number;
+    info: number;
+    debug: number;
+};
+/**
+ * Initializes new logger subject.
+ * @internal
+ */
+export declare function initLogger(): Subject<LogEntry>;
+export interface LogEntry {
+    time: Date;
+    module: string;
+    level: keyof Logger;
+    messages: any[];
+}
+export declare type LogLevelName = keyof typeof logLevelMap;
+export declare type Logger = Record<LogLevelName, (message?: any, ...optionalParams: any[]) => void>;
+/**
+ * Gets logger for a given module.
+ *
+ * @internal
+ *
+ * @param module Module name.
+ * @returns Logger instance.
+ */
+export declare function getLogger(module: string): Logger;

package/lib/logger/logger.js

@@ -0,0 +1,48 @@
+import { Subject } from "rxjs";
+import { entries } from "../common/entries";
+/**
+ * The subsject is created and overrdien in initLogger().
+ * The function has to be called each time new instance of CameraKit is bootstrapped.
+ */
+let logEntriesSubject = new Subject();
+/**
+ * This map associates log level names with their corresponding level value.
+ * This means that a configured log level will match all log entries with a level value greater than
+ * or equal to the configured value.
+ */
+export const logLevelMap = {
+    error: 3,
+    warn: 2,
+    log: 1,
+    info: 1,
+    debug: 0,
+};
+/**
+ * Initializes new logger subject.
+ * @internal
+ */
+export function initLogger() {
+    return (logEntriesSubject = new Subject());
+}
+/**
+ * Gets logger for a given module.
+ *
+ * @internal
+ *
+ * @param module Module name.
+ * @returns Logger instance.
+ */
+export function getLogger(module) {
+    return entries(logLevelMap).reduce((logger, [level]) => {
+        logger[level] = (...messages) => {
+            logEntriesSubject.next({
+                time: new Date(),
+                module,
+                level,
+                messages,
+            });
+        };
+        return logger;
+    }, {});
+}
+//# sourceMappingURL=logger.js.map

package/lib/logger/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C;;;GAGG;AACH,IAAI,iBAAiB,GAAG,IAAI,OAAO,EAAY,CAAC;AAEhD;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,CAAC;IACN,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;CACX,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,UAAU;IACtB,OAAO,CAAC,iBAAiB,GAAG,IAAI,OAAO,EAAY,CAAC,CAAC;AACzD,CAAC;AAYD;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAC,MAAc;IACpC,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE;QACnD,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,QAAe,EAAE,EAAE;YACnC,iBAAiB,CAAC,IAAI,CAAC;gBACnB,IAAI,EAAE,IAAI,IAAI,EAAE;gBAChB,MAAM;gBACN,KAAK;gBACL,QAAQ;aACX,CAAC,CAAC;QACP,CAAC,CAAC;QACF,OAAO,MAAM,CAAC;IAClB,CAAC,EAAE,EAAY,CAAC,CAAC;AACrB,CAAC","sourcesContent":["import { Subject } from \"rxjs\";\nimport { entries } from \"../common/entries\";\n\n/**\n * The subsject is created and overrdien in initLogger().\n * The function has to be called each time new instance of CameraKit is bootstrapped.\n */\nlet logEntriesSubject = new Subject<LogEntry>();\n\n/**\n * This map associates log level names with their corresponding level value.\n * This means that a configured log level will match all log entries with a level value greater than\n * or equal to the configured value.\n */\nexport const logLevelMap = {\n    error: 3,\n    warn: 2,\n    log: 1,\n    info: 1,\n    debug: 0,\n};\n\n/**\n * Initializes new logger subject.\n * @internal\n */\nexport function initLogger() {\n    return (logEntriesSubject = new Subject<LogEntry>());\n}\n\nexport interface LogEntry {\n    time: Date;\n    module: string;\n    level: keyof Logger;\n    messages: any[];\n}\n\nexport type LogLevelName = keyof typeof logLevelMap;\nexport type Logger = Record<LogLevelName, (message?: any, ...optionalParams: any[]) => void>;\n\n/**\n * Gets logger for a given module.\n *\n * @internal\n *\n * @param module Module name.\n * @returns Logger instance.\n */\nexport function getLogger(module: string): Logger {\n    return entries(logLevelMap).reduce((logger, [level]) => {\n        logger[level] = (...messages: any[]) => {\n            logEntriesSubject.next({\n                time: new Date(),\n                module,\n                level,\n                messages,\n            });\n        };\n        return logger;\n    }, {} as Logger);\n}\n"]}

package/lib/logger/registerLogEntriesSubscriber.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from "rxjs";
+import { CameraKitConfiguration } from "../configuration";
+import { LogEntry } from "./logger";
+/**
+ * The factory subscribes to log entry events and, based on the configured log level,
+ * forwards matching log entries to the logger specified in the CameraKit configuration object.
+ *
+ * @internal
+ */
+export declare const registerLogEntriesSubscriber: {
+    (args_0: CameraKitConfiguration, args_1: Observable<LogEntry>): void;
+    token: "registerLogEntriesSubscriber";
+    dependencies: readonly ["configuration", "logEntries"];
+};

package/lib/logger/registerLogEntriesSubscriber.js

@@ -0,0 +1,23 @@
+import { filter } from "rxjs";
+import { configurationToken } from "../configuration";
+import { Injectable } from "../dependency-injection/Injectable";
+import { logEntriesFactory } from "./logEntries";
+import { logLevelMap } from "./logger";
+/**
+ * The factory subscribes to log entry events and, based on the configured log level,
+ * forwards matching log entries to the logger specified in the CameraKit configuration object.
+ *
+ * @internal
+ */
+export const registerLogEntriesSubscriber = Injectable("registerLogEntriesSubscriber", [configurationToken, logEntriesFactory.token], (configuration, logEntries) => {
+    logEntries
+        .pipe(filter((entry) => logLevelMap[entry.level] >= logLevelMap[configuration.logLevel]))
+        .subscribe((logEntry) => {
+        switch (configuration.logger) {
+            case "console":
+                console[logEntry.level](`[CameraKit.${logEntry.module}]`, ...logEntry.messages);
+                break;
+        }
+    });
+});
+//# sourceMappingURL=registerLogEntriesSubscriber.js.map

package/lib/logger/registerLogEntriesSubscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerLogEntriesSubscriber.js","sourceRoot":"","sources":["../../src/logger/registerLogEntriesSubscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,MAAM,MAAM,CAAC;AAC1C,OAAO,EAA0B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAY,WAAW,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAClD,8BAA8B,EAC9B,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,KAAK,CAAU,EACtD,CAAC,aAAqC,EAAE,UAAgC,EAAE,EAAE;IACxE,UAAU;SACL,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;SACxF,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;QACpB,QAAQ,aAAa,CAAC,MAAM,EAAE;YAC1B,KAAK,SAAS;gBACV,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,cAAc,QAAQ,CAAC,MAAM,GAAG,EAAE,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBAChF,MAAM;SACb;IACL,CAAC,CAAC,CAAC;AACX,CAAC,CACJ,CAAC","sourcesContent":["import { filter, Observable } from \"rxjs\";\nimport { CameraKitConfiguration, configurationToken } from \"../configuration\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport { logEntriesFactory } from \"./logEntries\";\nimport { LogEntry, logLevelMap } from \"./logger\";\n\n/**\n * The factory subscribes to log entry events and, based on the configured log level,\n * forwards matching log entries to the logger specified in the CameraKit configuration object.\n *\n * @internal\n */\nexport const registerLogEntriesSubscriber = Injectable(\n    \"registerLogEntriesSubscriber\",\n    [configurationToken, logEntriesFactory.token] as const,\n    (configuration: CameraKitConfiguration, logEntries: Observable<LogEntry>) => {\n        logEntries\n            .pipe(filter((entry) => logLevelMap[entry.level] >= logLevelMap[configuration.logLevel]))\n            .subscribe((logEntry) => {\n                switch (configuration.logger) {\n                    case \"console\":\n                        console[logEntry.level](`[CameraKit.${logEntry.module}]`, ...logEntry.messages);\n                        break;\n                }\n            });\n    }\n);\n"]}

package/lib/media-sources/CameraKitSource.d.ts

@@ -0,0 +1,88 @@
+import { LensCoreModule, UseMediaElementInput } from "../lens-core-module/generated-types";
+import { Transform2D } from "../transforms";
+/**
+ * When creating a {@link CameraKitSource}, passing a CameraKitSourceSubscriber allows logic to implemented which will
+ * run whenever that source is attached/detached from a CameraKitSession.
+ *
+ * @category Rendering
+ */
+export interface CameraKitSourceSubscriber {
+    readonly onAttach?: (source: CameraKitSource, lensCore: LensCoreModule, reportError: (error: Error) => void) => void | Promise<void>;
+    readonly onDetach?: (reportError: (error: Error) => void) => void | Promise<void>;
+}
+/** @category Rendering */
+export declare type CameraKitDeviceInfo = {
+    cameraType: "front" | "back";
+    fpsLimit: number;
+};
+export declare type CameraKitSourceInfo = Pick<UseMediaElementInput, "media" | "replayTrackingData" | "useManualFrameProcessing">;
+/** @category Rendering */
+export declare type CameraKitSourceOptions<T = {}> = Partial<T> & Partial<CameraKitDeviceInfo>;
+/**
+ * This general-purpose class represents a source of media for a {@link CameraKitSession}.
+ *
+ * When an instance is passed to {@link CameraKitSession.setSource | CameraKitSession.setSource}, it will be "attached"
+ * to the session. Later it may be "detached" from the session.
+ *
+ * Passing a {@link CameraKitSourceSubscriber} to the constructor allows callers to specify behavior
+ * that will occur when the source is attached and detached. This can be used to e.g. update the render size.
+ *
+ * @category Rendering
+ */
+export declare class CameraKitSource {
+    private readonly sourceInfo;
+    private readonly subscriber;
+    private lensCore?;
+    private readonly deviceInfo;
+    constructor(sourceInfo: CameraKitSourceInfo, subscriber?: CameraKitSourceSubscriber, deviceInfo?: Partial<CameraKitDeviceInfo>);
+    /**
+     * Called by {@link CameraKitSession} when this source is set as that session's source.
+     *
+     * @param lensCore
+     * @param reportError Calling this function will report an error back to the session.
+     * @returns Rejects if any calls to LensCore or CameraKitSource.subscriber.onAttach fail.
+     * @internal
+     */
+    attach(lensCore: LensCoreModule, reportError: (error: Error) => void): Promise<void>;
+    /**
+     * Make a copy of the source, sharing the same {@link CameraKitSourceSubscriber}.
+     *
+     * @param deviceInfo Optionally provide new device info for the copy (e.g. to change the camera type).
+     * @returns The new {@link CameraKitSource}
+     */
+    copy(deviceInfo?: Partial<CameraKitDeviceInfo>): CameraKitSource;
+    /**
+     * Called by {@link CameraKitSession} when it must remove this source.
+     *
+     * @param reportError Calling this function will report an error back to the session.
+     * @returns
+     * @internal
+     */
+    detach(reportError: (error: Error) => void): void | Promise<void>;
+    /**
+     * Set the resolution used to render this source.
+     *
+     * It’s important to distinguish render size from display size. The size at which the output canvases are displayed
+     * on a web page is determined by the CSS of the page. It is distinct from the size at which LensCore renders
+     * Lenses. Performance is dominated by render size, while any display scaling can most often be thought of as free.
+     *
+     * If greater performance is required, a smaller render size may boost frame-rate. It does come at a cost, including
+     * loss of accuracy in various tracking and computer-vision algorithms (since they'll be operating on fewer pixels).
+     *
+     * The size of the Live and Capture {@link RenderTarget} is always the same.
+     *
+     * @todo Currently it's only valid to call `setRenderSize` after `CameraKitSession.play` has been called. This
+     * constraint should be removed, so callers don't have to understand the underlying LensCore state machine.
+     *
+     * @param width pixels
+     * @param height pixels
+     * @returns Promise resolves when the render size has been successfully updated.
+     */
+    setRenderSize(width: number, height: number): Promise<void>;
+    /**
+     * Apply a 2D transformation to the source (e.g. translation, rotation, scale).
+     *
+     * @param transform Specifies the 3x3 matrix describing the transformation.
+     */
+    setTransform(transform: Transform2D): Promise<void>;
+}

package/lib/media-sources/CameraKitSource.js

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/member-ordering */
+import { __awaiter, __decorate, __metadata } from "tslib";
+import { validate } from "../common/validate";
+import { Transform2D } from "../transforms";
+const defaultDeviceInfo = {
+    cameraType: "front",
+    fpsLimit: Number.POSITIVE_INFINITY,
+};
+const createNotAttachedError = (message) => new Error(`${message}. This CameraKitSource is not attached to a CameraKitSession.`);
+/**
+ * This general-purpose class represents a source of media for a {@link CameraKitSession}.
+ *
+ * When an instance is passed to {@link CameraKitSession.setSource | CameraKitSession.setSource}, it will be "attached"
+ * to the session. Later it may be "detached" from the session.
+ *
+ * Passing a {@link CameraKitSourceSubscriber} to the constructor allows callers to specify behavior
+ * that will occur when the source is attached and detached. This can be used to e.g. update the render size.
+ *
+ * @category Rendering
+ */
+export class CameraKitSource {
+    constructor(sourceInfo, subscriber = {}, deviceInfo = {}) {
+        this.sourceInfo = sourceInfo;
+        this.subscriber = subscriber;
+        this.deviceInfo = Object.assign(Object.assign({}, defaultDeviceInfo), deviceInfo);
+    }
+    /**
+     * Called by {@link CameraKitSession} when this source is set as that session's source.
+     *
+     * @param lensCore
+     * @param reportError Calling this function will report an error back to the session.
+     * @returns Rejects if any calls to LensCore or CameraKitSource.subscriber.onAttach fail.
+     * @internal
+     */
+    attach(lensCore, reportError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.lensCore) {
+                throw new Error("Cannot attach. This CameraKitCustomSource has already been attached to " +
+                    "a CameraKitSession. To re-attach, create a copy of this CameraKitCustomSource.");
+            }
+            this.lensCore = lensCore;
+            yield new Promise((onSuccess, onFailure) => {
+                lensCore.useMediaElement({
+                    autoplayNewMedia: false,
+                    autoplayPreviewCanvas: false,
+                    media: this.sourceInfo.media,
+                    pauseExistingMedia: false,
+                    replayTrackingData: this.sourceInfo.replayTrackingData,
+                    requestWebcam: false,
+                    startOnFrontCamera: this.deviceInfo.cameraType === "front",
+                    useManualFrameProcessing: this.sourceInfo.useManualFrameProcessing,
+                    onSuccess,
+                    onFailure,
+                });
+            });
+            yield new Promise((onSuccess, onFailure) => {
+                // LensCore uses 0 to remove the limit.
+                const fps = this.deviceInfo.fpsLimit < Number.POSITIVE_INFINITY ? this.deviceInfo.fpsLimit : 0;
+                lensCore.setFPSLimit({ fps, onSuccess, onFailure });
+            });
+            if (this.subscriber.onAttach)
+                yield this.subscriber.onAttach(this, lensCore, reportError);
+        });
+    }
+    /**
+     * Make a copy of the source, sharing the same {@link CameraKitSourceSubscriber}.
+     *
+     * @param deviceInfo Optionally provide new device info for the copy (e.g. to change the camera type).
+     * @returns The new {@link CameraKitSource}
+     */
+    copy(deviceInfo = {}) {
+        return new CameraKitSource(this.sourceInfo, this.subscriber, Object.assign(Object.assign({}, this.deviceInfo), deviceInfo));
+    }
+    /**
+     * Called by {@link CameraKitSession} when it must remove this source.
+     *
+     * @param reportError Calling this function will report an error back to the session.
+     * @returns
+     * @internal
+     */
+    detach(reportError) {
+        if (!this.lensCore)
+            return Promise.reject(createNotAttachedError("Cannot detach"));
+        if (this.subscriber.onDetach)
+            return this.subscriber.onDetach(reportError);
+    }
+    /**
+     * Set the resolution used to render this source.
+     *
+     * It’s important to distinguish render size from display size. The size at which the output canvases are displayed
+     * on a web page is determined by the CSS of the page. It is distinct from the size at which LensCore renders
+     * Lenses. Performance is dominated by render size, while any display scaling can most often be thought of as free.
+     *
+     * If greater performance is required, a smaller render size may boost frame-rate. It does come at a cost, including
+     * loss of accuracy in various tracking and computer-vision algorithms (since they'll be operating on fewer pixels).
+     *
+     * The size of the Live and Capture {@link RenderTarget} is always the same.
+     *
+     * @todo Currently it's only valid to call `setRenderSize` after `CameraKitSession.play` has been called. This
+     * constraint should be removed, so callers don't have to understand the underlying LensCore state machine.
+     *
+     * @param width pixels
+     * @param height pixels
+     * @returns Promise resolves when the render size has been successfully updated.
+     */
+    setRenderSize(width, height) {
+        return new Promise((onSuccess, onFailure) => {
+            if (!this.lensCore)
+                return onFailure(createNotAttachedError("Cannot setRenderSize"));
+            const target = { width, height };
+            this.lensCore.setRenderSize({ mode: "explicit", target, onSuccess, onFailure });
+        });
+    }
+    /**
+     * Apply a 2D transformation to the source (e.g. translation, rotation, scale).
+     *
+     * @param transform Specifies the 3x3 matrix describing the transformation.
+     */
+    setTransform(transform) {
+        return new Promise((onSuccess, onFailure) => {
+            if (!this.lensCore)
+                return onFailure(createNotAttachedError("Cannot setTransform"));
+            const matrix = new Float32Array(transform.matrix);
+            this.lensCore.setInputTransform({ matrix, onSuccess, onFailure });
+        });
+    }
+}
+__decorate([
+    validate,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", Promise)
+], CameraKitSource.prototype, "setRenderSize", null);
+__decorate([
+    validate,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Transform2D]),
+    __metadata("design:returntype", Promise)
+], CameraKitSource.prototype, "setTransform", null);
+//# sourceMappingURL=CameraKitSource.js.map

package/lib/media-sources/CameraKitSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CameraKitSource.js","sourceRoot":"","sources":["../../src/media-sources/CameraKitSource.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/member-ordering */\n\nimport { validate } from \"../common/validate\";\nimport { LensCoreModule, UseMediaElementInput } from \"../lens-core-module/generated-types\";\nimport { Transform2D } from \"../transforms\";\n\nconst defaultDeviceInfo: CameraKitDeviceInfo = {\n    cameraType: \"front\",\n    fpsLimit: Number.POSITIVE_INFINITY,\n};\n\nconst createNotAttachedError = (message: string) =>\n    new Error(`${message}. This CameraKitSource is not attached to a CameraKitSession.`);\n\n/**\n * When creating a {@link CameraKitSource}, passing a CameraKitSourceSubscriber allows logic to implemented which will\n * run whenever that source is attached/detached from a CameraKitSession.\n *\n * @category Rendering\n */\nexport interface CameraKitSourceSubscriber {\n    readonly onAttach?: (\n        source: CameraKitSource,\n        lensCore: LensCoreModule,\n        reportError: (error: Error) => void\n    ) => void | Promise<void>;\n    readonly onDetach?: (reportError: (error: Error) => void) => void | Promise<void>;\n}\n\n/** @category Rendering */\nexport type CameraKitDeviceInfo = {\n    cameraType: \"front\" | \"back\";\n    fpsLimit: number;\n};\n\nexport type CameraKitSourceInfo = Pick<\n    UseMediaElementInput,\n    \"media\" | \"replayTrackingData\" | \"useManualFrameProcessing\"\n>;\n\n/** @category Rendering */\nexport type CameraKitSourceOptions<T = {}> = Partial<T> & Partial<CameraKitDeviceInfo>;\n\n/**\n * This general-purpose class represents a source of media for a {@link CameraKitSession}.\n *\n * When an instance is passed to {@link CameraKitSession.setSource | CameraKitSession.setSource}, it will be \"attached\"\n * to the session. Later it may be \"detached\" from the session.\n *\n * Passing a {@link CameraKitSourceSubscriber} to the constructor allows callers to specify behavior\n * that will occur when the source is attached and detached. This can be used to e.g. update the render size.\n *\n * @category Rendering\n */\nexport class CameraKitSource {\n    private lensCore?: LensCoreModule;\n    private readonly deviceInfo: CameraKitDeviceInfo;\n\n    constructor(\n        private readonly sourceInfo: CameraKitSourceInfo,\n        private readonly subscriber: CameraKitSourceSubscriber = {},\n        deviceInfo: Partial<CameraKitDeviceInfo> = {}\n    ) {\n        this.deviceInfo = { ...defaultDeviceInfo, ...deviceInfo };\n    }\n\n    /**\n     * Called by {@link CameraKitSession} when this source is set as that session's source.\n     *\n     * @param lensCore\n     * @param reportError Calling this function will report an error back to the session.\n     * @returns Rejects if any calls to LensCore or CameraKitSource.subscriber.onAttach fail.\n     * @internal\n     */\n    async attach(lensCore: LensCoreModule, reportError: (error: Error) => void): Promise<void> {\n        if (this.lensCore) {\n            throw new Error(\n                \"Cannot attach. This CameraKitCustomSource has already been attached to \" +\n                    \"a CameraKitSession. To re-attach, create a copy of this CameraKitCustomSource.\"\n            );\n        }\n\n        this.lensCore = lensCore;\n\n        await new Promise((onSuccess, onFailure) => {\n            lensCore.useMediaElement({\n                autoplayNewMedia: false,\n                autoplayPreviewCanvas: false,\n                media: this.sourceInfo.media,\n                pauseExistingMedia: false,\n                replayTrackingData: this.sourceInfo.replayTrackingData,\n                requestWebcam: false,\n                startOnFrontCamera: this.deviceInfo.cameraType === \"front\",\n                useManualFrameProcessing: this.sourceInfo.useManualFrameProcessing,\n                onSuccess,\n                onFailure,\n            });\n        });\n\n        await new Promise<void>((onSuccess, onFailure) => {\n            // LensCore uses 0 to remove the limit.\n            const fps = this.deviceInfo.fpsLimit < Number.POSITIVE_INFINITY ? this.deviceInfo.fpsLimit : 0;\n            lensCore.setFPSLimit({ fps, onSuccess, onFailure });\n        });\n\n        if (this.subscriber.onAttach) await this.subscriber.onAttach(this, lensCore, reportError);\n    }\n\n    /**\n     * Make a copy of the source, sharing the same {@link CameraKitSourceSubscriber}.\n     *\n     * @param deviceInfo Optionally provide new device info for the copy (e.g. to change the camera type).\n     * @returns The new {@link CameraKitSource}\n     */\n    copy(deviceInfo: Partial<CameraKitDeviceInfo> = {}): CameraKitSource {\n        return new CameraKitSource(this.sourceInfo, this.subscriber, { ...this.deviceInfo, ...deviceInfo });\n    }\n\n    /**\n     * Called by {@link CameraKitSession} when it must remove this source.\n     *\n     * @param reportError Calling this function will report an error back to the session.\n     * @returns\n     * @internal\n     */\n    detach(reportError: (error: Error) => void): void | Promise<void> {\n        if (!this.lensCore) return Promise.reject(createNotAttachedError(\"Cannot detach\"));\n        if (this.subscriber.onDetach) return this.subscriber.onDetach(reportError);\n    }\n\n    /**\n     * Set the resolution used to render this source.\n     *\n     * It’s important to distinguish render size from display size. The size at which the output canvases are displayed\n     * on a web page is determined by the CSS of the page. It is distinct from the size at which LensCore renders\n     * Lenses. Performance is dominated by render size, while any display scaling can most often be thought of as free.\n     *\n     * If greater performance is required, a smaller render size may boost frame-rate. It does come at a cost, including\n     * loss of accuracy in various tracking and computer-vision algorithms (since they'll be operating on fewer pixels).\n     *\n     * The size of the Live and Capture {@link RenderTarget} is always the same.\n     *\n     * @todo Currently it's only valid to call `setRenderSize` after `CameraKitSession.play` has been called. This\n     * constraint should be removed, so callers don't have to understand the underlying LensCore state machine.\n     *\n     * @param width pixels\n     * @param height pixels\n     * @returns Promise resolves when the render size has been successfully updated.\n     */\n    @validate\n    setRenderSize(width: number, height: number): Promise<void> {\n        return new Promise((onSuccess, onFailure) => {\n            if (!this.lensCore) return onFailure(createNotAttachedError(\"Cannot setRenderSize\"));\n            const target = { width, height };\n            this.lensCore.setRenderSize({ mode: \"explicit\", target, onSuccess, onFailure });\n        });\n    }\n\n    /**\n     * Apply a 2D transformation to the source (e.g. translation, rotation, scale).\n     *\n     * @param transform Specifies the 3x3 matrix describing the transformation.\n     */\n    @validate\n    setTransform(transform: Transform2D): Promise<void> {\n        return new Promise((onSuccess, onFailure) => {\n            if (!this.lensCore) return onFailure(createNotAttachedError(\"Cannot setTransform\"));\n            const matrix = new Float32Array(transform.matrix);\n            this.lensCore.setInputTransform({ matrix, onSuccess, onFailure });\n        });\n    }\n}\n"]}

package/lib/media-sources/FunctionSource.d.ts

@@ -0,0 +1,30 @@
+import { CameraKitSource, CameraKitSourceOptions } from "./CameraKitSource";
+/** @internal */
+export declare type FrameFormat = "rgb" | "yuv" | "nv12";
+/** @internal */
+export interface FrameInput {
+    format?: FrameFormat;
+    imageData: ImageData;
+    timestampMillis: number;
+}
+/** @internal */
+export interface FrameOutput {
+    live: ImageData;
+    capture: ImageData;
+}
+/** @internal */
+export interface MediaSourceFunction {
+    (render: (frame: FrameInput) => Promise<FrameOutput>): Promise<void>;
+}
+/**
+ * Creates a {@link CameraKitSource} from a function which provides per-frame pixel data to CameraKit.
+ *
+ * @param sourceFunction This function will be called in a requestAnimationFrame loop. Each time it is called, it is
+ * passed a `render` function. It may call `render` and CameraKit will process the pixel data passed to `render` and
+ * return a Promise of the processed pixels (along with rendering them to the normal output canvases).
+ * @param options
+ * @param options.cameraType By default we set this to 'front', which is the camera type most Lenses expect.
+ *
+ * @internal
+ */
+export declare const createFunctionSource: (sourceFunction: MediaSourceFunction, options?: Omit<CameraKitSourceOptions, "fpsLimit">) => CameraKitSource;

package/lib/media-sources/FunctionSource.js

@@ -0,0 +1,132 @@
+import { __awaiter } from "tslib";
+import { CameraKitSource } from "./CameraKitSource";
+const getYUVImageData = (canvas, lensCore) => __awaiter(void 0, void 0, void 0, function* () {
+    const { width, height } = canvas;
+    // A YUV buffer has lower-res UV channels, so the total number of bytes works out like so:
+    const outputBuffer = new ArrayBuffer((width * height * 3) / 2);
+    yield new Promise((onSuccess, onFailure) => {
+        lensCore.imageToYuvBuffer({ image: canvas, width, height, outputBuffer, onSuccess, onFailure });
+    });
+    const pixels = new Uint8ClampedArray(outputBuffer);
+    return new ImageData(pixels, width, height);
+});
+const getRGBImageData = (output, imageReader2D) => {
+    if (imageReader2D === null)
+        return new ImageData(0, 0);
+    imageReader2D.drawImage(output, 0, 0);
+    return imageReader2D.getImageData(0, 0, output.width, output.height);
+};
+const getImageBitmap = (imageData, format) => __awaiter(void 0, void 0, void 0, function* () {
+    switch (format) {
+        case "nv12":
+        case "yuv":
+            if (!window.VideoFrame)
+                return Promise.reject(new Error(`Cannot process frame. ImageData in ${format} ` + `is not supported by this browser.`));
+            const frame = new VideoFrame(imageData.data.buffer, {
+                format: "NV12",
+                codedWidth: imageData.width,
+                codedHeight: imageData.height,
+                timestamp: 0,
+            });
+            return createImageBitmap(frame);
+        case "rgb":
+            return createImageBitmap(imageData);
+    }
+});
+/**
+ * Creates a {@link CameraKitSource} from a function which provides per-frame pixel data to CameraKit.
+ *
+ * @param sourceFunction This function will be called in a requestAnimationFrame loop. Each time it is called, it is
+ * passed a `render` function. It may call `render` and CameraKit will process the pixel data passed to `render` and
+ * return a Promise of the processed pixels (along with rendering them to the normal output canvases).
+ * @param options
+ * @param options.cameraType By default we set this to 'front', which is the camera type most Lenses expect.
+ *
+ * @internal
+ */
+export const createFunctionSource = (sourceFunction, options = {}) => {
+    let width = 0;
+    let height = 0;
+    let shouldProcessFrame = true;
+    // We require an auxiliary canvas that we can use to read back pixel data (unless we're in YUV mode, in which case
+    // we use LensCore to convert between formats and we don't need this canvas).
+    const imageReaderCanvas = document.createElement("canvas");
+    const imageReader2D = imageReaderCanvas.getContext("2d");
+    const subscriber = {
+        onAttach: (source, lensCore, reportError) => {
+            const outputs = lensCore.getOutputCanvases();
+            const output = {
+                live: outputs[lensCore.CanvasType.Preview.value],
+                capture: outputs[lensCore.CanvasType.Capture.value],
+            };
+            const processFrame = (source, lensCore, reportError) => requestAnimationFrame(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                if (!shouldProcessFrame)
+                    return;
+                try {
+                    yield sourceFunction(({ format, imageData, timestampMillis }) => {
+                        const frameOutput = new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+                            const inputFrame = yield getImageBitmap(imageData, format !== null && format !== void 0 ? format : "rgb");
+                            if (inputFrame.width !== width || inputFrame.height !== height) {
+                                width = imageReaderCanvas.width = inputFrame.width;
+                                height = imageReaderCanvas.height = inputFrame.height;
+                                // We don't await this promise, because we want to continue to process frames and
+                                // let LensCore manage the concurrency between setting resolution and processing a
+                                // frame.
+                                source.setRenderSize(width, height);
+                            }
+                            lensCore.processFrame({
+                                inputFrame,
+                                timestampMillis,
+                                onSuccess: () => __awaiter(void 0, void 0, void 0, function* () {
+                                    // Closing releases graphics resources associated with the frame, now that is
+                                    // has been processed.
+                                    inputFrame.close();
+                                    switch (format !== null && format !== void 0 ? format : "rgb") {
+                                        case "nv12":
+                                        case "yuv":
+                                            const [live, capture] = yield Promise.all([
+                                                getYUVImageData(output.live, lensCore),
+                                                getYUVImageData(output.capture, lensCore),
+                                            ]).catch((error) => {
+                                                reject(error);
+                                                return [undefined, undefined];
+                                            });
+                                            // if either of these is undefined, we'll have already rejected
+                                            // the promise, so we can return.
+                                            if (!live || !capture)
+                                                return;
+                                            return resolve({ live, capture });
+                                        case "rgb":
+                                            return resolve({
+                                                live: getRGBImageData(output.live, imageReader2D),
+                                                capture: getRGBImageData(output.capture, imageReader2D),
+                                            });
+                                    }
+                                }),
+                                onFailure: (error) => {
+                                    inputFrame.close();
+                                    reject(error);
+                                },
+                            });
+                        }));
+                        // Even if there's an error processing the frame, we do want to attempt to process the next
+                        // frame. We expect `sourceFunction` to handle a rejected `frameOutput` Promise.
+                        frameOutput.finally(() => processFrame(source, lensCore, reportError));
+                        return frameOutput;
+                    });
+                }
+                catch (error) {
+                    reportError(new Error("Failure to process frame, which was not handled by the provided " +
+                        `MediaSourceFunction ${(_a = sourceFunction.name) !== null && _a !== void 0 ? _a : "anonymous"}.`, { cause: error }));
+                }
+            }));
+            processFrame(source, lensCore, reportError);
+        },
+        onDetach: () => {
+            shouldProcessFrame = false;
+        },
+    };
+    return new CameraKitSource({ useManualFrameProcessing: true }, subscriber, options);
+};
+//# sourceMappingURL=FunctionSource.js.map