@snap/camera-kit 0.17.0 → 0.18.0

package/dist/dependency-injection/RootServices.d.ts

@@ -0,0 +1,74 @@
+import type { lensRepositoryFactory } from "../lens/LensRepository";
+import type { lensCoreFactory } from "../lens-core-module/loader/lensCoreFactory";
+import type { remoteMediaAssetLoaderFactory } from "../lens/assets/remoteMediaAssetLoaderFactory";
+import type { deviceDependentAssetLoaderFactory } from "../lens/assets/deviceDependentAssetLoader";
+import type { staticAssetLoaderFactory } from "../lens/assets/staticAssetLoader";
+import type { defaultFetchHandlerFactory } from "../handlers/defaultFetchHandler";
+import type { cameraKitServiceFetchHandlerFactory } from "../handlers/cameraKitServiceFetchHandlerFactory";
+import type { createCameraKitConfigurationFactory } from "../configuration";
+import type { externalMetricsSubjectFactory, metricsClientFactory } from "../clients/metricsClient";
+import type { LensCore } from "../lens-core-module/lensCore";
+import type { metricsEventTargetFactory } from "../metrics/metricsEventTarget";
+import type { lensSourcesFactory } from "../lens/LensSource";
+import type { uriHandlersFactory } from "../extensions/UriHandlers";
+import type { lensPersistenceStoreFactory } from "../lens/LensPersistenceStore";
+import type { cofHandlerFactory } from "../remote-configuration/cofHandler";
+import type { remoteConfigurationFactory } from "../remote-configuration/remoteConfiguration";
+import type { lensAssetRepositoryFactory } from "../lens/assets/LensAssetRepository";
+import type { legalStateFactory } from "../legal/legalState";
+import type { legalPromptFactory } from "../legal/legalPrompt";
+import type { logEntriesFactory } from "../logger/logEntries";
+import type { reportGlobalException } from "../metrics/reporters/reportGlobalException";
+import type { requestStateEventTargetFactory } from "../handlers/requestStateEmittingHandler";
+import type { lensesClientFactory } from "../clients/lensesClient";
+import type { pageVisibilityFactory } from "../common/pageVisibility";
+import type { remoteApiServicesFactory } from "../extensions/RemoteApiServices";
+import type { grpcHandlerFactory } from "../clients/grpcHandler";
+import type { ServicesFromInjectables } from "./types";
+/**
+ * All services available to be customized by client app.
+ */
+export type PublicServices = ServicesFromInjectables<[
+    ReturnType<typeof createCameraKitConfigurationFactory>,
+    typeof defaultFetchHandlerFactory,
+    typeof remoteMediaAssetLoaderFactory,
+    typeof lensSourcesFactory,
+    typeof remoteApiServicesFactory,
+    typeof uriHandlersFactory,
+    typeof externalMetricsSubjectFactory
+]>;
+/**
+ * Define all the Services contained in CameraKit's root dependency injection container.
+ *
+ * Note: we do end up defining this list of Services twice (once here to create the type, once when we actually
+ * create the Container inside the `bootstrapCameraKit` function). We could avoid doing this and just infer the
+ * RootContainer type from the constructed container – but since we can only do that *inside* `bootstrapCameraKit`, it
+ * makes it more awkward to provide a type for the `provide` user-supplied function (or use the type elsewhere, like in
+ * CameraKitSession).
+ *
+ * There may be a way to eliminate this extra boilerplate, but for now it's required in order to present a cleaner
+ * `bootstrapCameraKit` API to applications.
+ */
+export type RootServices = {
+    [lensCoreFactory.token]: LensCore;
+} & PublicServices & ServicesFromInjectables<[
+    typeof pageVisibilityFactory,
+    typeof metricsEventTargetFactory,
+    typeof requestStateEventTargetFactory,
+    typeof cameraKitServiceFetchHandlerFactory,
+    typeof grpcHandlerFactory,
+    typeof lensesClientFactory,
+    typeof cofHandlerFactory,
+    typeof remoteConfigurationFactory,
+    typeof lensRepositoryFactory,
+    typeof lensPersistenceStoreFactory,
+    typeof metricsClientFactory,
+    typeof lensAssetRepositoryFactory,
+    typeof deviceDependentAssetLoaderFactory,
+    typeof staticAssetLoaderFactory,
+    typeof legalStateFactory,
+    typeof legalPromptFactory,
+    typeof logEntriesFactory,
+    typeof reportGlobalException
+]>;
+//# sourceMappingURL=RootServices.d.ts.map

package/dist/dependency-injection/RootServices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RootServices.d.ts","sourceRoot":"","sources":["../../src/dependency-injection/RootServices.ts"],"names":[],"mappings":"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"}

package/dist/dependency-injection/RootServices.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RootServices.js.map

package/dist/dependency-injection/RootServices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RootServices.js","sourceRoot":"","sources":["../../src/dependency-injection/RootServices.ts"],"names":[],"mappings":"","sourcesContent":["import type { lensRepositoryFactory } from \"../lens/LensRepository\";\nimport type { lensCoreFactory } from \"../lens-core-module/loader/lensCoreFactory\";\nimport type { remoteMediaAssetLoaderFactory } from \"../lens/assets/remoteMediaAssetLoaderFactory\";\nimport type { deviceDependentAssetLoaderFactory } from \"../lens/assets/deviceDependentAssetLoader\";\nimport type { staticAssetLoaderFactory } from \"../lens/assets/staticAssetLoader\";\nimport type { defaultFetchHandlerFactory } from \"../handlers/defaultFetchHandler\";\nimport type { cameraKitServiceFetchHandlerFactory } from \"../handlers/cameraKitServiceFetchHandlerFactory\";\nimport type { createCameraKitConfigurationFactory } from \"../configuration\";\nimport type { externalMetricsSubjectFactory, metricsClientFactory } from \"../clients/metricsClient\";\nimport type { LensCore } from \"../lens-core-module/lensCore\";\nimport type { metricsEventTargetFactory } from \"../metrics/metricsEventTarget\";\nimport type { lensSourcesFactory } from \"../lens/LensSource\";\nimport type { uriHandlersFactory } from \"../extensions/UriHandlers\";\nimport type { lensPersistenceStoreFactory } from \"../lens/LensPersistenceStore\";\nimport type { cofHandlerFactory } from \"../remote-configuration/cofHandler\";\nimport type { remoteConfigurationFactory } from \"../remote-configuration/remoteConfiguration\";\nimport type { lensAssetRepositoryFactory } from \"../lens/assets/LensAssetRepository\";\nimport type { legalStateFactory } from \"../legal/legalState\";\nimport type { legalPromptFactory } from \"../legal/legalPrompt\";\nimport type { logEntriesFactory } from \"../logger/logEntries\";\nimport type { reportGlobalException } from \"../metrics/reporters/reportGlobalException\";\nimport type { requestStateEventTargetFactory } from \"../handlers/requestStateEmittingHandler\";\nimport type { lensesClientFactory } from \"../clients/lensesClient\";\nimport type { pageVisibilityFactory } from \"../common/pageVisibility\";\nimport type { remoteApiServicesFactory } from \"../extensions/RemoteApiServices\";\nimport type { grpcHandlerFactory } from \"../clients/grpcHandler\";\nimport type { ServicesFromInjectables } from \"./types\";\n\n/**\n * All services available to be customized by client app.\n */\nexport type PublicServices = ServicesFromInjectables<\n    [\n        ReturnType<typeof createCameraKitConfigurationFactory>,\n        typeof defaultFetchHandlerFactory,\n        typeof remoteMediaAssetLoaderFactory,\n        typeof lensSourcesFactory,\n        typeof remoteApiServicesFactory,\n        typeof uriHandlersFactory,\n        typeof externalMetricsSubjectFactory\n    ]\n>;\n\n/**\n * Define all the Services contained in CameraKit's root dependency injection container.\n *\n * Note: we do end up defining this list of Services twice (once here to create the type, once when we actually\n * create the Container inside the `bootstrapCameraKit` function). We could avoid doing this and just infer the\n * RootContainer type from the constructed container – but since we can only do that *inside* `bootstrapCameraKit`, it\n * makes it more awkward to provide a type for the `provide` user-supplied function (or use the type elsewhere, like in\n * CameraKitSession).\n *\n * There may be a way to eliminate this extra boilerplate, but for now it's required in order to present a cleaner\n * `bootstrapCameraKit` API to applications.\n */\nexport type RootServices = {\n    // bootstrapCameraKit replaces the lensCoreFactory token's value with the resolved LensCore (rather than the\n    // Promise of the LensCore), so we need to do the same re-mapping here.\n    [lensCoreFactory.token]: LensCore;\n} & PublicServices &\n    ServicesFromInjectables<\n        [\n            typeof pageVisibilityFactory,\n            typeof metricsEventTargetFactory,\n            typeof requestStateEventTargetFactory,\n            typeof cameraKitServiceFetchHandlerFactory,\n            typeof grpcHandlerFactory,\n            typeof lensesClientFactory,\n            typeof cofHandlerFactory,\n            typeof remoteConfigurationFactory,\n            typeof lensRepositoryFactory,\n            typeof lensPersistenceStoreFactory,\n            typeof metricsClientFactory,\n            typeof lensAssetRepositoryFactory,\n            typeof deviceDependentAssetLoaderFactory,\n            typeof staticAssetLoaderFactory,\n            typeof legalStateFactory,\n            typeof legalPromptFactory,\n            typeof logEntriesFactory,\n            typeof reportGlobalException\n        ]\n    >;\n"]}

package/dist/dependency-injection/types.d.ts

@@ -0,0 +1,57 @@
+import type { Container, ContainerToken } from "./Container";
+type AsTuple<T> = T extends readonly any[] ? T : never;
+type CorrespondingService<Services, Token extends ValidTokens<Services>> = Token extends ContainerToken ? Container<Services> : Token extends keyof Services ? Services[Token] : never;
+/**
+ * Given a Services object, the valid Tokens are simply the keys of that object or the special Container Token.
+ */
+export type ValidTokens<Services> = ContainerToken | keyof Services;
+/**
+ * Given Services, map from a list of Tokens to a list of Service types.
+ */
+export type CorrespondingServices<Services, Tokens extends readonly ValidTokens<Services>[]> = {
+    [K in keyof Tokens]: Tokens[K] extends ValidTokens<Services> ? CorrespondingService<Services, Tokens[K]> : never;
+};
+/**
+ * A valid InjectableFunction is one that can be successfully called, given some Services, to return a new Service. That
+ * is, it must satisfy two conditions:
+ *
+ *   1. All the Tokens it specifies as dependencies are valid given the Services (i.e. they are either the Container
+ *   Token or keys of the Services type).
+ *   2. The function argument types correspond to the Services specified by the dependency Tokens.
+ *
+ * A InjectableFunction also includes its own key Token and dependency Tokens as metadata, so it may be resolved by
+ * Container<Services> later.
+ */
+export type InjectableFunction<Services, Tokens, Token extends string, Service> = Tokens extends readonly ValidTokens<Services>[] ? {
+    (...args: AsTuple<CorrespondingServices<Services, Tokens>>): Service;
+    token: Token;
+    dependencies: Tokens;
+} : never;
+export type AnyInjectable = InjectableFunction<any, readonly string[], string, any>;
+export type ServicesFromInjectables<Injectables extends readonly AnyInjectable[]> = {
+    [Name in Injectables[number]["token"]]: ReturnType<Extract<Injectables[number], {
+        token: Name;
+    }>>;
+};
+/**
+ * Add a Service with a Token to an existing set of Services.
+ */
+export type AddService<ParentServices, Token extends string, Service> = ParentServices extends any ? {
+    [K in keyof ParentServices | Token]: K extends keyof ParentServices ? ParentServices[K] : Service;
+} : never;
+/**
+ * Create an object type from two tuples of the same length. The first tuple contains the object keys (strings) and the
+ * second contains the value types corresponding to those keys.
+ *
+ * Ex:
+ * ```ts
+ * type FooBar = ServicesFromTokenizedParams<['foo', 'bar'], [string, number]>
+ * const foobar: FooBar = {foo: 'foo', bar: 1}
+ * const badfoobar: FooBar = {foo: 1, bar: 'bar'} // any extra, missing, or mis-typed properties raise an error.
+ * ```
+ */
+export type ServicesFromTokenizedParams<Tokens, Params> = Tokens extends readonly [] ? Params extends readonly [] ? {} : never : Tokens extends readonly [infer Token, ...infer RemainingTokens] ? Params extends readonly [infer Param, ...infer RemainingParams] ? Tokens["length"] extends Params["length"] ? Token extends ContainerToken ? Param extends Container<infer S> ? S & ServicesFromTokenizedParams<RemainingTokens, RemainingParams> : never : Token extends string ? {
+    [K in Token]: Param extends Container<infer S> ? S : Param;
+} & ServicesFromTokenizedParams<RemainingTokens, RemainingParams> : never : never : never : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/dependency-injection/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dependency-injection/types.ts"],"names":[],"mappings":"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"}

package/dist/dependency-injection/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/dependency-injection/types.ts"],"names":[],"mappings":"","sourcesContent":["/* eslint-disable import/exports-last */\nimport type { Container, ContainerToken } from \"./Container\";\n\ntype AsTuple<T> = T extends readonly any[] ? T : never;\n\ntype CorrespondingService<Services, Token extends ValidTokens<Services>> = Token extends ContainerToken\n    ? Container<Services>\n    : Token extends keyof Services\n    ? Services[Token]\n    : never;\n\n/**\n * Given a Services object, the valid Tokens are simply the keys of that object or the special Container Token.\n */\nexport type ValidTokens<Services> = ContainerToken | keyof Services;\n\n/**\n * Given Services, map from a list of Tokens to a list of Service types.\n */\nexport type CorrespondingServices<Services, Tokens extends readonly ValidTokens<Services>[]> = {\n    [K in keyof Tokens]: Tokens[K] extends ValidTokens<Services> ? CorrespondingService<Services, Tokens[K]> : never;\n};\n\n/**\n * A valid InjectableFunction is one that can be successfully called, given some Services, to return a new Service. That\n * is, it must satisfy two conditions:\n *\n *   1. All the Tokens it specifies as dependencies are valid given the Services (i.e. they are either the Container\n *   Token or keys of the Services type).\n *   2. The function argument types correspond to the Services specified by the dependency Tokens.\n *\n * A InjectableFunction also includes its own key Token and dependency Tokens as metadata, so it may be resolved by\n * Container<Services> later.\n */\nexport type InjectableFunction<\n    Services,\n    Tokens,\n    Token extends string,\n    Service\n> = Tokens extends readonly ValidTokens<Services>[]\n    ? {\n          (...args: AsTuple<CorrespondingServices<Services, Tokens>>): Service;\n          token: Token;\n          dependencies: Tokens;\n      }\n    : never;\n\nexport type AnyInjectable = InjectableFunction<any, readonly string[], string, any>;\n\nexport type ServicesFromInjectables<Injectables extends readonly AnyInjectable[]> = {\n    [Name in Injectables[number][\"token\"]]: ReturnType<Extract<Injectables[number], { token: Name }>>;\n};\n\n/**\n * Add a Service with a Token to an existing set of Services.\n */\n// Using a conditional type forces TS language services to evaluate the type -- so when showing e.g. type hints, we\n// will see the mapped type instead of the AddService type alias. This produces better hints.\nexport type AddService<ParentServices, Token extends string, Service> = ParentServices extends any\n    ? // A mapped type produces better, more concise type hints than an intersection type.\n      { [K in keyof ParentServices | Token]: K extends keyof ParentServices ? ParentServices[K] : Service }\n    : never;\n\n/**\n * Create an object type from two tuples of the same length. The first tuple contains the object keys (strings) and the\n * second contains the value types corresponding to those keys.\n *\n * Ex:\n * ```ts\n * type FooBar = ServicesFromTokenizedParams<['foo', 'bar'], [string, number]>\n * const foobar: FooBar = {foo: 'foo', bar: 1}\n * const badfoobar: FooBar = {foo: 1, bar: 'bar'} // any extra, missing, or mis-typed properties raise an error.\n * ```\n */\nexport type ServicesFromTokenizedParams<Tokens, Params> = Tokens extends readonly []\n    ? Params extends readonly []\n        ? {}\n        : never\n    : Tokens extends readonly [infer Token, ...infer RemainingTokens]\n    ? Params extends readonly [infer Param, ...infer RemainingParams]\n        ? Tokens[\"length\"] extends Params[\"length\"]\n            ? Token extends ContainerToken\n                ? Param extends Container<infer S>\n                    ? S & ServicesFromTokenizedParams<RemainingTokens, RemainingParams>\n                    : never\n                : Token extends string\n                ? { [K in Token]: Param extends Container<infer S> ? S : Param } & ServicesFromTokenizedParams<\n                      RemainingTokens,\n                      RemainingParams\n                  >\n                : never\n            : never\n        : never\n    : never;\n"]}

package/dist/environment.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    PACKAGE_VERSION: string;
+};
+export default _default;
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":";;;AAAA,wBAA6C"}

package/dist/environment.js

@@ -0,0 +1,2 @@
+export default { PACKAGE_VERSION: "0.18.0" };
+//# sourceMappingURL=environment.js.map

package/dist/environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.js","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA,eAAe,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC","sourcesContent":["export default { PACKAGE_VERSION: \"0.18.0\" };\n"]}

package/dist/events/TypedCustomEvent.d.ts

@@ -0,0 +1,11 @@
+export type EventOfType<K extends string, Event extends TypedCustomEvent> = Extract<Event, TypedCustomEvent<K, any>>;
+/**
+ * This wrapper around CustomEvent provides more descriptive type information. By using this class, the `type` property
+ * of the CustomEvent will be typed as a string literal – this allows [TypedEventTarget] to provide more useful type
+ * checking of events.
+ */
+export declare class TypedCustomEvent<N extends string = string, T = any> extends CustomEvent<T> {
+    readonly type: N;
+    constructor(type: N, detail: T, eventInitDict?: Omit<CustomEventInit<T>, "detail">);
+}
+//# sourceMappingURL=TypedCustomEvent.d.ts.map

package/dist/events/TypedCustomEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedCustomEvent.d.ts","sourceRoot":"","sources":["../../src/events/TypedCustomEvent.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,SAAS,gBAAgB,IAAI,OAAO,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AAErH;;;;GAIG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,GAAG,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAKpF,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;gBACL,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,GAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAM;CAGzF"}

package/dist/events/TypedCustomEvent.js

@@ -0,0 +1,6 @@
+export class TypedCustomEvent extends CustomEvent {
+    constructor(type, detail, eventInitDict = {}) {
+        super(type, Object.assign(Object.assign({}, eventInitDict), { detail }));
+    }
+}
+//# sourceMappingURL=TypedCustomEvent.js.map

package/dist/events/TypedCustomEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedCustomEvent.js","sourceRoot":"","sources":["../../src/events/TypedCustomEvent.ts"],"names":[],"mappings":"AAOA,MAAM,OAAO,gBAAqD,SAAQ,WAAc;IAMpF,YAAY,IAAO,EAAE,MAAS,EAAE,gBAAoD,EAAE;QAClF,KAAK,CAAC,IAAI,kCAAO,aAAa,KAAE,MAAM,IAAG,CAAC;IAC9C,CAAC;CACJ","sourcesContent":["export type EventOfType<K extends string, Event extends TypedCustomEvent> = Extract<Event, TypedCustomEvent<K, any>>;\n\n/**\n * This wrapper around CustomEvent provides more descriptive type information. By using this class, the `type` property\n * of the CustomEvent will be typed as a string literal – this allows [TypedEventTarget] to provide more useful type\n * checking of events.\n */\nexport class TypedCustomEvent<N extends string = string, T = any> extends CustomEvent<T> {\n    // @ts-ignore: The compiler complains that this property \"has no initializer and is not definitely set in the\n    // constructor\" – we must rely on the superclass constructor to set this, because CustomEvent only implements a\n    // getter for type, so if we try to do `this.type = type` we get a runtime error. We do need to re-define type,\n    // though, so we can give it the specific type N instead of the less-useful string type defined by the superclass.\n    readonly type: N;\n    constructor(type: N, detail: T, eventInitDict: Omit<CustomEventInit<T>, \"detail\"> = {}) {\n        super(type, { ...eventInitDict, detail });\n    }\n}\n"]}

package/dist/events/TypedEventTarget.d.ts

@@ -0,0 +1,26 @@
+import type { EventOfType, TypedCustomEvent } from "./TypedCustomEvent";
+export type TypedEventListener<Event extends TypedCustomEvent> = (evt: Event) => void;
+export interface TypedEventListenerOptions {
+    once?: boolean;
+}
+/**
+ * Extract the generic Events type (which must extend {@link TypedCustomEvent}) from a {@link TypedEventTarget}
+ */
+export type EventsFromTarget<Target extends TypedEventTarget> = Target extends TypedEventTarget<infer Events> ? Events : never;
+/**
+ * This wrapper around EventTarget provides more descriptive type information. By using this class, calls to EventTarget
+ * methods are correctly type checked to ensure only allowed event types are used, and that events and their type
+ * strings are correctly associated.
+ *
+ * For example, when calling TypedEventTarget::addEventListener, the event passed to the callback will have the correct
+ * type corresponding to the type of event for which the listener has been added.
+ */
+export declare class TypedEventTarget<Events extends TypedCustomEvent = TypedCustomEvent> {
+    private readonly listeners;
+    private readonly options;
+    constructor();
+    addEventListener<K extends Events["type"]>(type: K, callback: TypedEventListener<EventOfType<K, Events>>, options?: TypedEventListenerOptions): void;
+    dispatchEvent(event: Events): true;
+    removeEventListener<K extends Events["type"]>(type: K, callback: TypedEventListener<EventOfType<K, Events>>): void;
+}
+//# sourceMappingURL=TypedEventTarget.d.ts.map

package/dist/events/TypedEventTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEventTarget.d.ts","sourceRoot":"","sources":["../../src/events/TypedEventTarget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAExE,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,gBAAgB,IAAI,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;AAEtF,MAAM,WAAW,yBAAyB;IACtC,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,gBAAgB,IAAI,MAAM,SAAS,gBAAgB,CAAC,MAAM,MAAM,CAAC,GACvG,MAAM,GACN,KAAK,CAAC;AAEZ;;;;;;;GAOG;AACH,qBAAa,gBAAgB,CAAC,MAAM,SAAS,gBAAgB,GAAG,gBAAgB;IAC5E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsD;IAChF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuE;;IAO/F,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EACrC,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EACpD,OAAO,CAAC,EAAE,yBAAyB,GACpC,IAAI;IAWP,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAoBlC,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI;CAUrH"}

package/dist/events/TypedEventTarget.js

@@ -0,0 +1,42 @@
+export class TypedEventTarget {
+    constructor() {
+        this.listeners = new Map();
+        this.options = new Map();
+    }
+    addEventListener(type, callback, options) {
+        var _a;
+        const listener = callback;
+        const listeners = (_a = this.listeners.get(type)) !== null && _a !== void 0 ? _a : [];
+        this.listeners.set(type, [...listeners, listener]);
+        if (options)
+            this.options.set(listener, options);
+    }
+    dispatchEvent(event) {
+        const listeners = this.listeners.get(event.type);
+        if (!listeners)
+            return true;
+        listeners.forEach((listener) => {
+            var _a;
+            const options = (_a = this.options.get(listener)) !== null && _a !== void 0 ? _a : {};
+            try {
+                listener(event);
+            }
+            catch (error) {
+                if (window)
+                    window.dispatchEvent(new CustomEvent("error", { detail: error }));
+            }
+            if (options.once)
+                this.removeEventListener(event.type, listener);
+        });
+        return true;
+    }
+    removeEventListener(type, callback) {
+        const listener = callback;
+        const listeners = this.listeners.get(type);
+        if (!listeners)
+            return;
+        this.listeners.set(type, listeners.filter((l) => l !== listener));
+        this.options.delete(listener);
+    }
+}
+//# sourceMappingURL=TypedEventTarget.js.map

package/dist/events/TypedEventTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEventTarget.js","sourceRoot":"","sources":["../../src/events/TypedEventTarget.ts"],"names":[],"mappings":"AAuBA,MAAM,OAAO,gBAAgB;IAIzB;QACI,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;IAC7B,CAAC;IAED,gBAAgB,CACZ,IAAO,EACP,QAAoD,EACpD,OAAmC;;QAMnC,MAAM,QAAQ,GAAG,QAAgD,CAAC;QAClE,MAAM,SAAS,GAAG,MAAA,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,mCAAI,EAAE,CAAC;QACjD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;QACnD,IAAI,OAAO;YAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IAED,aAAa,CAAC,KAAa;QACvB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,SAAS;YAAE,OAAO,IAAI,CAAC;QAE5B,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;;YAC3B,MAAM,OAAO,GAAG,MAAA,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,mCAAI,EAAE,CAAC;YACjD,IAAI;gBACA,QAAQ,CAAC,KAAK,CAAC,CAAC;aACnB;YAAC,OAAO,KAAK,EAAE;gBAIZ,IAAI,MAAM;oBAAE,MAAM,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;aACjF;YACD,IAAI,OAAO,CAAC,IAAI;gBAAE,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,mBAAmB,CAA2B,IAAO,EAAE,QAAoD;QACvG,MAAM,QAAQ,GAAG,QAAgD,CAAC;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,SAAS;YAAE,OAAO;QACvB,IAAI,CAAC,SAAS,CAAC,GAAG,CACd,IAAI,EACJ,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAC1C,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;CACJ","sourcesContent":["import type { EventOfType, TypedCustomEvent } from \"./TypedCustomEvent\";\n\nexport type TypedEventListener<Event extends TypedCustomEvent> = (evt: Event) => void;\n\nexport interface TypedEventListenerOptions {\n    once?: boolean;\n}\n\n/**\n * Extract the generic Events type (which must extend {@link TypedCustomEvent}) from a {@link TypedEventTarget}\n */\nexport type EventsFromTarget<Target extends TypedEventTarget> = Target extends TypedEventTarget<infer Events>\n    ? Events\n    : never;\n\n/**\n * This wrapper around EventTarget provides more descriptive type information. By using this class, calls to EventTarget\n * methods are correctly type checked to ensure only allowed event types are used, and that events and their type\n * strings are correctly associated.\n *\n * For example, when calling TypedEventTarget::addEventListener, the event passed to the callback will have the correct\n * type corresponding to the type of event for which the listener has been added.\n */\nexport class TypedEventTarget<Events extends TypedCustomEvent = TypedCustomEvent> {\n    private readonly listeners: Map<string, TypedEventListener<TypedCustomEvent>[]>;\n    private readonly options: Map<TypedEventListener<TypedCustomEvent>, TypedEventListenerOptions>;\n\n    constructor() {\n        this.listeners = new Map();\n        this.options = new Map();\n    }\n\n    addEventListener<K extends Events[\"type\"]>(\n        type: K,\n        callback: TypedEventListener<EventOfType<K, Events>>,\n        options?: TypedEventListenerOptions\n    ): void {\n        // Safety: the type in the method signature ensures the callback handles events of type K, and we use that type\n        // as the key when storing the callback – we only ever invoke callbacks obtained by mapping from that event\n        // type to the callback, so even though we store the callback with a wider type, we only ever call it with the\n        // specific event type specified by K.\n        const listener = callback as TypedEventListener<TypedCustomEvent>;\n        const listeners = this.listeners.get(type) ?? [];\n        this.listeners.set(type, [...listeners, listener]);\n        if (options) this.options.set(listener, options);\n    }\n\n    dispatchEvent(event: Events): true {\n        const listeners = this.listeners.get(event.type);\n        if (!listeners) return true;\n\n        listeners.forEach((listener) => {\n            const options = this.options.get(listener) ?? {};\n            try {\n                listener(event);\n            } catch (error) {\n                // We'll do our best to immitate native behavior, where if a listener throws an error it is caught and\n                // emitted as an error event on the window – this might be slightly different from native behavior since\n                // we have to use a CustomEvent, but it's as close as we can get.\n                if (window) window.dispatchEvent(new CustomEvent(\"error\", { detail: error }));\n            }\n            if (options.once) this.removeEventListener(event.type, listener);\n        });\n\n        return true;\n    }\n\n    removeEventListener<K extends Events[\"type\"]>(type: K, callback: TypedEventListener<EventOfType<K, Events>>): void {\n        const listener = callback as TypedEventListener<TypedCustomEvent>;\n        const listeners = this.listeners.get(type);\n        if (!listeners) return;\n        this.listeners.set(\n            type,\n            listeners.filter((l) => l !== listener)\n        );\n        this.options.delete(listener);\n    }\n}\n"]}

package/dist/events/scan.d.ts

@@ -0,0 +1,18 @@
+import type { EventOfType } from "./TypedCustomEvent";
+import { TypedCustomEvent } from "./TypedCustomEvent";
+import type { EventsFromTarget } from "./TypedEventTarget";
+import { TypedEventTarget } from "./TypedEventTarget";
+/**
+ * Each time an event is emitted, call a given accumulator function with two arguments: some state of type S and the
+ * event. The accumulator returns a new state. `scan` returns a new event emitter which emits an event each time a new
+ * state is produced by the accumulator.
+ *
+ * This can be used to implement a Redux-style state management architecture.
+ *
+ * @param seedState Some initial state, passed to the accumulator when the first event is emitted.
+ * @returns A function which takes a source {@link TypedEventTarget}, a list of event types emitted by that target to
+ * which to listen, and the accumulator function. The accumulator is called each time an event of the given type(s) is
+ * emitted on the source. It is passed the current state and the event, and must return a new state.
+ */
+export declare const scan: <S>(seedState: S) => <Target extends TypedEventTarget<TypedCustomEvent<string, any>>, Events extends EventsFromTarget<Target>, EventType extends Events["type"]>(source: Target, eventTypes: EventType[], accumulator: (state: S, event: EventOfType<EventType, Events>) => S) => TypedEventTarget<TypedCustomEvent<"state", S>>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/events/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/events/scan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,kUAwCZ,CAAC"}

package/dist/events/scan.js

@@ -0,0 +1,29 @@
+import { TypedCustomEvent } from "./TypedCustomEvent";
+import { TypedEventTarget } from "./TypedEventTarget";
+export const scan = (seedState) => (source, eventTypes, accumulator) => {
+    let state = seedState;
+    const sink = new TypedEventTarget();
+    const listener = (event) => {
+        state = accumulator(state, event);
+        sink.dispatchEvent(new TypedCustomEvent("state", state));
+    };
+    let hasListener = false;
+    sink.addEventListener = new Proxy(sink.addEventListener, {
+        apply: (target, thisArg, args) => {
+            if (hasListener)
+                throw new Error("Cannot add another event listener. The TypedEventTarget returned by scan only " +
+                    "supports a single listener, and one has already been added.");
+            hasListener = true;
+            eventTypes.forEach((eventType) => source.addEventListener(eventType, listener));
+            target.apply(thisArg, args);
+        },
+    });
+    sink.removeEventListener = new Proxy(sink.removeEventListener, {
+        apply: (target, thisArg, args) => {
+            eventTypes.forEach((eventType) => source.removeEventListener(eventType, listener));
+            target.apply(thisArg, args);
+        },
+    });
+    return sink;
+};
+//# sourceMappingURL=scan.js.map

package/dist/events/scan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.js","sourceRoot":"","sources":["../../src/events/scan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AActD,MAAM,CAAC,MAAM,IAAI,GACb,CAAI,SAAY,EAAE,EAAE,CACpB,CACI,MAAc,EACd,UAAuB,EACvB,WAAmE,EACrB,EAAE;IAChD,IAAI,KAAK,GAAG,SAAS,CAAC;IACtB,MAAM,IAAI,GAAG,IAAI,gBAAgB,EAAgC,CAAC;IAClE,MAAM,QAAQ,GAAG,CAAC,KAAuB,EAAE,EAAE;QACzC,KAAK,GAAG,WAAW,CAAC,KAAK,EAAE,KAAuC,CAAC,CAAC;QACpE,IAAI,CAAC,aAAa,CAAC,IAAI,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;IAC7D,CAAC,CAAC;IAOF,IAAI,WAAW,GAAG,KAAK,CAAC;IACxB,IAAI,CAAC,gBAAgB,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,gBAAgB,EAAE;QACrD,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,IAAmD,EAAE,EAAE;YAC5E,IAAI,WAAW;gBACX,MAAM,IAAI,KAAK,CACX,gFAAgF;oBAC5E,6DAA6D,CACpE,CAAC;YACN,WAAW,GAAG,IAAI,CAAC;YACnB,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;YAChF,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAChC,CAAC;KACJ,CAAC,CAAC;IACH,IAAI,CAAC,mBAAmB,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,mBAAmB,EAAE;QAC3D,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,IAAsD,EAAE,EAAE;YAC/E,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;YACnF,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAChC,CAAC;KACJ,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC;AAChB,CAAC,CAAC","sourcesContent":["import type { EventOfType } from \"./TypedCustomEvent\";\nimport { TypedCustomEvent } from \"./TypedCustomEvent\";\nimport type { EventsFromTarget } from \"./TypedEventTarget\";\nimport { TypedEventTarget } from \"./TypedEventTarget\";\n\n/**\n * Each time an event is emitted, call a given accumulator function with two arguments: some state of type S and the\n * event. The accumulator returns a new state. `scan` returns a new event emitter which emits an event each time a new\n * state is produced by the accumulator.\n *\n * This can be used to implement a Redux-style state management architecture.\n *\n * @param seedState Some initial state, passed to the accumulator when the first event is emitted.\n * @returns A function which takes a source {@link TypedEventTarget}, a list of event types emitted by that target to\n * which to listen, and the accumulator function. The accumulator is called each time an event of the given type(s) is\n * emitted on the source. It is passed the current state and the event, and must return a new state.\n */\nexport const scan =\n    <S>(seedState: S) =>\n    <Target extends TypedEventTarget, Events extends EventsFromTarget<Target>, EventType extends Events[\"type\"]>(\n        source: Target,\n        eventTypes: EventType[],\n        accumulator: (state: S, event: EventOfType<EventType, Events>) => S\n    ): TypedEventTarget<TypedCustomEvent<\"state\", S>> => {\n        let state = seedState;\n        const sink = new TypedEventTarget<TypedCustomEvent<\"state\", S>>();\n        const listener = (event: TypedCustomEvent) => {\n            state = accumulator(state, event as EventOfType<EventType, Events>);\n            sink.dispatchEvent(new TypedCustomEvent(\"state\", state));\n        };\n\n        // We'll use Proxies to make sure that event listeners are added/removed at the appropriate time.\n        // Callers can then control when to clean up the listeners we add here in a transparent way –\n        // by just removing the listener on the returned event target.\n        //\n        // We also prevent multiple listeners on the sink, as a simplification.\n        let hasListener = false;\n        sink.addEventListener = new Proxy(sink.addEventListener, {\n            apply: (target, thisArg, args: Parameters<(typeof sink)[\"addEventListener\"]>) => {\n                if (hasListener)\n                    throw new Error(\n                        \"Cannot add another event listener. The TypedEventTarget returned by scan only \" +\n                            \"supports a single listener, and one has already been added.\"\n                    );\n                hasListener = true;\n                eventTypes.forEach((eventType) => source.addEventListener(eventType, listener));\n                target.apply(thisArg, args);\n            },\n        });\n        sink.removeEventListener = new Proxy(sink.removeEventListener, {\n            apply: (target, thisArg, args: Parameters<(typeof sink)[\"removeEventListener\"]>) => {\n                eventTypes.forEach((eventType) => source.removeEventListener(eventType, listener));\n                target.apply(thisArg, args);\n            },\n        });\n\n        return sink;\n    };\n"]}

package/dist/extensions/RemoteApiServices.d.ts

@@ -0,0 +1,88 @@
+import type { LensRepository } from "../lens/LensRepository";
+import type { Lens } from "../lens/Lens";
+import type { LensState } from "../session/lensState";
+import type { SessionState } from "../session/sessionState";
+import type { MetricsClient } from "../clients/metricsClient";
+import type { UriHandler } from "./UriHandlers";
+/**
+ * Status of a Remote API response.
+ */
+export type RemoteApiStatus = "success" | "redirected" | "badRequest" | "accessDenied" | "notFound" | "timeout" | "requestTooLarge" | "serverError" | "cancelled" | "proxyError";
+/**
+ * Remote API request sent by a lens.
+ */
+export interface RemoteApiRequest {
+    /**
+     * Unique id of the remote API service specification.
+     */
+    apiSpecId: string;
+    /**
+     * Unique id of the remote API service endpoint requested by this request.
+     */
+    endpointId: string;
+    /**
+     * A map of named parameters associated with the request.
+     */
+    parameters: Record<string, string>;
+    /**
+     * Additional binary request payload.
+     */
+    body: ArrayBuffer;
+}
+/**
+ * Remote API response to a request sent by a lens.
+ */
+export interface RemoteApiResponse {
+    /**
+     * Status of the response
+     */
+    status: RemoteApiStatus;
+    /**
+     * A map of named metadata associated with the response.
+     */
+    metadata: Record<string, string>;
+    /**
+     * Additional binary request payload.
+     */
+    body: ArrayBuffer;
+}
+/**
+ * Represents a Remote API request cancellation handler function.
+ */
+export type RemoteApiCancelRequestHandler = () => void;
+/**
+ * Represents a Remote API request handler function.
+ * It is provided with a reply callback that must be invoked to send a response back to the lens.
+ * The reply callback can be invoked multiple times if needed.
+ * Additionally, the handler can return a cancellation callback, which is triggered when the lens cancels the request.
+ */
+export type RemoteApiRequestHandler = (reply: (response: RemoteApiResponse) => void) => RemoteApiCancelRequestHandler | void;
+/**
+ * Service to handle a lens Remote API request.
+ */
+export interface RemoteApiService {
+    /**
+     * Remote API spec ID(s).
+     */
+    apiSpecId: string;
+    /**
+     * This method is called by Camera Kit when a lens triggers a Remote API request with a corresponding spec ID.
+     * If the service can handle the request, the method returns a request handler; otherwise, it returns nothing.
+     * @param request Remote API request object.
+     * @param lens Lens that triggers the request.
+     * @returns A request handler if applicable.
+     */
+    getRequestHandler(request: RemoteApiRequest, lens: Lens): RemoteApiRequestHandler | undefined;
+}
+export type RemoteApiServices = RemoteApiService[];
+export declare const remoteApiServicesFactory: {
+    (): RemoteApiServices;
+    token: "remoteApiServices";
+    dependencies: [];
+};
+/**
+ * Provides a URI handler that searches for a match within the provided services to handle Remote API requests,
+ * i.e., those whose URI starts with 'app://remote-api/performApiRequest'.
+ */
+export declare function getRemoteApiUriHandler(registeredServices: RemoteApiService[], sessionState: SessionState, lensState: LensState, lensRepository: LensRepository, metrics: MetricsClient): UriHandler;
+//# sourceMappingURL=RemoteApiServices.d.ts.map

package/dist/extensions/RemoteApiServices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteApiServices.d.ts","sourceRoot":"","sources":["../../src/extensions/RemoteApiServices.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EAAoB,UAAU,EAA2B,MAAM,eAAe,CAAC;AAyF3F;;GAEG;AACH,MAAM,MAAM,eAAe,GACrB,SAAS,GACT,YAAY,GACZ,YAAY,GACZ,cAAc,GACd,UAAU,GACV,SAAS,GACT,iBAAiB,GACjB,aAAa,GACb,WAAW,GACX,YAAY,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;OAEG;IACH,MAAM,EAAE,eAAe,CAAC;IACxB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,MAAM,IAAI,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAClC,KAAK,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,KAC3C,6BAA6B,GAAG,IAAI,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;OAMG;IACH,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,IAAI,GAAG,uBAAuB,GAAG,SAAS,CAAC;CACjG;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,EAAE,CAAC;AAEnD,eAAO,MAAM,wBAAwB;;;;CAGnC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,sBAAsB,CAClC,kBAAkB,EAAE,gBAAgB,EAAE,EACtC,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,aAAa,GACvB,UAAU,CAoKZ"}

package/dist/extensions/RemoteApiServices.js

@@ -0,0 +1,155 @@
+import { Subject, catchError, filter, map, merge, retry, takeUntil, tap } from "rxjs";
+import { forActions } from "@snap/state-management";
+import { Injectable } from "../dependency-injection/Injectable";
+import { RemoteApiInfo } from "../generated-proto/pb_schema/camera_kit/v3/features/remote_api_info";
+import { ResponseCode, responseCodeToNumber } from "../generated-proto/pb_schema/lenses/remote_api/remote_api_service";
+import { getLogger } from "../logger/logger";
+import { Count } from "../metrics/operational/Count";
+import { joinMetricNames } from "../metrics/operational/Metric";
+import { extractSchemeAndRoute } from "./UriHandlers";
+const logger = getLogger("RemoteApiServices");
+const uriResponseOkCode = 200;
+const apiResponseStatusHeader = ":sc_lens_api_status";
+const apiBinaryContentType = "application/octet-stream";
+const remoteApiInfoProtobufTypeUrl = "type.googleapis.com/com.snap.camerakit.v3.features.RemoteApiInfo";
+const statusToResponseCodeMap = {
+    success: ResponseCode.SUCCESS,
+    redirected: ResponseCode.REDIRECTED,
+    badRequest: ResponseCode.BAD_REQUEST,
+    accessDenied: ResponseCode.ACCESS_DENIED,
+    notFound: ResponseCode.NOT_FOUND,
+    timeout: ResponseCode.TIMEOUT,
+    requestTooLarge: ResponseCode.REQUEST_TOO_LARGE,
+    serverError: ResponseCode.SERVER_ERROR,
+    cancelled: ResponseCode.CANCELLED,
+    proxyError: ResponseCode.PROXY_ERROR,
+};
+function callCancellationHandler(cancellationHandlers, ...keys) {
+    var _a;
+    for (const key of keys) {
+        (_a = cancellationHandlers.get(key)) === null || _a === void 0 ? void 0 : _a();
+        cancellationHandlers.delete(key);
+    }
+}
+function handleLensApplicationEnd(lensRequestState, ...lensIds) {
+    for (const lensId of lensIds) {
+        const state = lensRequestState.get(lensId);
+        if (state) {
+            callCancellationHandler(state.cancellationHandlers, ...state.cancellationHandlers.keys());
+            lensRequestState.delete(lensId);
+        }
+    }
+}
+export const remoteApiServicesFactory = Injectable("remoteApiServices", () => {
+    const remoteApiServices = [];
+    return remoteApiServices;
+});
+export function getRemoteApiUriHandler(registeredServices, sessionState, lensState, lensRepository, metrics) {
+    const registeredServiceMap = new Map();
+    for (const service of registeredServices) {
+        const existingServices = registeredServiceMap.get(service.apiSpecId) || [];
+        registeredServiceMap.set(service.apiSpecId, [...existingServices, service]);
+    }
+    const uriRequests = new Subject();
+    const uriCancelRequests = new Subject();
+    const lensRequestState = new Map();
+    const lensTurnOffEvents = lensState.events.pipe(forActions("turnedOff"), tap(([action]) => handleLensApplicationEnd(lensRequestState, action.data.id)));
+    const uriRequestEvents = uriRequests.pipe(map((uriRequest) => {
+        var _a, _b;
+        const lensId = uriRequest.lens.id;
+        if (!lensRequestState.has(lensId)) {
+            lensRequestState.set(lensId, {
+                cancellationHandlers: new Map(),
+                supportedSpecIds: new Set(((_b = (_a = lensRepository.getLensMetadata(lensId)) === null || _a === void 0 ? void 0 : _a.featureMetadata) !== null && _b !== void 0 ? _b : [])
+                    .filter((feature) => feature.typeUrl === remoteApiInfoProtobufTypeUrl)
+                    .flatMap((any) => RemoteApiInfo.decode(any.value).apiSpecIds)),
+            });
+        }
+        const requestState = lensRequestState.get(lensId);
+        const { route } = extractSchemeAndRoute(uriRequest.request.uri);
+        const [specId, endpointIdWithQuery] = route.split("/").slice(2);
+        const [endpointId] = endpointIdWithQuery.split("?");
+        return { uriRequest, specId, endpointId, requestState };
+    }), filter(({ specId, requestState }) => requestState.supportedSpecIds.has(specId)), filter(({ specId }) => registeredServiceMap.has(specId)), map(({ uriRequest, specId, endpointId, requestState }) => {
+        var _a;
+        const dimensions = { specId };
+        const reportSingleCount = (name) => {
+            metrics.setOperationalMetrics(Count.count(joinMetricNames(["lens", "remote-api", name]), 1, dimensions));
+        };
+        reportSingleCount("requests");
+        const remoteApiRequest = {
+            apiSpecId: specId,
+            body: uriRequest.request.data,
+            endpointId,
+            parameters: uriRequest.request.metadata,
+        };
+        for (const service of (_a = registeredServiceMap.get(specId)) !== null && _a !== void 0 ? _a : []) {
+            let requestHandler = undefined;
+            try {
+                requestHandler = service.getRequestHandler(remoteApiRequest, uriRequest.lens);
+            }
+            catch (error) {
+                logger.warn("Client's Remote API request handler factory threw an error.", error);
+            }
+            if (requestHandler) {
+                reportSingleCount("handled-requests");
+                let cancellationHandler = undefined;
+                try {
+                    cancellationHandler = requestHandler((response) => {
+                        var _a;
+                        reportSingleCount("responses");
+                        const responseCode = (_a = statusToResponseCodeMap[response.status]) !== null && _a !== void 0 ? _a : ResponseCode.UNRECOGNIZED;
+                        const uriResponse = {
+                            code: uriResponseOkCode,
+                            description: "",
+                            contentType: apiBinaryContentType,
+                            data: response.body,
+                            metadata: Object.assign(Object.assign({}, response.metadata), { [apiResponseStatusHeader]: responseCodeToNumber(responseCode).toString() }),
+                        };
+                        uriRequest.reply(uriResponse);
+                    });
+                }
+                catch (error) {
+                    logger.warn("Client's Remote API request handler threw an error.", error);
+                }
+                if (typeof cancellationHandler === "function") {
+                    requestState.cancellationHandlers.set(uriRequest.request.identifier, () => {
+                        try {
+                            cancellationHandler();
+                        }
+                        catch (error) {
+                            logger.warn("Client's Remote API request cancellation handler threw an error.", error);
+                        }
+                    });
+                }
+                break;
+            }
+        }
+    }));
+    const uriCancelRequestEvents = uriCancelRequests.pipe(tap((uriRequest) => {
+        var _a;
+        const cancellationHandlers = (_a = lensRequestState.get(uriRequest.lens.id)) === null || _a === void 0 ? void 0 : _a.cancellationHandlers;
+        if (cancellationHandlers) {
+            callCancellationHandler(cancellationHandlers, uriRequest.request.requestId);
+        }
+    }));
+    merge(lensTurnOffEvents, uriRequestEvents, uriCancelRequestEvents)
+        .pipe(catchError((error, sourcePipe) => {
+        logger.error(error);
+        metrics.setOperationalMetrics(Count.count(joinMetricNames(["lens", "remote-api", "errors"]), 1));
+        return sourcePipe;
+    }), retry(), takeUntil(sessionState.events.pipe(forActions("destroy"))))
+        .subscribe({
+        complete: () => handleLensApplicationEnd(lensRequestState, ...lensRequestState.keys()),
+    });
+    return {
+        uri: "app://remote-api/performApiRequest",
+        handleRequest(request, reply, lens) {
+            uriRequests.next({ request, reply, lens });
+        },
+        cancelRequest(request, lens) {
+            uriCancelRequests.next({ request, lens });
+        },
+    };
+}
+//# sourceMappingURL=RemoteApiServices.js.map