@snap/camera-kit 0.7.0

package/lib/lens/LensRepository.js

@@ -0,0 +1,239 @@
+import { __awaiter, __decorate, __metadata, __param } from "tslib";
+import { guard, validate } from "../common/validate";
+import { isArrayOfType, isSafeString, isSafeStringArray, isString, isUndefined } from "../common/typeguards";
+import { Injectable } from "../dependency-injection/Injectable";
+import { cameraKitServiceFetchHandlerFactory } from "../handlers/cameraKitServiceFetchHandlerFactory";
+import { defaultFetchHandlerFactory } from "../handlers/defaultFetchHandler";
+import { lensSourcesFactory } from "../extensions/LensSources";
+import { createRequestStateEmittingHandler } from "../handlers/requestStateEmittingHandler";
+import { HandlerChainBuilder } from "../handlers/HandlerChainBuilder";
+import { createArrayBufferParsingHandler } from "../handlers/arrayBufferParsingHandler";
+import { LensAssetManifestItem_RequestTiming } from "../generated-proto/pb_schema/camera_kit/v3/lens";
+import { getLogger } from "../logger/logger";
+import { errorLoggingDecorator } from "../logger/errorLoggingDecorator";
+import { isLensArray, toPublicLens } from "./Lens";
+import { retrieveCameraKitLens, retrieveCameraKitLensGroup } from "./lensHttpUtil";
+import { decodeEnvelopes } from "./lensEnvelopeUtil";
+import { lensAssetRepositoryFactory } from "./assets/LensAssetRepository";
+const logger = getLogger("LensRepository");
+const log = errorLoggingDecorator(logger);
+const assetTimingMap = {
+    required: LensAssetManifestItem_RequestTiming.REQUIRED,
+    onDemand: LensAssetManifestItem_RequestTiming.ON_DEMAND,
+};
+function isAssetTiming(value) {
+    return isString(value) && assetTimingMap.hasOwnProperty(value);
+}
+function isOptionalAssetTimingArray(value) {
+    return isUndefined(value) || isArrayOfType(isAssetTiming, value);
+}
+/**
+ * The LensRepository is used to query for lenses from specific lens groups, or for a lens with a specific ID.
+ *
+ * Lens groups are configured in the CameraKit Portal -- that's where you'll find lens group IDs and lens IDs.
+ *
+ * Lenses must be loaded by the LensRepository before they can be applied to a {@link CameraKitSession}.
+ *
+ * @example
+ * ```ts
+ * const cameraKit = await bootstrapCameraKit(options)
+ * const session = await cameraKit.createSession()
+ * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)
+ * session.applyLens(lens)
+ * ```
+ *
+ * @category Lenses
+ */
+export class LensRepository {
+    /** @internal */
+    constructor(lensMetadataFetchHandler, lensFetchHandler, lensSources, lensAssetRepository) {
+        this.lensMetadataFetchHandler = lensMetadataFetchHandler;
+        this.lensFetchHandler = lensFetchHandler;
+        this.lensSources = lensSources;
+        this.lensAssetRepository = lensAssetRepository;
+        this.metadataCache = new Map();
+        this.binariesCache = new Map();
+    }
+    /**
+     * Retrieve a single Lens.
+     *
+     * @param lensId Desired Lens's unique ID. Can be found in the CameraKit Portal.
+     * @param groupId The ID of a group containing the desired Lens. Can be found in the CameraKit Portal.
+     * @returns Resolves with the desired Lens, or rejects if an error occurred (including a missing Lens).
+     */
+    loadLens(lensId, groupId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const envelopes = yield this.lensSources.retrieveLenses({ lensId, groupId });
+            let lens;
+            if (envelopes) {
+                lens = decodeEnvelopes(envelopes)[0];
+                if (!lens) {
+                    throw new Error("Expected non-empty envelope");
+                }
+            }
+            else {
+                lens = yield retrieveCameraKitLens(this.lensMetadataFetchHandler, lensId, groupId);
+            }
+            this.metadataCache.set(lens.id, lens);
+            return toPublicLens(lens);
+        });
+    }
+    /**
+     * Retrieve the Lenses contained in a list of Lens Groups.
+     *
+     * This may result in multiple requests to retrieve Lens data (e.g. one per desired group). If any constituent
+     * requests fail, those errors will be reported in the response – but the returned Promise will not be rejected. Any
+     * Lenses which could be successfully retrieved will be available in the response.
+     *
+     * @param groupIds A list of Lens Group IDs. Can be found in the CameraKit Portal.
+     * @returns Resolves with a flattened list of all lenses in the desired groups. If any errors occurred during the
+     * query operation, these will be included in a separate list. If errors are present, the list of Lenses may not
+     * contain all the Lenses from the desired groups.
+     */
+    loadLensGroups(groupIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = yield Promise.all(groupIds.map((groupId) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const envelopes = yield this.lensSources.retrieveLenses({ groupId });
+                    const lenses = envelopes
+                        ? decodeEnvelopes(envelopes)
+                        : yield retrieveCameraKitLensGroup(this.lensMetadataFetchHandler, groupId);
+                    lenses.forEach((lens) => this.metadataCache.set(lens.id, lens));
+                    return lenses.map(toPublicLens);
+                }
+                catch (error) {
+                    logger.error(new Error(`Failed to load lens group ${groupId}`, { cause: error }));
+                    return error;
+                }
+            })));
+            const errors = [];
+            const lenses = [];
+            responses.forEach((response) => (Array.isArray(response) ? lenses.push(...response) : errors.push(response)));
+            return { errors, lenses };
+        });
+    }
+    /**
+     * Loads and caches lens content and dependencies to reduce latency when {@link CameraKitSession.applyLens} is later
+     * called to apply the lens. This is an in-memory cache, it will not be persisted across page loads.
+     *
+     * This may useful if the application A) knows which lenses will be applied and B) has some opportunity to call
+     * this method before a lens is applied. For example, if the user must perform some other actions before lenses
+     * become active, this might be a good opportunity to cache lenses to improve applyLens latency.
+     *
+     * @example
+     * ```ts
+     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)
+     * await cameraKit.lensRepository.cacheLensContent([lens])
+     *
+     * // sometime later -- this call will use the cached lens content, making lens application faster.
+     * await cameraKitSession.applyLens(lens)
+     * ```
+     *
+     * @param lenses Array of lenses to cache in memory.
+     * @param assetTimingsToCache Lenses specify certain required assets that are necessary for the lens to render, and
+     * other assets which may be needed by the lens. By default this method will cache all of those assets, but this
+     * behavior can be modified to only load the required assets, only the "onDemand" assets, or neither (by passing
+     * an empty array).
+     */
+    cacheLensContent(lenses, assetTimingsToCache = ["required", "onDemand"]) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetTimingsToLoad = assetTimingsToCache.map((timing) => assetTimingMap[timing]);
+            yield Promise.all(lenses.map((lens) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const { lensBuffer } = yield this.getLensContent(lens);
+                    // Safety: getLensContent() call above ensures metadata to exist
+                    const { content } = this.metadataCache.get(lens.id);
+                    this.binariesCache.set(lens.id, lensBuffer);
+                    yield this.lensAssetRepository.cacheAssets(content.assetManifest, lens, assetTimingsToLoad);
+                }
+                catch (e) {
+                    logger.warn(new Error(`Failed to cache lens ${lens.id}.`, { cause: e }));
+                }
+            })));
+        });
+    }
+    /**
+     * Returns loaded Lens metadata if available.
+     */
+    getLensMetadata(lensId) {
+        return this.metadataCache.get(lensId);
+    }
+    /**
+     * Removes Lens content from the in-memory cache.
+     */
+    removeCachedLenses(lenses) {
+        lenses.forEach((lens) => this.binariesCache.delete(lens.id));
+    }
+    /**
+     * Fetches lens content and assets. This may come from the cache, otherwise network requests will be made.
+     *
+     * @internal
+     */
+    getLensContent(lens) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { content } = (_a = this.metadataCache.get(lens.id)) !== null && _a !== void 0 ? _a : {};
+            if (!content) {
+                throw new Error(`Cannot find metadata for lens ${lens.id}.`);
+            }
+            const cachedLensBuffer = this.binariesCache.get(lens.id);
+            if (cachedLensBuffer) {
+                return {
+                    lensBuffer: cachedLensBuffer,
+                    lensChecksum: content.lnsSha256,
+                };
+            }
+            // Load required lens assets and the lens itself in parallel. We count both toward lens download time.
+            const [lensBuffer] = yield this.lensFetchHandler([
+                // TODO: remove force-cache once https://jira.sc-corp.net/browse/CAMKIT-3671 is addressed
+                new Request(content.lnsUrlBolt, { cache: "force-cache" }),
+                {
+                    requestType: "lens_content",
+                    lensId: lens.id,
+                },
+            ]);
+            return { lensBuffer, lensChecksum: content.lnsSha256 };
+        });
+    }
+}
+__decorate([
+    validate,
+    log,
+    __param(0, guard(isSafeString)),
+    __param(1, guard(isSafeString)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], LensRepository.prototype, "loadLens", null);
+__decorate([
+    validate,
+    log,
+    __param(0, guard(isSafeStringArray)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], LensRepository.prototype, "loadLensGroups", null);
+__decorate([
+    validate,
+    log,
+    __param(0, guard(isLensArray)),
+    __param(1, guard(isOptionalAssetTimingArray)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Array]),
+    __metadata("design:returntype", Promise)
+], LensRepository.prototype, "cacheLensContent", null);
+/**
+ * @internal
+ */
+export const lensRepositoryFactory = Injectable("LensRepository", [
+    cameraKitServiceFetchHandlerFactory.token,
+    defaultFetchHandlerFactory.token,
+    lensSourcesFactory.token,
+    lensAssetRepositoryFactory.token,
+], (lensMetadataFetchHandler, defaultFetchHandler, lensSources, lensAssetRepository) => {
+    const lensFetchHandler = new HandlerChainBuilder(defaultFetchHandler)
+        .map(createRequestStateEmittingHandler())
+        .map(createArrayBufferParsingHandler()).handler;
+    return new LensRepository(lensMetadataFetchHandler, lensFetchHandler, lensSources, lensAssetRepository);
+});
+//# sourceMappingURL=LensRepository.js.map

package/lib/lens/LensRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LensRepository.js","sourceRoot":"","sources":["../../src/lens/LensRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import { guard, validate } from \"../common/validate\";\nimport { isArrayOfType, isSafeString, isSafeStringArray, isString, isUndefined } from \"../common/typeguards\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport { cameraKitServiceFetchHandlerFactory } from \"../handlers/cameraKitServiceFetchHandlerFactory\";\nimport { defaultFetchHandlerFactory, FetchHandler } from \"../handlers/defaultFetchHandler\";\nimport { LensSources, lensSourcesFactory } from \"../extensions/LensSources\";\nimport { createRequestStateEmittingHandler } from \"../handlers/requestStateEmittingHandler\";\nimport { LensDownloadDimensions } from \"../metrics/reporters/reportLensAndAssetDownload\";\nimport { Handler, HandlerChainBuilder } from \"../handlers/HandlerChainBuilder\";\nimport { createArrayBufferParsingHandler } from \"../handlers/arrayBufferParsingHandler\";\nimport { LensAssetManifestItem_RequestTiming } from \"../generated-proto/pb_schema/camera_kit/v3/lens\";\nimport { getLogger } from \"../logger/logger\";\nimport { errorLoggingDecorator } from \"../logger/errorLoggingDecorator\";\nimport { isLensArray, Lens, LensProto, toPublicLens } from \"./Lens\";\nimport { retrieveCameraKitLens, retrieveCameraKitLensGroup } from \"./lensHttpUtil\";\nimport { decodeEnvelopes } from \"./lensEnvelopeUtil\";\nimport { LensAssetRepository, lensAssetRepositoryFactory } from \"./assets/LensAssetRepository\";\n\nconst logger = getLogger(\"LensRepository\");\nconst log = errorLoggingDecorator(logger);\n\ntype LensFetchHandler = Handler<\n    [RequestInfo, LensDownloadDimensions],\n    [ArrayBuffer, Response],\n    RequestInit | undefined\n>;\n\nconst assetTimingMap = {\n    required: LensAssetManifestItem_RequestTiming.REQUIRED,\n    onDemand: LensAssetManifestItem_RequestTiming.ON_DEMAND,\n};\n\nfunction isAssetTiming(value: unknown): value is AssetTiming {\n    return isString(value) && assetTimingMap.hasOwnProperty(value);\n}\n\nfunction isOptionalAssetTimingArray(value: unknown): value is undefined | AssetTiming[] {\n    return isUndefined(value) || isArrayOfType(isAssetTiming, value);\n}\n\n/**\n * Lens assets are included in a manifest, and each will indicate when that asset will be used by the lens.\n *\n * Assets can have the following timing values:\n * - `required`: the lens will definitely request this asset immediately when the lens is applied.\n * - `onDemand`: the lens may request this asset at some time while the lens is applied.\n *\n * Depending on the use-case, an application may want to cache both required and onDemand assets for\n * a particular lens, or may decide to only cache required assets (or cache no assets).\n *\n * @category Lenses\n */\nexport type AssetTiming = keyof typeof assetTimingMap;\n\nexport interface LensGroupsQueryResponse {\n    errors: Error[];\n    lenses: Lens[];\n}\n\nexport interface LensBinary {\n    lensBuffer: ArrayBuffer;\n    lensChecksum: string;\n}\n\n/**\n * The LensRepository is used to query for lenses from specific lens groups, or for a lens with a specific ID.\n *\n * Lens groups are configured in the CameraKit Portal -- that's where you'll find lens group IDs and lens IDs.\n *\n * Lenses must be loaded by the LensRepository before they can be applied to a {@link CameraKitSession}.\n *\n * @example\n * ```ts\n * const cameraKit = await bootstrapCameraKit(options)\n * const session = await cameraKit.createSession()\n * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)\n * session.applyLens(lens)\n * ```\n *\n * @category Lenses\n */\nexport class LensRepository {\n    private readonly metadataCache = new Map<string, LensProto>();\n    private readonly binariesCache = new Map<string, ArrayBuffer>();\n\n    /** @internal */\n    constructor(\n        private readonly lensMetadataFetchHandler: FetchHandler,\n        private readonly lensFetchHandler: LensFetchHandler,\n        private readonly lensSources: LensSources,\n        private readonly lensAssetRepository: LensAssetRepository\n    ) {}\n\n    /**\n     * Retrieve a single Lens.\n     *\n     * @param lensId Desired Lens's unique ID. Can be found in the CameraKit Portal.\n     * @param groupId The ID of a group containing the desired Lens. Can be found in the CameraKit Portal.\n     * @returns Resolves with the desired Lens, or rejects if an error occurred (including a missing Lens).\n     */\n    @validate\n    @log\n    async loadLens(@guard(isSafeString) lensId: string, @guard(isSafeString) groupId: string): Promise<Lens> {\n        const envelopes = await this.lensSources.retrieveLenses({ lensId, groupId });\n        let lens: LensProto;\n        if (envelopes) {\n            lens = decodeEnvelopes(envelopes)[0];\n            if (!lens) {\n                throw new Error(\"Expected non-empty envelope\");\n            }\n        } else {\n            lens = await retrieveCameraKitLens(this.lensMetadataFetchHandler, lensId, groupId);\n        }\n        this.metadataCache.set(lens.id, lens);\n        return toPublicLens(lens);\n    }\n\n    /**\n     * Retrieve the Lenses contained in a list of Lens Groups.\n     *\n     * This may result in multiple requests to retrieve Lens data (e.g. one per desired group). If any constituent\n     * requests fail, those errors will be reported in the response – but the returned Promise will not be rejected. Any\n     * Lenses which could be successfully retrieved will be available in the response.\n     *\n     * @param groupIds A list of Lens Group IDs. Can be found in the CameraKit Portal.\n     * @returns Resolves with a flattened list of all lenses in the desired groups. If any errors occurred during the\n     * query operation, these will be included in a separate list. If errors are present, the list of Lenses may not\n     * contain all the Lenses from the desired groups.\n     */\n    @validate\n    @log\n    async loadLensGroups(@guard(isSafeStringArray) groupIds: string[]): Promise<LensGroupsQueryResponse> {\n        const responses = await Promise.all(\n            groupIds.map(async (groupId) => {\n                try {\n                    const envelopes = await this.lensSources.retrieveLenses({ groupId });\n                    const lenses = envelopes\n                        ? decodeEnvelopes(envelopes)\n                        : await retrieveCameraKitLensGroup(this.lensMetadataFetchHandler, groupId);\n                    lenses.forEach((lens) => this.metadataCache.set(lens.id, lens));\n                    return lenses.map(toPublicLens);\n                } catch (error) {\n                    logger.error(new Error(`Failed to load lens group ${groupId}`, { cause: error }));\n                    return error as Error;\n                }\n            })\n        );\n\n        const errors: Error[] = [];\n        const lenses: Lens[] = [];\n        responses.forEach((response) => (Array.isArray(response) ? lenses.push(...response) : errors.push(response)));\n        return { errors, lenses };\n    }\n\n    /**\n     * Loads and caches lens content and dependencies to reduce latency when {@link CameraKitSession.applyLens} is later\n     * called to apply the lens. This is an in-memory cache, it will not be persisted across page loads.\n     *\n     * This may useful if the application A) knows which lenses will be applied and B) has some opportunity to call\n     * this method before a lens is applied. For example, if the user must perform some other actions before lenses\n     * become active, this might be a good opportunity to cache lenses to improve applyLens latency.\n     *\n     * @example\n     * ```ts\n     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)\n     * await cameraKit.lensRepository.cacheLensContent([lens])\n     *\n     * // sometime later -- this call will use the cached lens content, making lens application faster.\n     * await cameraKitSession.applyLens(lens)\n     * ```\n     *\n     * @param lenses Array of lenses to cache in memory.\n     * @param assetTimingsToCache Lenses specify certain required assets that are necessary for the lens to render, and\n     * other assets which may be needed by the lens. By default this method will cache all of those assets, but this\n     * behavior can be modified to only load the required assets, only the \"onDemand\" assets, or neither (by passing\n     * an empty array).\n     */\n    @validate\n    @log\n    async cacheLensContent(\n        @guard(isLensArray) lenses: Lens[],\n        @guard(isOptionalAssetTimingArray) assetTimingsToCache: AssetTiming[] = [\"required\", \"onDemand\"]\n    ) {\n        const assetTimingsToLoad = assetTimingsToCache.map((timing) => assetTimingMap[timing]);\n        await Promise.all(\n            lenses.map(async (lens) => {\n                try {\n                    const { lensBuffer } = await this.getLensContent(lens);\n                    // Safety: getLensContent() call above ensures metadata to exist\n                    const { content } = this.metadataCache.get(lens.id)!;\n                    this.binariesCache.set(lens.id, lensBuffer);\n                    await this.lensAssetRepository.cacheAssets(content!.assetManifest, lens, assetTimingsToLoad);\n                } catch (e) {\n                    logger.warn(new Error(`Failed to cache lens ${lens.id}.`, { cause: e }));\n                }\n            })\n        );\n    }\n\n    /**\n     * Returns loaded Lens metadata if available.\n     */\n    getLensMetadata(lensId: string): LensProto | undefined {\n        return this.metadataCache.get(lensId);\n    }\n\n    /**\n     * Removes Lens content from the in-memory cache.\n     */\n    removeCachedLenses(lenses: Lens[]) {\n        lenses.forEach((lens) => this.binariesCache.delete(lens.id));\n    }\n\n    /**\n     * Fetches lens content and assets. This may come from the cache, otherwise network requests will be made.\n     *\n     * @internal\n     */\n    async getLensContent(lens: Lens): Promise<LensBinary> {\n        const { content } = this.metadataCache.get(lens.id) ?? {};\n        if (!content) {\n            throw new Error(`Cannot find metadata for lens ${lens.id}.`);\n        }\n\n        const cachedLensBuffer = this.binariesCache.get(lens.id);\n        if (cachedLensBuffer) {\n            return {\n                lensBuffer: cachedLensBuffer,\n                lensChecksum: content.lnsSha256,\n            };\n        }\n\n        // Load required lens assets and the lens itself in parallel. We count both toward lens download time.\n        const [lensBuffer] = await this.lensFetchHandler([\n            // TODO: remove force-cache once https://jira.sc-corp.net/browse/CAMKIT-3671 is addressed\n            new Request(content.lnsUrlBolt, { cache: \"force-cache\" }),\n            {\n                requestType: \"lens_content\",\n                lensId: lens.id,\n            },\n        ]);\n        return { lensBuffer, lensChecksum: content.lnsSha256 };\n    }\n}\n\n/**\n * @internal\n */\nexport const lensRepositoryFactory = Injectable(\n    \"LensRepository\",\n    [\n        cameraKitServiceFetchHandlerFactory.token,\n        defaultFetchHandlerFactory.token,\n        lensSourcesFactory.token,\n        lensAssetRepositoryFactory.token,\n    ] as const,\n    (\n        lensMetadataFetchHandler: FetchHandler,\n        defaultFetchHandler: FetchHandler,\n        lensSources: LensSources,\n        lensAssetRepository: LensAssetRepository\n    ) => {\n        const lensFetchHandler = new HandlerChainBuilder(defaultFetchHandler)\n            .map(createRequestStateEmittingHandler<LensDownloadDimensions>())\n            .map(createArrayBufferParsingHandler()).handler;\n        return new LensRepository(lensMetadataFetchHandler, lensFetchHandler, lensSources, lensAssetRepository);\n    }\n);\n"]}

package/lib/lens/assets/LensAssetRepository.d.ts

@@ -0,0 +1,66 @@
+import { Lens } from "../Lens";
+import { LensAssetManifestItem, LensAssetManifestItem_RequestTiming, LensAssetManifestItem_Type } from "../../generated-proto/pb_schema/camera_kit/v3/lens";
+import { AssetDescriptor, AssetType, LensCoreModule } from "../../lens-core-module";
+import { MetricsEventTarget } from "../../metrics/metricsEventTarget";
+export declare function mapManfiestItemToAssetType(lensCore: LensCoreModule, type: LensAssetManifestItem_Type): AssetType;
+export interface Asset {
+    assetId: string;
+    assetBuffer: ArrayBuffer;
+    assetType: AssetType;
+    assetChecksum: string | undefined;
+}
+export declare type AssetResponse = ArrayBuffer | {
+    data: ArrayBuffer;
+    checksum?: string;
+};
+/**
+ * An AssetLoader is used to retrieve assets. A separate loader may be defined to retrieve different asset types.
+ *
+ * @category Lenses
+ */
+export declare type AssetLoader = (asset: AssetDescriptor, lens?: Lens, assetManifest?: LensAssetManifestItem[]) => Promise<AssetResponse> | AssetResponse;
+/**
+ * Registers a remote asset provider function with a given instance of LensCore, and uses a provided mapping of asset
+ * types to loading functions to acquire remote asset data and pass it to LensCore.
+ *
+ * *Note:* LensCoreModule.initialize must be called on the desired LensCoreModule instance **prior** to passing it
+ * to the LensAssetProvider constructor. If this class is instantiated with a LensCoreModule that has not been
+ * initialized, the registry of the asset provider function will fail silently and no remote assets will be loaded.
+ */
+export declare class LensAssetRepository {
+    private readonly lensCore;
+    private readonly assetLoaders;
+    private readonly metrics;
+    private readonly cachedAssetKeys;
+    constructor(lensCore: LensCoreModule, assetLoaders: Map<AssetType, [keyof LensCoreModule["AssetType"], AssetLoader]>, metrics: MetricsEventTarget);
+    /**
+     * Caches lens assets defined in asset manifest.
+     *
+     * @param assetManifest Lens asset manifest.
+     * @param lens Lens to cache assets of.
+     * @param assetTimings Optionally specifies what assets to cache. By default, on-demand assets are not cached.
+     * @returns Promise rejects if any required assets could not be loaded – if this occurs, it's very likely the Lens
+     * with this manifest will not function.
+     */
+    cacheAssets(assetManifest: LensAssetManifestItem[], lens: Lens, assetTimings?: LensAssetManifestItem_RequestTiming[]): Promise<void>;
+    /**
+     * Calls the correct asset loader to fetch the asset's data,
+     * depending on the requested asset's type and provides that to LensCore.
+     */
+    loadAsset(assetDescriptor: AssetDescriptor, lens: Lens | undefined, assetManifest: LensAssetManifestItem[] | undefined): Promise<void>;
+    /**
+     * Downloads and caches assets if applicable. Does nothing for assets that are already in cache.
+     * @param assetDescriptors Asset ID and type pairs.
+     * @param lens Lens to load assets for.
+     * @param assetManifest Lens asset manifest.
+     */
+    private cacheAssetsByDescriptor;
+}
+/**
+ * @internal
+ */
+export declare const lensAssetRepositoryFactory: {
+    (args_0: LensCoreModule, args_1: AssetLoader, args_2: AssetLoader, args_3: AssetLoader, args_4: MetricsEventTarget): LensAssetRepository;
+    token: "lensAssetRepository";
+    dependencies: readonly ["lensCore", "deviceDependentAssetLoader", "remoteMediaAssetLoader", "staticAssetLoader", "metricsEventTarget"];
+};

package/lib/lens/assets/LensAssetRepository.js

@@ -0,0 +1,179 @@
+import { __awaiter } from "tslib";
+import { ensureError } from "../../common/errorHelpers";
+import { Injectable } from "../../dependency-injection/Injectable";
+import { dispatchRequestCompleted, dispatchRequestErrored, dispatchRequestStarted, } from "../../handlers/requestStateEmittingHandler";
+import { LensAssetManifestItem_RequestTiming, LensAssetManifestItem_Type, } from "../../generated-proto/pb_schema/camera_kit/v3/lens";
+import { lensCoreFactory } from "../../lens-core-module";
+import { assertUnreachable } from "../../common/assertions";
+import { getLogger } from "../../logger/logger";
+import { metricsEventTargetFactory } from "../../metrics/metricsEventTarget";
+import { TypedCustomEvent } from "../../events/TypedCustomEvent";
+import { deviceDependentAssetLoaderFactory } from "./deviceDependentAssetLoader";
+import { remoteMediaAssetLoaderFactory } from "./remoteMediaAssetLoaderFactory";
+import { staticAssetLoaderFactory } from "./staticAssetLoader";
+const logger = getLogger("LensAssetRepository");
+/**
+ * Computes cache key for asset ID and loader type pair.
+ * @param asset Asset ID and loader type pair.
+ * @returns Cache key.
+ */
+function getCacheKey(asset) {
+    return `${asset.assetId}_${asset.assetType.value}`;
+}
+export function mapManfiestItemToAssetType(lensCore, type) {
+    switch (type) {
+        case LensAssetManifestItem_Type.ASSET:
+            return lensCore.AssetType.Static;
+        case LensAssetManifestItem_Type.DEVICE_DEPENDENT_ASSET_UNSET:
+        case LensAssetManifestItem_Type.UNRECOGNIZED:
+            return lensCore.AssetType.DeviceDependent;
+        default:
+            return assertUnreachable(type);
+    }
+}
+/**
+ * Registers a remote asset provider function with a given instance of LensCore, and uses a provided mapping of asset
+ * types to loading functions to acquire remote asset data and pass it to LensCore.
+ *
+ * *Note:* LensCoreModule.initialize must be called on the desired LensCoreModule instance **prior** to passing it
+ * to the LensAssetProvider constructor. If this class is instantiated with a LensCoreModule that has not been
+ * initialized, the registry of the asset provider function will fail silently and no remote assets will be loaded.
+ */
+export class LensAssetRepository {
+    constructor(lensCore, assetLoaders, metrics) {
+        this.lensCore = lensCore;
+        this.assetLoaders = assetLoaders;
+        this.metrics = metrics;
+        this.cachedAssetKeys = new Set();
+    }
+    /**
+     * Caches lens assets defined in asset manifest.
+     *
+     * @param assetManifest Lens asset manifest.
+     * @param lens Lens to cache assets of.
+     * @param assetTimings Optionally specifies what assets to cache. By default, on-demand assets are not cached.
+     * @returns Promise rejects if any required assets could not be loaded – if this occurs, it's very likely the Lens
+     * with this manifest will not function.
+     */
+    cacheAssets(assetManifest, lens, assetTimings = [LensAssetManifestItem_RequestTiming.REQUIRED]) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetTimingsToPreload = new Set([
+                // That is a bad naming, but PRELOAD_UNSET actually means
+                // that an asset has to be preloaded
+                LensAssetManifestItem_RequestTiming.PRELOAD_UNSET,
+                ...assetTimings,
+            ]);
+            const assetDescriptors = assetManifest
+                .filter((asset) => {
+                return assetTimingsToPreload.has(asset.requestTiming);
+            })
+                .map(({ id, type }) => ({
+                assetId: id,
+                assetType: mapManfiestItemToAssetType(this.lensCore, type),
+            }));
+            if (assetDescriptors.length) {
+                // When preloading, we *do* want load failures to reject Promise.all (assets listed in the manifest
+                // are known to be hard requirements of the lens).
+                return this.cacheAssetsByDescriptor(assetDescriptors, lens, assetManifest);
+            }
+        });
+    }
+    /**
+     * Calls the correct asset loader to fetch the asset's data,
+     * depending on the requested asset's type and provides that to LensCore.
+     */
+    loadAsset(assetDescriptor, lens, assetManifest) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { assetId, assetType } = assetDescriptor;
+            const [assetTypeName, assetLoader] = (_a = this.assetLoaders.get(assetType)) !== null && _a !== void 0 ? _a : [];
+            const safeAssetTypeName = assetTypeName !== null && assetTypeName !== void 0 ? assetTypeName : "unknown";
+            const dimensions = {
+                requestType: "asset",
+                assetId: assetId,
+                assetType: safeAssetTypeName,
+                lensId: (_b = lens === null || lens === void 0 ? void 0 : lens.id) !== null && _b !== void 0 ? _b : "unknown",
+            };
+            const { requestId } = dispatchRequestStarted({ dimensions });
+            try {
+                if (!assetLoader) {
+                    throw new Error(`Cannot get asset "${assetId}". Asset type "${safeAssetTypeName}" is not supported.`);
+                }
+                const assetResponse = yield assetLoader(assetDescriptor, lens, assetManifest);
+                const assetBuffer = "data" in assetResponse ? assetResponse.data : assetResponse;
+                const assetChecksum = "checksum" in assetResponse ? assetResponse.checksum : undefined;
+                if (assetBuffer.byteLength === 0) {
+                    throw new Error(`Got empty response for asset "${assetId}" from "${safeAssetTypeName}" loader.`);
+                }
+                dispatchRequestCompleted({ requestId, dimensions, status: 200, sizeByte: assetBuffer.byteLength });
+                this.lensCore.provideRemoteAssetsResponse({
+                    assetId,
+                    assetBuffer,
+                    assetType,
+                    assetChecksum,
+                    onFailure: (reason) => {
+                        const lensCoreError = ensureError(reason);
+                        if (/validation failed/.test(lensCoreError.message)) {
+                            this.metrics.dispatchEvent(new TypedCustomEvent("assetValidationFailed", {
+                                name: "assetValidationFailed",
+                                assetId,
+                            }));
+                        }
+                        logger.warn(new Error(`Failed to provide lens asset "${assetId}".`, { cause: lensCoreError }));
+                    },
+                });
+            }
+            catch (error) {
+                const wrappedError = new Error(`Failed to load lens asset "${assetId}".`, { cause: error });
+                dispatchRequestErrored({ requestId, dimensions, error: wrappedError });
+                throw wrappedError;
+            }
+        });
+    }
+    /**
+     * Downloads and caches assets if applicable. Does nothing for assets that are already in cache.
+     * @param assetDescriptors Asset ID and type pairs.
+     * @param lens Lens to load assets for.
+     * @param assetManifest Lens asset manifest.
+     */
+    cacheAssetsByDescriptor(assetDescriptors, lens, assetManifest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(assetDescriptors
+                .filter((assetDescriptors) => !this.cachedAssetKeys.has(getCacheKey(assetDescriptors)))
+                .map((assetDescriptor) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    // NOTE: we allow concurrent cache request to download the same asset more than once,
+                    // because that is better than skipping second request when the firs one fails.
+                    // In future we could improve concurretn logic with observables as part of
+                    // https://jira.sc-corp.net/browse/CAMKIT-3931
+                    yield this.loadAsset(assetDescriptor, lens, assetManifest);
+                    this.cachedAssetKeys.add(getCacheKey(assetDescriptor));
+                }
+                catch (error) {
+                    const { assetId, assetType } = assetDescriptor;
+                    const [assetTypeName] = (_a = this.assetLoaders.get(assetType)) !== null && _a !== void 0 ? _a : [];
+                    logger.warn(new Error(`Failed to cache asset "${assetId}" of type "${assetTypeName !== null && assetTypeName !== void 0 ? assetTypeName : assetType.value}".`, { cause: error }));
+                }
+            })));
+        });
+    }
+}
+/**
+ * @internal
+ */
+export const lensAssetRepositoryFactory = Injectable("lensAssetRepository", [
+    lensCoreFactory.token,
+    deviceDependentAssetLoaderFactory.token,
+    remoteMediaAssetLoaderFactory.token,
+    staticAssetLoaderFactory.token,
+    metricsEventTargetFactory.token,
+], (lensCore, deviceDependentAssetLoader, remoteMediaAssetLoader, staticAssetLoader, metrics) => new LensAssetRepository(lensCore, new Map([
+    [lensCore.AssetType.DeviceDependent, ["DeviceDependent", deviceDependentAssetLoader]],
+    [lensCore.AssetType.RemoteMediaByUrl, ["RemoteMediaByUrl", remoteMediaAssetLoader]],
+    // URL type is deprecated and was introduced before RemoteMediaByURL
+    // however, there are some lenses still using it so we need to support it
+    [lensCore.AssetType.URL, ["URL", remoteMediaAssetLoader]],
+    [lensCore.AssetType.Static, ["Static", staticAssetLoader]],
+]), metrics));
+//# sourceMappingURL=LensAssetRepository.js.map

package/lib/lens/assets/LensAssetRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LensAssetRepository.js","sourceRoot":"","sources":["../../../src/lens/assets/LensAssetRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import { ensureError } from \"../../common/errorHelpers\";\nimport { Injectable } from \"../../dependency-injection/Injectable\";\nimport { Lens } from \"../Lens\";\nimport {\n    dispatchRequestCompleted,\n    dispatchRequestErrored,\n    dispatchRequestStarted,\n} from \"../../handlers/requestStateEmittingHandler\";\nimport { AssetDownloadDimensions } from \"../../metrics/reporters/reportLensAndAssetDownload\";\nimport {\n    LensAssetManifestItem,\n    LensAssetManifestItem_RequestTiming,\n    LensAssetManifestItem_Type,\n} from \"../../generated-proto/pb_schema/camera_kit/v3/lens\";\nimport { AssetDescriptor, AssetType, lensCoreFactory, LensCoreModule } from \"../../lens-core-module\";\nimport { assertUnreachable } from \"../../common/assertions\";\nimport { getLogger } from \"../../logger/logger\";\nimport { MetricsEventTarget, metricsEventTargetFactory } from \"../../metrics/metricsEventTarget\";\nimport { TypedCustomEvent } from \"../../events/TypedCustomEvent\";\nimport { deviceDependentAssetLoaderFactory } from \"./deviceDependentAssetLoader\";\nimport { remoteMediaAssetLoaderFactory } from \"./remoteMediaAssetLoaderFactory\";\nimport { staticAssetLoaderFactory } from \"./staticAssetLoader\";\n\nconst logger = getLogger(\"LensAssetRepository\");\n\n/**\n * Computes cache key for asset ID and loader type pair.\n * @param asset Asset ID and loader type pair.\n * @returns Cache key.\n */\nfunction getCacheKey(asset: AssetDescriptor) {\n    return `${asset.assetId}_${asset.assetType.value}`;\n}\n\nexport function mapManfiestItemToAssetType(lensCore: LensCoreModule, type: LensAssetManifestItem_Type): AssetType {\n    switch (type) {\n        case LensAssetManifestItem_Type.ASSET:\n            return lensCore.AssetType.Static;\n        case LensAssetManifestItem_Type.DEVICE_DEPENDENT_ASSET_UNSET:\n        case LensAssetManifestItem_Type.UNRECOGNIZED:\n            return lensCore.AssetType.DeviceDependent;\n        default:\n            return assertUnreachable(type);\n    }\n}\n\nexport interface Asset {\n    assetId: string;\n    assetBuffer: ArrayBuffer;\n    assetType: AssetType;\n    assetChecksum: string | undefined;\n}\n\nexport type AssetResponse =\n    | ArrayBuffer\n    | {\n          data: ArrayBuffer;\n          checksum?: string;\n      };\n\n/**\n * An AssetLoader is used to retrieve assets. A separate loader may be defined to retrieve different asset types.\n *\n * @category Lenses\n */\nexport type AssetLoader = (\n    asset: AssetDescriptor,\n    lens?: Lens,\n    assetManifest?: LensAssetManifestItem[]\n) => Promise<AssetResponse> | AssetResponse;\n\n/**\n * Registers a remote asset provider function with a given instance of LensCore, and uses a provided mapping of asset\n * types to loading functions to acquire remote asset data and pass it to LensCore.\n *\n * *Note:* LensCoreModule.initialize must be called on the desired LensCoreModule instance **prior** to passing it\n * to the LensAssetProvider constructor. If this class is instantiated with a LensCoreModule that has not been\n * initialized, the registry of the asset provider function will fail silently and no remote assets will be loaded.\n */\nexport class LensAssetRepository {\n    private readonly cachedAssetKeys = new Set<string>();\n\n    constructor(\n        private readonly lensCore: LensCoreModule,\n        private readonly assetLoaders: Map<AssetType, [keyof LensCoreModule[\"AssetType\"], AssetLoader]>,\n        private readonly metrics: MetricsEventTarget\n    ) {}\n\n    /**\n     * Caches lens assets defined in asset manifest.\n     *\n     * @param assetManifest Lens asset manifest.\n     * @param lens Lens to cache assets of.\n     * @param assetTimings Optionally specifies what assets to cache. By default, on-demand assets are not cached.\n     * @returns Promise rejects if any required assets could not be loaded – if this occurs, it's very likely the Lens\n     * with this manifest will not function.\n     */\n    public async cacheAssets(\n        assetManifest: LensAssetManifestItem[],\n        lens: Lens,\n        assetTimings: LensAssetManifestItem_RequestTiming[] = [LensAssetManifestItem_RequestTiming.REQUIRED]\n    ): Promise<void> {\n        const assetTimingsToPreload = new Set([\n            // That is a bad naming, but PRELOAD_UNSET actually means\n            // that an asset has to be preloaded\n            LensAssetManifestItem_RequestTiming.PRELOAD_UNSET,\n            ...assetTimings,\n        ]);\n        const assetDescriptors = assetManifest\n            .filter((asset) => {\n                return assetTimingsToPreload.has(asset.requestTiming);\n            })\n            .map(({ id, type }) => ({\n                assetId: id,\n                assetType: mapManfiestItemToAssetType(this.lensCore, type),\n            }));\n\n        if (assetDescriptors.length) {\n            // When preloading, we *do* want load failures to reject Promise.all (assets listed in the manifest\n            // are known to be hard requirements of the lens).\n            return this.cacheAssetsByDescriptor(assetDescriptors, lens, assetManifest);\n        }\n    }\n\n    /**\n     * Calls the correct asset loader to fetch the asset's data,\n     * depending on the requested asset's type and provides that to LensCore.\n     */\n    public async loadAsset(\n        assetDescriptor: AssetDescriptor,\n        lens: Lens | undefined,\n        assetManifest: LensAssetManifestItem[] | undefined\n    ): Promise<void> {\n        const { assetId, assetType } = assetDescriptor;\n        const [assetTypeName, assetLoader] = this.assetLoaders.get(assetType) ?? [];\n        const safeAssetTypeName = assetTypeName ?? \"unknown\";\n        const dimensions: AssetDownloadDimensions = {\n            requestType: \"asset\",\n            assetId: assetId,\n            assetType: safeAssetTypeName,\n            lensId: lens?.id ?? \"unknown\",\n        };\n\n        const { requestId } = dispatchRequestStarted({ dimensions });\n\n        try {\n            if (!assetLoader) {\n                throw new Error(`Cannot get asset \"${assetId}\". Asset type \"${safeAssetTypeName}\" is not supported.`);\n            }\n\n            const assetResponse = await assetLoader(assetDescriptor, lens, assetManifest);\n            const assetBuffer = \"data\" in assetResponse ? assetResponse.data : assetResponse;\n            const assetChecksum = \"checksum\" in assetResponse ? assetResponse.checksum : undefined;\n\n            if (assetBuffer.byteLength === 0) {\n                throw new Error(`Got empty response for asset \"${assetId}\" from \"${safeAssetTypeName}\" loader.`);\n            }\n\n            dispatchRequestCompleted({ requestId, dimensions, status: 200, sizeByte: assetBuffer.byteLength });\n\n            this.lensCore.provideRemoteAssetsResponse({\n                assetId,\n                assetBuffer,\n                assetType,\n                assetChecksum,\n                onFailure: (reason) => {\n                    const lensCoreError = ensureError(reason);\n                    if (/validation failed/.test(lensCoreError.message)) {\n                        this.metrics.dispatchEvent(\n                            new TypedCustomEvent(\"assetValidationFailed\", {\n                                name: \"assetValidationFailed\",\n                                assetId,\n                            })\n                        );\n                    }\n                    logger.warn(new Error(`Failed to provide lens asset \"${assetId}\".`, { cause: lensCoreError }));\n                },\n            });\n        } catch (error) {\n            const wrappedError = new Error(`Failed to load lens asset \"${assetId}\".`, { cause: error });\n            dispatchRequestErrored({ requestId, dimensions, error: wrappedError });\n            throw wrappedError;\n        }\n    }\n\n    /**\n     * Downloads and caches assets if applicable. Does nothing for assets that are already in cache.\n     * @param assetDescriptors Asset ID and type pairs.\n     * @param lens Lens to load assets for.\n     * @param assetManifest Lens asset manifest.\n     */\n    private async cacheAssetsByDescriptor(\n        assetDescriptors: AssetDescriptor[],\n        lens: Lens,\n        assetManifest: LensAssetManifestItem[] | undefined\n    ): Promise<void> {\n        await Promise.all(\n            assetDescriptors\n                .filter((assetDescriptors) => !this.cachedAssetKeys.has(getCacheKey(assetDescriptors)))\n                .map(async (assetDescriptor) => {\n                    try {\n                        // NOTE: we allow concurrent cache request to download the same asset more than once,\n                        // because that is better than skipping second request when the firs one fails.\n                        // In future we could improve concurretn logic with observables as part of\n                        // https://jira.sc-corp.net/browse/CAMKIT-3931\n                        await this.loadAsset(assetDescriptor, lens, assetManifest);\n                        this.cachedAssetKeys.add(getCacheKey(assetDescriptor));\n                    } catch (error) {\n                        const { assetId, assetType } = assetDescriptor;\n                        const [assetTypeName] = this.assetLoaders.get(assetType) ?? [];\n                        logger.warn(\n                            new Error(\n                                `Failed to cache asset \"${assetId}\" of type \"${assetTypeName ?? assetType.value}\".`,\n                                { cause: error }\n                            )\n                        );\n                    }\n                })\n        );\n    }\n}\n\n/**\n * @internal\n */\nexport const lensAssetRepositoryFactory = Injectable(\n    \"lensAssetRepository\",\n    [\n        lensCoreFactory.token,\n        deviceDependentAssetLoaderFactory.token,\n        remoteMediaAssetLoaderFactory.token,\n        staticAssetLoaderFactory.token,\n        metricsEventTargetFactory.token,\n    ] as const,\n    (\n        lensCore: LensCoreModule,\n        deviceDependentAssetLoader: AssetLoader,\n        remoteMediaAssetLoader: AssetLoader,\n        staticAssetLoader: AssetLoader,\n        metrics: MetricsEventTarget\n    ) =>\n        new LensAssetRepository(\n            lensCore,\n            new Map([\n                [lensCore.AssetType.DeviceDependent, [\"DeviceDependent\", deviceDependentAssetLoader]],\n                [lensCore.AssetType.RemoteMediaByUrl, [\"RemoteMediaByUrl\", remoteMediaAssetLoader]],\n                // URL type is deprecated and was introduced before RemoteMediaByURL\n                // however, there are some lenses still using it so we need to support it\n                [lensCore.AssetType.URL, [\"URL\", remoteMediaAssetLoader]],\n                [lensCore.AssetType.Static, [\"Static\", staticAssetLoader]],\n            ]),\n            metrics\n        )\n);\n"]}

package/lib/lens/assets/LensAssetsProvider.d.ts

@@ -0,0 +1,21 @@
+import { LensCoreModule } from "../../lens-core-module";
+import { MakeTaggedBusinessEvent } from "../../metrics/businessEventsReporter";
+import { LensRepository } from "../LensRepository";
+import { LensAssetRepository } from "./LensAssetRepository";
+/**
+ * The AssetValidationFailed metric reports every time we handle an asset checksum validation failure.
+ */
+export declare type AssetValidationFailed = MakeTaggedBusinessEvent<"assetValidationFailed">;
+/**
+ * Registers a remote asset provider function with a given instance of LensCore.
+ *
+ * *Note:* LensCoreModule.initialize must be called on the desired LensCoreModule instance **prior** to passing it
+ * to the LensAssetsProvider constructor. If this class is instantiated with a LensCoreModule that has not been
+ * initialized, the registry of the asset provider function will fail silently and no remote assets will be loaded.
+ * @internal
+ */
+export declare const registerLensAssetsProvider: {
+    (args_0: LensCoreModule, args_1: LensRepository, args_2: LensAssetRepository): void;
+    token: "registerLensAssetsProvider";
+    dependencies: readonly ["lensCore", "LensRepository", "lensAssetRepository"];
+};

package/lib/lens/assets/LensAssetsProvider.js

@@ -0,0 +1,41 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "../../dependency-injection/Injectable";
+import { lensAssetError } from "../../namedErrors";
+import { lensCoreFactory } from "../../lens-core-module";
+import { getLogger } from "../../logger/logger";
+import { toPublicLens } from "../Lens";
+import { lensRepositoryFactory } from "../LensRepository";
+import { lensAssetRepositoryFactory } from "./LensAssetRepository";
+const logger = getLogger("LensAssetProvider");
+/**
+ * Registers a remote asset provider function with a given instance of LensCore.
+ *
+ * *Note:* LensCoreModule.initialize must be called on the desired LensCoreModule instance **prior** to passing it
+ * to the LensAssetsProvider constructor. If this class is instantiated with a LensCoreModule that has not been
+ * initialized, the registry of the asset provider function will fail silently and no remote assets will be loaded.
+ * @internal
+ */
+export const registerLensAssetsProvider = Injectable("registerLensAssetsProvider", [lensCoreFactory.token, lensRepositoryFactory.token, lensAssetRepositoryFactory.token], (lensCore, lensRepository, lensAssetRepository) => {
+    lensCore.setRemoteAssetsProvider((assetDescriptor) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        // Fetch an asset and provide it to LensCore. If fetching the asset fails we give LensCore
+        // an empty response (which it may handle in a variety of ways, e.g. retry, gracefully
+        // degrade lens behavior, throw error) and then reject.
+        const { assetId, assetType, effectId } = assetDescriptor;
+        try {
+            const lens = effectId ? lensRepository.getLensMetadata(effectId) : undefined;
+            yield lensAssetRepository.loadAsset(assetDescriptor, lens && toPublicLens(lens), (_a = lens === null || lens === void 0 ? void 0 : lens.content) === null || _a === void 0 ? void 0 : _a.assetManifest);
+        }
+        catch (error) {
+            // if an error occurs, LensCore handles things in different ways
+            // depending on the active lens. It might: 1) retry, 2) gracefully degrade lens behavior,
+            // 3) lens JS might throw, which will be passed to the exceptionHandler we register with LensCore.
+            lensCore.provideRemoteAssetsResponse({
+                assetId,
+                assetType,
+            });
+            logger.error(lensAssetError(`Unable to handle lens asset "${assetId}" request.`, error));
+        }
+    }));
+});
+//# sourceMappingURL=LensAssetsProvider.js.map

package/lib/lens/assets/LensAssetsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LensAssetsProvider.js","sourceRoot":"","sources":["../../../src/lens/assets/LensAssetsProvider.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAkB,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAkB,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAuB,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExF,MAAM,MAAM,GAAG,SAAS,CAAC,mBAAmB,CAAC,CAAC;AAO9C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAChD,4BAA4B,EAC5B,CAAC,eAAe,CAAC,KAAK,EAAE,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,CAAC,KAAK,CAAU,EAC/F,CAAC,QAAwB,EAAE,cAA8B,EAAE,mBAAwC,EAAE,EAAE;IACnG,QAAQ,CAAC,uBAAuB,CAAC,CAAO,eAAe,EAAE,EAAE;;QACvD,0FAA0F;QAC1F,sFAAsF;QACtF,uDAAuD;QACvD,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,eAAe,CAAC;QACzD,IAAI;YACA,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC7E,MAAM,mBAAmB,CAAC,SAAS,CAC/B,eAAe,EACf,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC,EAC1B,MAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,OAAO,0CAAE,aAAa,CAC/B,CAAC;SACL;QAAC,OAAO,KAAK,EAAE;YACZ,gEAAgE;YAChE,yFAAyF;YACzF,kGAAkG;YAClG,QAAQ,CAAC,2BAA2B,CAAC;gBACjC,OAAO;gBACP,SAAS;aACZ,CAAC,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,gCAAgC,OAAO,YAAY,EAAE,KAAK,CAAC,CAAC,CAAC;SAC5F;IACL,CAAC,CAAA,CAAC,CAAC;AACP,CAAC,CACJ,CAAC","sourcesContent":["import { Injectable } from \"../../dependency-injection/Injectable\";\nimport { lensAssetError } from \"../../namedErrors\";\nimport { lensCoreFactory, LensCoreModule } from \"../../lens-core-module\";\nimport { getLogger } from \"../../logger/logger\";\nimport { MakeTaggedBusinessEvent } from \"../../metrics/businessEventsReporter\";\nimport { toPublicLens } from \"../Lens\";\nimport { LensRepository, lensRepositoryFactory } from \"../LensRepository\";\nimport { LensAssetRepository, lensAssetRepositoryFactory } from \"./LensAssetRepository\";\n\nconst logger = getLogger(\"LensAssetProvider\");\n\n/**\n * The AssetValidationFailed metric reports every time we handle an asset checksum validation failure.\n */\nexport type AssetValidationFailed = MakeTaggedBusinessEvent<\"assetValidationFailed\">;\n\n/**\n * Registers a remote asset provider function with a given instance of LensCore.\n *\n * *Note:* LensCoreModule.initialize must be called on the desired LensCoreModule instance **prior** to passing it\n * to the LensAssetsProvider constructor. If this class is instantiated with a LensCoreModule that has not been\n * initialized, the registry of the asset provider function will fail silently and no remote assets will be loaded.\n * @internal\n */\nexport const registerLensAssetsProvider = Injectable(\n    \"registerLensAssetsProvider\",\n    [lensCoreFactory.token, lensRepositoryFactory.token, lensAssetRepositoryFactory.token] as const,\n    (lensCore: LensCoreModule, lensRepository: LensRepository, lensAssetRepository: LensAssetRepository) => {\n        lensCore.setRemoteAssetsProvider(async (assetDescriptor) => {\n            // Fetch an asset and provide it to LensCore. If fetching the asset fails we give LensCore\n            // an empty response (which it may handle in a variety of ways, e.g. retry, gracefully\n            // degrade lens behavior, throw error) and then reject.\n            const { assetId, assetType, effectId } = assetDescriptor;\n            try {\n                const lens = effectId ? lensRepository.getLensMetadata(effectId) : undefined;\n                await lensAssetRepository.loadAsset(\n                    assetDescriptor,\n                    lens && toPublicLens(lens),\n                    lens?.content?.assetManifest\n                );\n            } catch (error) {\n                // if an error occurs, LensCore handles things in different ways\n                // depending on the active lens. It might: 1) retry, 2) gracefully degrade lens behavior,\n                // 3) lens JS might throw, which will be passed to the exceptionHandler we register with LensCore.\n                lensCore.provideRemoteAssetsResponse({\n                    assetId,\n                    assetType,\n                });\n                logger.error(lensAssetError(`Unable to handle lens asset \"${assetId}\" request.`, error));\n            }\n        });\n    }\n);\n"]}