@snap/camera-kit 0.7.0

package/lib/dependency-injection/PartialContainer.d.ts

@@ -0,0 +1,81 @@
+import { Container, Factories } from "./Container";
+import { AddService, InjectableFunction, ServicesFromTokenizedParams, ValidTokens } from "./types";
+declare type AddDependencies<ParentDependencies, Dependencies> = ParentDependencies extends any ? {
+    [K in keyof ParentDependencies | keyof Dependencies]: K extends keyof ParentDependencies ? ParentDependencies[K] : K extends keyof Dependencies ? Dependencies[K] : never;
+} : never;
+declare type ExcludeKey<T, U> = T extends any ? {
+    [K in Exclude<keyof T, U>]: T[K];
+} : never;
+declare type PartialInjectableFunction<Params extends readonly any[], Tokens extends readonly string[], Token extends string, Service> = {
+    (...args: Params): Service;
+    token: Token;
+    dependencies: Tokens;
+};
+declare type Injectables<Services, Dependencies> = {
+    [K in keyof Services]: K extends string ? InjectableFunction<Services & Dependencies, readonly ValidTokens<Services & Dependencies>[], K, Services[K]> : never;
+};
+/**
+ * Similar to [Container], with the exception that Services may be provided to a PartialContainer which *does not*
+ * contain all of that Services dependencies.
+ *
+ * For this to remain safe, Services can not be resolved by PartialContainer – it has no `get` method.
+ *
+ * Instead, the PartialContainer must be provided to a [Container] which *does* contain all the dependencies required
+ * by all the Service in the PartialContainer. The resulting [Container] can then resolve these Services.
+ *
+ * PartialContainers are used to create a collection of Services which can then be provided via a simple one-line syntax
+ * to an existing Container (which fulfills the collection's dependencies). It is an organizational tool, allowing
+ * coherent groupings of Services to be defined in one place, then combined elsewhere to form a complete [Container].
+ *
+ * Here's an example of PartialContainer usage:
+ * ```ts
+ * // We can provide fooFactory, even though the PartialContainer doesn't fulfill the Bar dependency.
+ * const fooFactory = Injectable('Foo', ['Bar'] as const, (bar: Bar) => new Foo(bar))
+ * const partialContainer = new PartialContainer({}).provide(fooFactory)
+ *
+ * const barFactory = Injectable('Bar', () => new Bar())
+ * const dependenciesContainer = Container.provides(barFactory)
+ *
+ * const combinedContainer = dependenciesContainer.provides(partialContainer)
+ *
+ * // We can resolve Foo, because the combined container includes Bar, so all of Foo's dependencies are now met.
+ * const foo = combinedContainer.get('Foo')
+ * ```
+ */
+/** @internal */
+export declare class PartialContainer<Services = {}, Dependencies = {}> {
+    private readonly injectables;
+    constructor(injectables: Injectables<Services, Dependencies>);
+    /**
+     * Create a new PartialContainer which provides a Service created by the given InjectableFunction.
+     *
+     * The InjectableFunction contains metadata specifying the Token by which the created Service will be known, as well
+     * as an ordered list of Tokens to be resolved and provided to the InjectableFunction as arguments.
+     *
+     * This dependencies are allowed to be missing from the PartialContainer, but these dependencies are maintained as a
+     * parameter of the returned PartialContainer. This allows `[Container.provides]` to type check the dependencies and
+     * ensure they can be provided by the Container.
+     *
+     * @param fn A InjectableFunction, taking dependencies as arguments, which returns the Service.
+     */
+    provides<AdditionalDependencies extends readonly any[], Tokens extends readonly string[], Token extends string, Service>(fn: PartialInjectableFunction<AdditionalDependencies, Tokens, Token, Service>): PartialContainer<AddService<Services, Token, Service>, ExcludeKey<AddDependencies<ExcludeKey<Dependencies, Token>, ServicesFromTokenizedParams<Tokens, AdditionalDependencies>>, keyof Services>>;
+    /**
+     * In order to create a [Container], the InjectableFunctions maintained by the PartialContainer must be memoized
+     * into Factories that can resolve their dependencies and return the correct Service.
+     *
+     * In particular, this requires access to a "parent" Container to avoid infinite looping in cases where Service A
+     * depends on Service A – this is allowed (as long as the parent container provides Service A), but requires access
+     * to the parent Container to provide the parent implementation of Service A.
+     *
+     * This also means that Services provided by a PartialContainer to a Container via this function will always be
+     * scoped to the Container. In other words, if a PartialContainer containing Service A is provided to both
+     * Container X and Container Y, when Service A is resolved by Container X the InjectableFunction used to create
+     * Service A will be invoked – and when Service A is resolved by Container Y, the InjectableFunction will be invoked
+     * again.
+     *
+     * @param parent A [Container] which provides all the required Dependencies of this PartialContainer.
+     */
+    getFactories(parent: Container<Dependencies>): Factories<Services>;
+    getTokens(): Array<keyof Services>;
+}
+export {};

package/lib/dependency-injection/PartialContainer.js

@@ -0,0 +1,85 @@
+import { entries } from "../common/entries";
+import { memoize } from "../common/memoize";
+/**
+ * Similar to [Container], with the exception that Services may be provided to a PartialContainer which *does not*
+ * contain all of that Services dependencies.
+ *
+ * For this to remain safe, Services can not be resolved by PartialContainer – it has no `get` method.
+ *
+ * Instead, the PartialContainer must be provided to a [Container] which *does* contain all the dependencies required
+ * by all the Service in the PartialContainer. The resulting [Container] can then resolve these Services.
+ *
+ * PartialContainers are used to create a collection of Services which can then be provided via a simple one-line syntax
+ * to an existing Container (which fulfills the collection's dependencies). It is an organizational tool, allowing
+ * coherent groupings of Services to be defined in one place, then combined elsewhere to form a complete [Container].
+ *
+ * Here's an example of PartialContainer usage:
+ * ```ts
+ * // We can provide fooFactory, even though the PartialContainer doesn't fulfill the Bar dependency.
+ * const fooFactory = Injectable('Foo', ['Bar'] as const, (bar: Bar) => new Foo(bar))
+ * const partialContainer = new PartialContainer({}).provide(fooFactory)
+ *
+ * const barFactory = Injectable('Bar', () => new Bar())
+ * const dependenciesContainer = Container.provides(barFactory)
+ *
+ * const combinedContainer = dependenciesContainer.provides(partialContainer)
+ *
+ * // We can resolve Foo, because the combined container includes Bar, so all of Foo's dependencies are now met.
+ * const foo = combinedContainer.get('Foo')
+ * ```
+ */
+/** @internal */
+export class PartialContainer {
+    constructor(injectables) {
+        this.injectables = injectables;
+    }
+    /**
+     * Create a new PartialContainer which provides a Service created by the given InjectableFunction.
+     *
+     * The InjectableFunction contains metadata specifying the Token by which the created Service will be known, as well
+     * as an ordered list of Tokens to be resolved and provided to the InjectableFunction as arguments.
+     *
+     * This dependencies are allowed to be missing from the PartialContainer, but these dependencies are maintained as a
+     * parameter of the returned PartialContainer. This allows `[Container.provides]` to type check the dependencies and
+     * ensure they can be provided by the Container.
+     *
+     * @param fn A InjectableFunction, taking dependencies as arguments, which returns the Service.
+     */
+    provides(fn) {
+        return new PartialContainer(Object.assign(Object.assign({}, this.injectables), { [fn.token]: fn }));
+    }
+    /**
+     * In order to create a [Container], the InjectableFunctions maintained by the PartialContainer must be memoized
+     * into Factories that can resolve their dependencies and return the correct Service.
+     *
+     * In particular, this requires access to a "parent" Container to avoid infinite looping in cases where Service A
+     * depends on Service A – this is allowed (as long as the parent container provides Service A), but requires access
+     * to the parent Container to provide the parent implementation of Service A.
+     *
+     * This also means that Services provided by a PartialContainer to a Container via this function will always be
+     * scoped to the Container. In other words, if a PartialContainer containing Service A is provided to both
+     * Container X and Container Y, when Service A is resolved by Container X the InjectableFunction used to create
+     * Service A will be invoked – and when Service A is resolved by Container Y, the InjectableFunction will be invoked
+     * again.
+     *
+     * @param parent A [Container] which provides all the required Dependencies of this PartialContainer.
+     */
+    getFactories(parent) {
+        return Object.fromEntries(entries(this.injectables).map(([token, fn]) => {
+            return [
+                token,
+                memoize((c) => {
+                    return fn(...fn.dependencies.map((t) => {
+                        return t === token
+                            ? parent.get(t)
+                            : c.get(t);
+                    }));
+                }),
+            ];
+        }));
+    }
+    getTokens() {
+        return Object.keys(this.injectables);
+    }
+}
+//# sourceMappingURL=PartialContainer.js.map

package/lib/dependency-injection/PartialContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartialContainer.js","sourceRoot":"","sources":["../../src/dependency-injection/PartialContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAoC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gBAAgB;AAChB,MAAM,OAAO,gBAAgB;IACzB,YAA6B,WAAgD;QAAhD,gBAAW,GAAX,WAAW,CAAqC;IAAG,CAAC;IAEjF;;;;;;;;;;;OAWG;IACH,QAAQ,CAMJ,EAA6E;QAc7E,OAAO,IAAI,gBAAgB,CAAC,gCAAK,IAAI,CAAC,WAAW,KAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,GAAS,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,MAA+B;QACxC,OAAO,MAAM,CAAC,WAAW,CACrB,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE;YAC1C,OAAO;gBACH,KAAK;gBACL,OAAO,CAAC,CAAC,CAAqC,EAAE,EAAE;oBAC9C,OAAO,EAAE,CACL,GAAI,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;wBAC1B,OAAO,CAAC,KAAK,KAAK;4BACd,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAuB,CAAC;4BACrC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAkC,CAAC,CAAC;oBACpD,CAAC,CAAS,CACb,CAAC;gBACN,CAAC,CAAC;aACL,CAAC;QACN,CAAC,CAAC,CACkB,CAAC;IAC7B,CAAC;IAED,SAAS;QACL,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAA0B,CAAC;IAClE,CAAC;CACJ","sourcesContent":["import { entries } from \"../common/entries\";\nimport { memoize } from \"../common/memoize\";\nimport { Container, Factories } from \"./Container\";\nimport { AddService, InjectableFunction, ServicesFromTokenizedParams, ValidTokens } from \"./types\";\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 AddDependencies type alias. This produces better hints.\ntype AddDependencies<ParentDependencies, Dependencies> = ParentDependencies extends any\n    ? // A mapped type produces better, more concise type hints than an intersection type.\n      {\n          [K in keyof ParentDependencies | keyof Dependencies]: K extends keyof ParentDependencies\n              ? ParentDependencies[K]\n              : K extends keyof Dependencies\n              ? Dependencies[K]\n              : never;\n      }\n    : never;\n\ntype ExcludeKey<T, U> = T extends any ? { [K in Exclude<keyof T, U>]: T[K] } : never;\n\ntype PartialInjectableFunction<\n    Params extends readonly any[],\n    Tokens extends readonly string[],\n    Token extends string,\n    Service\n> = {\n    (...args: Params): Service;\n    token: Token;\n    dependencies: Tokens;\n};\n\ntype Injectables<Services, Dependencies> = {\n    [K in keyof Services]: K extends string\n        ? InjectableFunction<Services & Dependencies, readonly ValidTokens<Services & Dependencies>[], K, Services[K]>\n        : never;\n};\n\n/**\n * Similar to [Container], with the exception that Services may be provided to a PartialContainer which *does not*\n * contain all of that Services dependencies.\n *\n * For this to remain safe, Services can not be resolved by PartialContainer – it has no `get` method.\n *\n * Instead, the PartialContainer must be provided to a [Container] which *does* contain all the dependencies required\n * by all the Service in the PartialContainer. The resulting [Container] can then resolve these Services.\n *\n * PartialContainers are used to create a collection of Services which can then be provided via a simple one-line syntax\n * to an existing Container (which fulfills the collection's dependencies). It is an organizational tool, allowing\n * coherent groupings of Services to be defined in one place, then combined elsewhere to form a complete [Container].\n *\n * Here's an example of PartialContainer usage:\n * ```ts\n * // We can provide fooFactory, even though the PartialContainer doesn't fulfill the Bar dependency.\n * const fooFactory = Injectable('Foo', ['Bar'] as const, (bar: Bar) => new Foo(bar))\n * const partialContainer = new PartialContainer({}).provide(fooFactory)\n *\n * const barFactory = Injectable('Bar', () => new Bar())\n * const dependenciesContainer = Container.provides(barFactory)\n *\n * const combinedContainer = dependenciesContainer.provides(partialContainer)\n *\n * // We can resolve Foo, because the combined container includes Bar, so all of Foo's dependencies are now met.\n * const foo = combinedContainer.get('Foo')\n * ```\n */\n/** @internal */\nexport class PartialContainer<Services = {}, Dependencies = {}> {\n    constructor(private readonly injectables: Injectables<Services, Dependencies>) {}\n\n    /**\n     * Create a new PartialContainer which provides a Service created by the given InjectableFunction.\n     *\n     * The InjectableFunction contains metadata specifying the Token by which the created Service will be known, as well\n     * as an ordered list of Tokens to be resolved and provided to the InjectableFunction as arguments.\n     *\n     * This dependencies are allowed to be missing from the PartialContainer, but these dependencies are maintained as a\n     * parameter of the returned PartialContainer. This allows `[Container.provides]` to type check the dependencies and\n     * ensure they can be provided by the Container.\n     *\n     * @param fn A InjectableFunction, taking dependencies as arguments, which returns the Service.\n     */\n    provides<\n        AdditionalDependencies extends readonly any[],\n        Tokens extends readonly string[],\n        Token extends string,\n        Service\n    >(\n        fn: PartialInjectableFunction<AdditionalDependencies, Tokens, Token, Service>\n    ): PartialContainer<\n        AddService<Services, Token, Service>,\n        // The dependencies of the new PartialContainer are the combined dependencies of this container and the\n        // PartialInjectableFunction -- but we exclude any dependencies already provided by this container (i.e. this\n        // container's Services) as well as the new Service being provided.\n        ExcludeKey<\n            AddDependencies<\n                ExcludeKey<Dependencies, Token>,\n                ServicesFromTokenizedParams<Tokens, AdditionalDependencies>\n            >,\n            keyof Services\n        >\n    > {\n        return new PartialContainer({ ...this.injectables, [fn.token]: fn } as any);\n    }\n\n    /**\n     * In order to create a [Container], the InjectableFunctions maintained by the PartialContainer must be memoized\n     * into Factories that can resolve their dependencies and return the correct Service.\n     *\n     * In particular, this requires access to a \"parent\" Container to avoid infinite looping in cases where Service A\n     * depends on Service A – this is allowed (as long as the parent container provides Service A), but requires access\n     * to the parent Container to provide the parent implementation of Service A.\n     *\n     * This also means that Services provided by a PartialContainer to a Container via this function will always be\n     * scoped to the Container. In other words, if a PartialContainer containing Service A is provided to both\n     * Container X and Container Y, when Service A is resolved by Container X the InjectableFunction used to create\n     * Service A will be invoked – and when Service A is resolved by Container Y, the InjectableFunction will be invoked\n     * again.\n     *\n     * @param parent A [Container] which provides all the required Dependencies of this PartialContainer.\n     */\n    getFactories(parent: Container<Dependencies>): Factories<Services> {\n        return Object.fromEntries(\n            entries(this.injectables).map(([token, fn]) => {\n                return [\n                    token,\n                    memoize((c: Container<Services & Dependencies>) => {\n                        return fn(\n                            ...(fn.dependencies.map((t) => {\n                                return t === token\n                                    ? parent.get(t as keyof Dependencies)\n                                    : c.get(t as keyof Services & Dependencies);\n                            }) as any)\n                        );\n                    }),\n                ];\n            })\n        ) as Factories<Services>;\n    }\n\n    getTokens(): Array<keyof Services> {\n        return Object.keys(this.injectables) as Array<keyof Services>;\n    }\n}\n"]}

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

@@ -0,0 +1,62 @@
+import { lensRepositoryFactory } from "../lens/LensRepository";
+import { lensCoreFactory } from "../lens-core-module/loader/lensCoreFactory";
+import { remoteMediaAssetLoaderFactory } from "../lens/assets/remoteMediaAssetLoaderFactory";
+import { deviceDependentAssetLoaderFactory } from "../lens/assets/deviceDependentAssetLoader";
+import { staticAssetLoaderFactory } from "../lens/assets/staticAssetLoader";
+import { defaultFetchHandlerFactory } from "../handlers/defaultFetchHandler";
+import { cameraKitServiceFetchHandlerFactory } from "../handlers/cameraKitServiceFetchHandlerFactory";
+import { createCameraKitConfigurationFactory } from "../configuration";
+import { LensCoreModule } from "../lens-core-module/generated-types";
+import { metricsEventTargetFactory } from "../metrics/metricsEventTarget";
+import { metricsHandlerFactory } from "../metrics/metricsHandler";
+import { operationalMetricReporterFactory } from "../metrics/operationalMetricsReporter";
+import { lensSourcesFactory } from "../extensions/LensSources";
+import { uriHandlersFactory } from "../extensions/UriHandlers";
+import { lensPersistenceStoreFactory } from "../lens/LensPersistenceStore";
+import { remoteConfigurationFactory } from "../remote-configuration/remoteConfiguration";
+import { lensAssetRepositoryFactory } from "../lens/assets/LensAssetRepository";
+import { legalStateFactory } from "../legal/legalState";
+import { legalPromptFactory } from "../legal/legalPrompt";
+import { logEntriesFactory } from "../logger/logEntries";
+import { reportGlobalException } from "../metrics/reporters/reportGlobalException";
+import { ServicesFromInjectables } from "./types";
+/**
+ * All services available to be customized by client app.
+ */
+export declare type PublicServices = ServicesFromInjectables<[
+    ReturnType<typeof createCameraKitConfigurationFactory>,
+    typeof defaultFetchHandlerFactory,
+    typeof remoteMediaAssetLoaderFactory,
+    typeof lensSourcesFactory,
+    typeof uriHandlersFactory
+]>;
+/**
+ * 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 declare type RootServices = {
+    [lensCoreFactory.token]: LensCoreModule;
+} & PublicServices & ServicesFromInjectables<[
+    typeof metricsEventTargetFactory,
+    typeof cameraKitServiceFetchHandlerFactory,
+    typeof remoteConfigurationFactory,
+    typeof lensRepositoryFactory,
+    typeof lensPersistenceStoreFactory,
+    typeof metricsHandlerFactory,
+    typeof operationalMetricReporterFactory,
+    typeof lensAssetRepositoryFactory,
+    typeof deviceDependentAssetLoaderFactory,
+    typeof staticAssetLoaderFactory,
+    typeof legalStateFactory,
+    typeof legalPromptFactory,
+    typeof logEntriesFactory,
+    typeof reportGlobalException
+]>;

package/lib/dependency-injection/RootServices.js

@@ -0,0 +1,2 @@
+import { lensCoreFactory } from "../lens-core-module/loader/lensCoreFactory";
+//# sourceMappingURL=RootServices.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RootServices.js","sourceRoot":"","sources":["../../src/dependency-injection/RootServices.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC","sourcesContent":["import { lensRepositoryFactory } from \"../lens/LensRepository\";\nimport { lensCoreFactory } from \"../lens-core-module/loader/lensCoreFactory\";\nimport { remoteMediaAssetLoaderFactory } from \"../lens/assets/remoteMediaAssetLoaderFactory\";\nimport { deviceDependentAssetLoaderFactory } from \"../lens/assets/deviceDependentAssetLoader\";\nimport { staticAssetLoaderFactory } from \"../lens/assets/staticAssetLoader\";\nimport { defaultFetchHandlerFactory } from \"../handlers/defaultFetchHandler\";\nimport { cameraKitServiceFetchHandlerFactory } from \"../handlers/cameraKitServiceFetchHandlerFactory\";\nimport { createCameraKitConfigurationFactory } from \"../configuration\";\nimport { LensCoreModule } from \"../lens-core-module/generated-types\";\nimport { metricsEventTargetFactory } from \"../metrics/metricsEventTarget\";\nimport { metricsHandlerFactory } from \"../metrics/metricsHandler\";\nimport { operationalMetricReporterFactory } from \"../metrics/operationalMetricsReporter\";\nimport { lensSourcesFactory } from \"../extensions/LensSources\";\nimport { uriHandlersFactory } from \"../extensions/UriHandlers\";\nimport { lensPersistenceStoreFactory } from \"../lens/LensPersistenceStore\";\nimport { remoteConfigurationFactory } from \"../remote-configuration/remoteConfiguration\";\nimport { lensAssetRepositoryFactory } from \"../lens/assets/LensAssetRepository\";\nimport { legalStateFactory } from \"../legal/legalState\";\nimport { legalPromptFactory } from \"../legal/legalPrompt\";\nimport { logEntriesFactory } from \"../logger/logEntries\";\nimport { reportGlobalException } from \"../metrics/reporters/reportGlobalException\";\nimport { 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 uriHandlersFactory\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 LensCoreModule (rather than the\n    // Promise of the LensCoreModule), so we need to do the same re-mapping here.\n    [lensCoreFactory.token]: LensCoreModule;\n} & PublicServices &\n    ServicesFromInjectables<\n        [\n            typeof metricsEventTargetFactory,\n            typeof cameraKitServiceFetchHandlerFactory,\n            typeof remoteConfigurationFactory,\n            typeof lensRepositoryFactory,\n            typeof lensPersistenceStoreFactory,\n            typeof metricsHandlerFactory,\n            typeof operationalMetricReporterFactory,\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/lib/dependency-injection/types.d.ts

@@ -0,0 +1,56 @@
+import { Container, ContainerToken } from "./Container";
+declare type AsTuple<T> = T extends readonly any[] ? T : never;
+declare 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 declare type ValidTokens<Services> = ContainerToken | keyof Services;
+/**
+ * Given Services, map from a list of Tokens to a list of Service types.
+ */
+export declare 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 declare 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 declare type AnyInjectable = InjectableFunction<any, readonly string[], string, any>;
+export declare 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 declare 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 declare 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 {};

package/lib/dependency-injection/types.js

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

package/lib/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 { 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 } &\n                      ServicesFromTokenizedParams<RemainingTokens, RemainingParams>\n                : never\n            : never\n        : never\n    : never;\n"]}

package/lib/environment.json

@@ -0,0 +1 @@
+{ "PACKAGE_VERSION": "0.7.0-alpha.1" }

package/lib/events/TypedCustomEvent.d.ts

@@ -0,0 +1,10 @@
+export declare 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">);
+}

package/lib/events/TypedCustomEvent.js

@@ -0,0 +1,11 @@
+/**
+ * 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 class TypedCustomEvent extends CustomEvent {
+    constructor(type, detail, eventInitDict = {}) {
+        super(type, Object.assign(Object.assign({}, eventInitDict), { detail }));
+    }
+}
+//# sourceMappingURL=TypedCustomEvent.js.map

package/lib/events/TypedCustomEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedCustomEvent.js","sourceRoot":"","sources":["../../src/events/TypedCustomEvent.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,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/lib/events/TypedEventTarget.d.ts

@@ -0,0 +1,25 @@
+import { EventOfType, TypedCustomEvent } from "./TypedCustomEvent";
+export declare 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 declare 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;
+}

package/lib/events/TypedEventTarget.js

@@ -0,0 +1,57 @@
+/**
+ * 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 class TypedEventTarget {
+    constructor() {
+        this.listeners = new Map();
+        this.options = new Map();
+    }
+    addEventListener(type, callback, options) {
+        var _a;
+        // Safety: the type in the method signature ensures the callback handles events of type K, and we use that type
+        // as the key when storing the callback – we only ever invoke callbacks obtained by mapping from that event
+        // type to the callback, so even though we store the callback with a wider type, we only ever call it with the
+        // specific event type specified by K.
+        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) {
+                // We'll do our best to immitate native behavior, where if a listener throws an error it is caught and
+                // emitted as an error event on the window – this might be slightly different from native behavior since
+                // we have to use a CustomEvent, but it's as close as we can get.
+                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/lib/events/TypedEventTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEventTarget.js","sourceRoot":"","sources":["../../src/events/TypedEventTarget.ts"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AACH,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;;QAEnC,+GAA+G;QAC/G,2GAA2G;QAC3G,8GAA8G;QAC9G,sCAAsC;QACtC,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;gBACZ,sGAAsG;gBACtG,wGAAwG;gBACxG,iEAAiE;gBACjE,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 { 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/lib/events/scan.d.ts

@@ -0,0 +1,15 @@
+import { EventOfType, TypedCustomEvent } from "./TypedCustomEvent";
+import { EventsFromTarget, 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: Extract<Events, TypedCustomEvent<EventType, any>>) => S) => TypedEventTarget<TypedCustomEvent<"state", S>>;

package/lib/events/scan.js

@@ -0,0 +1,46 @@
+import { TypedCustomEvent } from "./TypedCustomEvent";
+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 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));
+    };
+    // We'll use Proxies to make sure that event listeners are added/removed at the appropriate time. Callers can then
+    // control when to clean up the listeners we add here in a transparent way – by just removing the listener on the
+    // returned event target.
+    //
+    // We also prevent multiple listeners on the sink, as a simplification.
+    let hasListener = false;
+    sink.addEventListener = new Proxy(sink.addEventListener, {
+        apply: (target, thisArg, args) => {
+            if (hasListener)
+                throw new Error("Cannot addEventListener. 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/lib/events/scan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.js","sourceRoot":"","sources":["../../src/events/scan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAoB,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAI,SAAY,EAAE,EAAE,CAAC,CAKrC,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;IAEF,kHAAkH;IAClH,iHAAiH;IACjH,yBAAyB;IACzB,EAAE;IACF,uEAAuE;IACvE,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,IAAiD,EAAE,EAAE;YAC1E,IAAI,WAAW;gBACX,MAAM,IAAI,KAAK,CACX,sEAAsE;oBAClE,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,IAAoD,EAAE,EAAE;YAC7E,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 { EventOfType, TypedCustomEvent } from \"./TypedCustomEvent\";\nimport { EventsFromTarget, 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 = <S>(seedState: S) => <\n    Target extends TypedEventTarget,\n    Events extends EventsFromTarget<Target>,\n    EventType extends Events[\"type\"]\n>(\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. Callers can then\n    // control when to clean up the listeners we add here in a transparent way – by just removing the listener on the\n    // 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 addEventListener. 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/lib/extensions/LensSources.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A source of a lens group.
+ */
+export interface LensSource {
+    /**
+     * Whether the given source is able to load lenses of the supplied group.
+     * @param groupId Group ID to check.
+     */
+    isGroupOwner(groupId: string): boolean;
+    /**
+     * Returns an encoded lens object.
+     * @param lensId Lens ID to get.
+     * @param groupId Group ID the lens belongs to.
+     */
+    getLens(lensId: string, groupId: string): Promise<ArrayBuffer>;
+    /**
+     * Returns encoded lens objects.
+     * @param groupId Group ID to get lenses of.
+     */
+    getLensGroup(groupId: string): Promise<ArrayBuffer[]>;
+}
+/**
+ * A chain of {@link LensSource} objects to be registered in Camera Kit on bootstrap. Camera Kit evaluates all
+ * registered {@link LensSource} objects for a group ownership during Lens retrieval ({@link CameraKit.lenses}).
+ * And if a source claims the ownership, its {@link LensSource.getLens} or {@link LensSource.getLensGroup}
+ * methods are called.
+ */
+export declare class LensSources {
+    private readonly fallbackSources;
+    private readonly source;
+    /**
+     * Creates an instance of Lens sources.
+     * @param fallbackSources A fallback sources if given {@link LensSource} doesn't claim a group ownership.
+     * @param source Lens source.
+     */
+    constructor(fallbackSources: LensSources, source: LensSource);
+    /**
+     * Returns empty LensSources instance.
+     * @internal
+     */
+    static empty(): LensSources;
+    /**
+     * Returns envelopes of lens/groups taking into account group ownership.
+     * @internal
+     * @param groupId A group to test ownership and get lens envelopes of.
+     * @param lensId An optional lens ID to narrow envelopes down to a single lens.
+     * @returns Envelopes or undefined if not applicable.
+     */
+    retrieveLenses({ groupId, lensId }: {
+        groupId: string;
+        lensId?: string;
+    }): Promise<ArrayBuffer[] | void>;
+}
+export declare const lensSourcesFactory: {
+    (): LensSources;
+    token: "lensSources";
+    dependencies: [];
+};