@snap/camera-kit 0.7.0 → 0.9.0

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

@@ -1 +1 @@
-{"version":3,"file":"Container.js","sourceRoot":"","sources":["../../src/dependency-injection/Container.ts"],"names":[],"mappings":"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","sourcesContent":["import { isMemoized, memoize, Memoized } from \"../common/memoize\";\nimport { PartialContainer } from \"./PartialContainer\";\nimport { AddService, InjectableFunction, ValidTokens } from \"./types\";\n\n// This is un-safe. In practice, Containers should always be created by calling `Container::provides` on some other\n// Container (except for some \"root\" Container which is instantiated with no Services) – `Container::provides\" is safely\n// type-checked, so this doesn't introduce much risk. But a more accurate solution would be for the `Factories` and\n// `MaybeMemoizedFactories` types to keep track of which specific Services must be present in the Container\n// corresponding to each Service. But this is much more complex to implement.\ntype UnsafePartialContainer<Services> = Container<Partial<Services>>;\n\ntype MaybeMemoizedFactories<Services> = {\n    [K in keyof Services]:\n        | ((c: UnsafePartialContainer<Services>) => Services[K])\n        | Memoized<(c: UnsafePartialContainer<Services>) => Services[K]>;\n};\n\nexport type Factories<Services> = {\n    [K in keyof Services]: Memoized<(c: UnsafePartialContainer<Services>) => Services[K]>;\n};\n\nexport const CONTAINER = \"$container\";\nexport type ContainerToken = typeof CONTAINER;\n\n/**\n * A Container of values, indexed each by a unique token, which can be used throughout CameraKit. This is how CameraKit\n * implements simple dependency injection.\n *\n * Dependency injection is a way to decouple the *use* of a dependency from the *creation* of that dependency. This\n * improves modularity and re-usability, since components only care about the *interfaces* of dependencies (since that\n * determines their use) and not about their concrete creation. New implementations of a particular dependency may be\n * provided without the need to change any of the consumers of that dependency.\n *\n * There are a few commonly-used terms used when talking about dependency injection:\n *\n *   - Container (or Injector): Maintains a registry of all available Services and understands how to create them.\n *   - Service: Anything that can be provided by the Container is called a Service – this can be a value of any type.\n *   - Token: Each Service is associated with a unique name, or Token. In order to obtain a Service from the Container,\n *     the consumer must provide the Token corresponding to that Service.\n *   - InjectableFunction: Services are created by InjectableFunctions. When adding a Service to a Container, the\n *     Service provider gives the Container a InjectableFunction which, when called will return the Service. These\n *     InjectableFunctions may themselves use other Services, which will be passed to them as arguments.\n *\n * Services are, by default, singletons – that is, each call to `get()` a particular Service will return a reference\n * to the same value. In other words, InjectableFunctions are only invoked once. If multiple instances of a Service are\n * desired, a new Container can be created using the `copy([Token])` method – passing a Token to this method forces the\n * new Container to recreate the corresponding Service (the InjectableFunction will be invoked again). We say that the\n * Service is then \"scoped\" to the new Container.\n *\n *\n * One common downside of many dependency injection implementations is that the dependency graph formed by the various\n * Services can only be validated at runtime. That is, if a dependency is missing or a circular dependency is found, the\n * developer must wait until runtime to discover the error. These errors can often be confusing and hard to debug.\n *\n * This implementation eliminates this issue by moving these sorts of errors to compile time. If an unknown dependency\n * is used in a InjectableFunction, for example, the code simply won't compile.\n *\n * To achieve this, we do lose the ability to implicitly define the dependency graph, as is common with many dependency\n * injection frameworks that employ decorators to define Services and their dependencies. Instead, the dependency graph\n * must be constructed explicitly, step-by-step, via successive calls to the `provide()` method. This is a suitable\n * trade-off for CameraKit, as there are a relatively small number of Services.\n *\n * Here's a simple example of Container usage:\n * ```ts\n * const fooFactory = Injectable('Foo', () => new Foo())\n * const barFactory = Injectable('Bar', ['Foo'] as const, (foo: Foo) => new Bar(foo))\n * const container = Container.empy()\n *   .provide(fooFactory)\n *   .provide(barFactory)\n *\n * const bar: Bar = container.get('Bar')\n * ```\n */\n/** @internal */\nexport class Container<Services = {}> {\n    private readonly factories: Factories<Services>;\n\n    constructor(factories: MaybeMemoizedFactories<Services>) {\n        this.factories = {} as Factories<Services>;\n        for (const k in factories) {\n            const fn = factories[k];\n            if (isMemoized(fn)) this.factories[k] = fn;\n            else this.factories[k] = memoize(fn);\n        }\n    }\n\n    /**\n     * Create a new [Container] by providing a [PartialContainer] that has no dependencies.\n     */\n    static provides<Services>(container: PartialContainer<Services, {}> | Container<Services>): Container<Services>;\n\n    /**\n     * Create a new [Container] by providing a Service that has no dependencies.\n     */\n    static provides<Token extends string, Service>(\n        fn: InjectableFunction<{}, [], Token, Service>\n    ): Container<AddService<{}, Token, Service>>;\n\n    static provides(\n        fnOrContainer: InjectableFunction<{}, [], string, any> | PartialContainer<any, {}> | Container<any>\n    ): Container<any> {\n        // Although the `provides` method has overloads that match both members of the union type separately, it does\n        // not match the union type itself, so the compiler forces us to branch and handle each type within the union\n        // separately. (Maybe in the future the compiler will decide to infer this, but for now this is necessary.)\n        if (fnOrContainer instanceof PartialContainer) return new Container({}).provides(fnOrContainer);\n        if (fnOrContainer instanceof Container) return new Container({}).provides(fnOrContainer);\n        return new Container({}).provides(fnOrContainer);\n    }\n\n    /**\n     * Create a copy of this Container, optionally providing a list of Services which will be scoped to the copy.\n     *\n     * This can be useful, for example, if different parts of an application wish to use the same Service interface, but\n     * do not want to share a reference to same Service instance.\n     *\n     * Say we have a Service which manages a list of Users. Our application wishes to display two lists of Users, which\n     * may be edited independently. In this case it may be desirable to create a Container for each list component, with\n     * the UserList Service scoped to those Containers – that way, each list component gets a unique copy of the\n     * UserList Service that can be edited independently of the other.\n     *\n     * @param scopedServices A list of Tokens identifying Services which will be scoped to the new Container – that is,\n     * if those Services had already been created by the source Container, they will be re-created by their Factory\n     * functions when provided by the new Container.\n     * @returns A new copy of this Container, sharing all of this Container's Services. Services corresponding to any\n     * Tokens passed to this method will be re-created by the new Container (i.e. they become \"scoped\" to the new\n     * Container).\n     */\n    copy<Tokens extends readonly (keyof Services)[]>(scopedServices?: Tokens): Container<Services> {\n        const factories: MaybeMemoizedFactories<Services> = { ...this.factories };\n\n        // We \"un-memoize\" scoped Service InjectableFunctions so they will create a new copy of their Service when\n        // provided by the new Container – we re-memoize them so the new Container will itself only create one Service\n        // instance.\n        (scopedServices || []).forEach((token: keyof Services) => {\n            factories[token] = this.factories[token].delegate;\n        });\n        return new Container(factories);\n    }\n\n    /**\n     * Gets a reference to this Container.\n     *\n     * @param token The CONTAINER token.\n     * @returns This Container.\n     */\n    get(token: ContainerToken): this;\n\n    /**\n     * Get a specific Service provided by this Container.\n     *\n     * @param token A unique string corresponding to a Service\n     * @returns A Service corresponding to the given Token.\n     */\n    get<Token extends keyof Services>(token: Token): Services[Token];\n\n    get(token: string): this | Services[keyof Services] {\n        if (token === CONTAINER) return this;\n        const factory = this.factories[token];\n        if (!factory) {\n            throw new Error(\n                `[Container::get] Could not find Service for Token \"${token}\". This should've caused a ` +\n                    \"compile-time error. If the Token is 'undefined', check all your calls to the Injectable \" +\n                    \"function. Make sure you define dependencies using string literals or string constants that are \" +\n                    \"definitely initialized before the call to Injectable.\"\n            );\n        }\n        return factory(this);\n    }\n\n    /**\n     * Run the services in this [PartialContainer]. \"Run\" simply means that [Container::get] will be called for each\n     * Service, which invokes that Service's factory function, creating the Service.\n     *\n     * This may be useful e.g. if services need to initialize themselves, since generally a Service factory is only\n     * invoked when the Service is needed.\n     *\n     * Note this method cannot be used to add services to a Container. – that is, calling this method does not provide\n     * the services in a new Container.\n     *\n     * @param container Optionally provide a [PartialContainer], which will be used as a filter – the only services\n     * from *this* container that will run are those with a token that is also present in this PartialContainer.\n     * @returns No mutation is done to the Container, it is returned as-is (convenient for chaining).\n     */\n    run<AdditionalServices, Dependencies, FulfilledDependencies extends Dependencies>(\n        // FullfilledDependencies is assignable to Dependencies -- by specifying Container<FulfilledDependencies> as the\n        // `this` type, we ensure this Container can provide all the Dependencies required by the PartialContainer.\n        this: Container<FulfilledDependencies>,\n        container: PartialContainer<AdditionalServices, Dependencies>\n    ): this;\n\n    /**\n     * Run the given Service. \"Run\" simply means that [Container::get] will be called for this Service, which invokes\n     * the Service's factory function, creating the Service.\n     *\n     * This may be useful e.g. if services need to initialize themselves, since generally a Service factory is only\n     * invoked when the Service is needed.\n     *\n     * Note this method cannot be used to add services to a Container. – that is, calling this method does not provide\n     * the services in a new Container.\n     *\n     * @param fn Optionally provide an [InjectableFunction], which will be used as a filter – the only services\n     * from *this* container that will run are those with a token that is also present in this PartialContainer.\n     * @returns No mutation is done to the Container, it is returned as-is (convenient for chaining).\n     */\n    run<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(\n        fn: InjectableFunction<Services, Tokens, Token, Service>\n    ): this;\n\n    run<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service, AdditionalServices>(\n        fnOrContainer:\n            | InjectableFunction<Services, Tokens, Token, Service>\n            | PartialContainer<AdditionalServices, Services>\n    ): this {\n        if (fnOrContainer instanceof PartialContainer) {\n            const runnableContainer = this.provides(fnOrContainer);\n            for (const token of fnOrContainer.getTokens()) {\n                runnableContainer.get(token);\n            }\n        } else {\n            this.provides(fnOrContainer).get(fnOrContainer.token);\n        }\n        return this;\n    }\n\n    /**\n     * Create a new Container from this Container with additional services from a given [PartialContainer].\n     *\n     * Services in the provided PartialContainer take precedence if there are service token conflicts.\n     *\n     * Services from the provided PartialContainer become scoped to the new Container – that is, if PartialContainer A\n     * is provided to Container X and Container Y, each resultant Container will contain its own copy of the services\n     * from PartialContainer A.\n     *\n     * @param container A [PartialContainer] providing additional services.\n     */\n    provides<AdditionalServices, Dependencies, FulfilledDependencies extends Dependencies>(\n        // FullfilledDependencies is assignable to Dependencies -- by specifying Container<FulfilledDependencies> as the\n        // `this` type, we ensure this Container can provide all the Dependencies required by the PartialContainer.\n        this: Container<FulfilledDependencies>,\n        container: PartialContainer<AdditionalServices, Dependencies>\n    ): Container<Services & AdditionalServices>;\n\n    /**\n     * Creates a new Container from this Container with additional services from another Container.\n     *\n     * Services in the provided PartialContainer take precedence if there are service token conflicts.\n     *\n     * Services from the provided Container become scoped to both Containers (the one from which they were provided\n     * and the new Container returned by this method) - that is, if Container A is provided to Container B,\n     * they will share the same instances of any Services provided by Container A.\n     * If Container B should re-create new instances of the Services from Container A,\n     * Container A must first be copied before providing it here.\n     *\n     * @param container A [Container] providing additional services.\n     */\n    provides<AdditionalServices>(container: Container<AdditionalServices>): Container<Services & AdditionalServices>;\n\n    /**\n     * Create a new Container 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     * If any of these required dependencies are missing from the Container (or if there is a mismatch between the types\n     * of those dependencies and the arguments of the InjectableFunction), a compiler error will be raised.\n     *\n     * @param fn A factory function, taking dependencies as arguments, which returns the Service.\n     */\n    provides<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(\n        fn: InjectableFunction<Services, Tokens, Token, Service>\n    ): Container<AddService<Services, Token, Service>>;\n\n    provides<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service, AdditionalServices>(\n        fnOrContainer:\n            | InjectableFunction<Services, Tokens, Token, Service>\n            | PartialContainer<AdditionalServices, Services>\n            | Container<AdditionalServices>\n    ): Container<any> {\n        if (fnOrContainer instanceof PartialContainer || fnOrContainer instanceof Container) {\n            const factories =\n                fnOrContainer instanceof PartialContainer ? fnOrContainer.getFactories(this) : fnOrContainer.factories;\n            // Safety: `this.factories` and `factories` are both properly type checked, so merging them produces\n            // a Factories object with keys from both Services and AdditionalServices. The compiler is unable to\n            // infer that Factories<A> & Factories<B> == Factories<A & B>, so the cast is required.\n            return new Container(({\n                ...this.factories,\n                ...factories,\n            } as unknown) as MaybeMemoizedFactories<Services & AdditionalServices>);\n        }\n        return this.providesService(fnOrContainer);\n    }\n\n    private providesService<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(\n        fn: InjectableFunction<Services, Tokens, Token, Service>\n    ): Container<AddService<Services, Token, Service>> {\n        const token = fn.token;\n        const dependencies: readonly any[] = fn.dependencies;\n\n        const factory = memoize((container: Container<Services>) => {\n            return fn(\n                ...(dependencies.map((t) => {\n                    // To support overwriting an already-existing service with a new implementation, it should be\n                    // possibleto do `provide(A, [A], a => createNewServiceFromOld(a))` – that is, inject a dependency\n                    // with the same token as this service's token.\n                    //\n                    // To avoid a circular dependency (in which the factory for service A depends on itself), we always\n                    // use the service defined in the *parent* container (i.e. this) when injecting a dependency with\n                    // the same token as the service we're providing. If we did not do this, calling `container.get(t)`\n                    // would result in an infinite loop.\n                    return t === token ? this.get(t) : container.get(t);\n                }) as any)\n            );\n        });\n\n        // Safety: `token` and `factory` are property type checked, so extending `this.factories` produces a\n        // MaybeMemoizedFactories object with the expected set of services – but when using the spread operation to\n        // merge two objects, the compiler widens the Token type to string. So we must re-narrow via casting.\n        const factories = { ...this.factories, [token]: factory };\n        return new Container((factories as unknown) as MaybeMemoizedFactories<AddService<Services, Token, Service>>);\n    }\n}\n"]}
+{"version":3,"file":"Container.js","sourceRoot":"","sources":["../../src/dependency-injection/Container.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAY,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAatD,MAAM,CAAC,MAAM,SAAS,GAAG,YAAY,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,gBAAgB;AAChB,MAAM,OAAO,SAAS;IAGlB,YAAY,SAA2C;QACnD,IAAI,CAAC,SAAS,GAAG,EAAyB,CAAC;QAC3C,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE;YACvB,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,UAAU,CAAC,EAAE,CAAC;gBAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;;gBACtC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;SACxC;IACL,CAAC;IAcD,MAAM,CAAC,QAAQ,CACX,aAAmG;QAEnG,6GAA6G;QAC7G,6GAA6G;QAC7G,2GAA2G;QAC3G,IAAI,aAAa,YAAY,gBAAgB;YAAE,OAAO,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;QAChG,IAAI,aAAa,YAAY,SAAS;YAAE,OAAO,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;QACzF,OAAO,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAA6C,cAAuB;QACpE,MAAM,SAAS,qBAA0C,IAAI,CAAC,SAAS,CAAE,CAAC;QAE1E,0GAA0G;QAC1G,8GAA8G;QAC9G,YAAY;QACZ,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,KAAqB,EAAE,EAAE;YACrD,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;QACtD,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,SAAS,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAkBD,GAAG,CAAC,KAAsC;QACtC,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACrC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,EAAE;YACV,MAAM,IAAI,KAAK,CACX,sDAAsD,MAAM,CAAC,KAAK,CAAC,6BAA6B;gBAC5F,0FAA0F;gBAC1F,iGAAiG;gBACjG,uDAAuD,CAC9D,CAAC;SACL;QACD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAyCD,GAAG,CACC,aAEoD;QAEpD,IAAI,aAAa,YAAY,gBAAgB,EAAE;YAC3C,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;YACvD,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,SAAS,EAAE,EAAE;gBAC3C,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;aAChC;SACJ;aAAM;YACH,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;SACzD;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAkDD,QAAQ,CACJ,aAGmC;QAEnC,IAAI,aAAa,YAAY,gBAAgB,IAAI,aAAa,YAAY,SAAS,EAAE;YACjF,MAAM,SAAS,GACX,aAAa,YAAY,gBAAgB,CAAC,CAAC,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC;YAC3G,oGAAoG;YACpG,oGAAoG;YACpG,uFAAuF;YACvF,OAAO,IAAI,SAAS,CAAC,gCACd,IAAI,CAAC,SAAS,GACd,SAAS,CACqD,CAAC,CAAC;SAC1E;QACD,OAAO,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;IAC/C,CAAC;IAEO,eAAe,CACnB,EAAwD;QAExD,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC;QACvB,MAAM,YAAY,GAAmB,EAAE,CAAC,YAAY,CAAC;QAErD,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,SAA8B,EAAE,EAAE;YACvD,OAAO,EAAE,CACL,GAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACvB,6FAA6F;gBAC7F,kGAAkG;gBAClG,+CAA+C;gBAC/C,EAAE;gBACF,mGAAmG;gBACnG,iGAAiG;gBACjG,mGAAmG;gBACnG,oCAAoC;gBACpC,OAAO,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACxD,CAAC,CAAS,CACb,CAAC;QACN,CAAC,CAAC,CAAC;QAEH,oGAAoG;QACpG,2GAA2G;QAC3G,qGAAqG;QACrG,MAAM,SAAS,mCAAQ,IAAI,CAAC,SAAS,KAAE,CAAC,KAAK,CAAC,EAAE,OAAO,GAAE,CAAC;QAC1D,OAAO,IAAI,SAAS,CAAC,SAAoF,CAAC,CAAC;IAC/G,CAAC;CACJ","sourcesContent":["import { isMemoized, memoize, Memoized } from \"../common/memoize\";\nimport { PartialContainer } from \"./PartialContainer\";\nimport { AddService, InjectableFunction, ValidTokens } from \"./types\";\n\ntype MaybeMemoizedFactories<Services> = {\n    [K in keyof Services]:\n        | ((c: Container<Services>) => Services[K])\n        | Memoized<(c: Container<Services>) => Services[K]>;\n};\n\nexport type Factories<Services> = {\n    [K in keyof Services]: Memoized<(c: Container<Services>) => Services[K]>;\n};\n\nexport const CONTAINER = \"$container\";\nexport type ContainerToken = typeof CONTAINER;\n\n/**\n * A Container of values, indexed each by a unique token, which can be used throughout CameraKit. This is how CameraKit\n * implements simple dependency injection.\n *\n * Dependency injection is a way to decouple the *use* of a dependency from the *creation* of that dependency. This\n * improves modularity and re-usability, since components only care about the *interfaces* of dependencies (since that\n * determines their use) and not about their concrete creation. New implementations of a particular dependency may be\n * provided without the need to change any of the consumers of that dependency.\n *\n * There are a few commonly-used terms used when talking about dependency injection:\n *\n *   - Container (or Injector): Maintains a registry of all available Services and understands how to create them.\n *   - Service: Anything that can be provided by the Container is called a Service – this can be a value of any type.\n *   - Token: Each Service is associated with a unique name, or Token. In order to obtain a Service from the Container,\n *     the consumer must provide the Token corresponding to that Service.\n *   - InjectableFunction: Services are created by InjectableFunctions. When adding a Service to a Container, the\n *     Service provider gives the Container a InjectableFunction which, when called will return the Service. These\n *     InjectableFunctions may themselves use other Services, which will be passed to them as arguments.\n *\n * Services are, by default, singletons – that is, each call to `get()` a particular Service will return a reference\n * to the same value. In other words, InjectableFunctions are only invoked once. If multiple instances of a Service are\n * desired, a new Container can be created using the `copy([Token])` method – passing a Token to this method forces the\n * new Container to recreate the corresponding Service (the InjectableFunction will be invoked again). We say that the\n * Service is then \"scoped\" to the new Container.\n *\n *\n * One common downside of many dependency injection implementations is that the dependency graph formed by the various\n * Services can only be validated at runtime. That is, if a dependency is missing or a circular dependency is found, the\n * developer must wait until runtime to discover the error. These errors can often be confusing and hard to debug.\n *\n * This implementation eliminates this issue by moving these sorts of errors to compile time. If an unknown dependency\n * is used in a InjectableFunction, for example, the code simply won't compile.\n *\n * To achieve this, we do lose the ability to implicitly define the dependency graph, as is common with many dependency\n * injection frameworks that employ decorators to define Services and their dependencies. Instead, the dependency graph\n * must be constructed explicitly, step-by-step, via successive calls to the `provide()` method. This is a suitable\n * trade-off for CameraKit, as there are a relatively small number of Services.\n *\n * Here's a simple example of Container usage:\n * ```ts\n * const fooFactory = Injectable('Foo', () => new Foo())\n * const barFactory = Injectable('Bar', ['Foo'] as const, (foo: Foo) => new Bar(foo))\n * const container = Container.empy()\n *   .provide(fooFactory)\n *   .provide(barFactory)\n *\n * const bar: Bar = container.get('Bar')\n * ```\n */\n/** @internal */\nexport class Container<Services = {}> {\n    private readonly factories: Factories<Services>;\n\n    constructor(factories: MaybeMemoizedFactories<Services>) {\n        this.factories = {} as Factories<Services>;\n        for (const k in factories) {\n            const fn = factories[k];\n            if (isMemoized(fn)) this.factories[k] = fn;\n            else this.factories[k] = memoize(fn);\n        }\n    }\n\n    /**\n     * Create a new [Container] by providing a [PartialContainer] that has no dependencies.\n     */\n    static provides<Services>(container: PartialContainer<Services, {}> | Container<Services>): Container<Services>;\n\n    /**\n     * Create a new [Container] by providing a Service that has no dependencies.\n     */\n    static provides<Token extends string, Service>(\n        fn: InjectableFunction<{}, [], Token, Service>\n    ): Container<AddService<{}, Token, Service>>;\n\n    static provides(\n        fnOrContainer: InjectableFunction<{}, [], string, any> | PartialContainer<any, {}> | Container<any>\n    ): Container<any> {\n        // Although the `provides` method has overloads that match both members of the union type separately, it does\n        // not match the union type itself, so the compiler forces us to branch and handle each type within the union\n        // separately. (Maybe in the future the compiler will decide to infer this, but for now this is necessary.)\n        if (fnOrContainer instanceof PartialContainer) return new Container({}).provides(fnOrContainer);\n        if (fnOrContainer instanceof Container) return new Container({}).provides(fnOrContainer);\n        return new Container({}).provides(fnOrContainer);\n    }\n\n    /**\n     * Create a copy of this Container, optionally providing a list of Services which will be scoped to the copy.\n     *\n     * This can be useful, for example, if different parts of an application wish to use the same Service interface, but\n     * do not want to share a reference to same Service instance.\n     *\n     * Say we have a Service which manages a list of Users. Our application wishes to display two lists of Users, which\n     * may be edited independently. In this case it may be desirable to create a Container for each list component, with\n     * the UserList Service scoped to those Containers – that way, each list component gets a unique copy of the\n     * UserList Service that can be edited independently of the other.\n     *\n     * @param scopedServices A list of Tokens identifying Services which will be scoped to the new Container – that is,\n     * if those Services had already been created by the source Container, they will be re-created by their Factory\n     * functions when provided by the new Container.\n     * @returns A new copy of this Container, sharing all of this Container's Services. Services corresponding to any\n     * Tokens passed to this method will be re-created by the new Container (i.e. they become \"scoped\" to the new\n     * Container).\n     */\n    copy<Tokens extends readonly (keyof Services)[]>(scopedServices?: Tokens): Container<Services> {\n        const factories: MaybeMemoizedFactories<Services> = { ...this.factories };\n\n        // We \"un-memoize\" scoped Service InjectableFunctions so they will create a new copy of their Service when\n        // provided by the new Container – we re-memoize them so the new Container will itself only create one Service\n        // instance.\n        (scopedServices || []).forEach((token: keyof Services) => {\n            factories[token] = this.factories[token].delegate;\n        });\n        return new Container(factories);\n    }\n\n    /**\n     * Gets a reference to this Container.\n     *\n     * @param token The CONTAINER token.\n     * @returns This Container.\n     */\n    get(token: ContainerToken): this;\n\n    /**\n     * Get a specific Service provided by this Container.\n     *\n     * @param token A unique string corresponding to a Service\n     * @returns A Service corresponding to the given Token.\n     */\n    get<Token extends keyof Services>(token: Token): Services[Token];\n\n    get(token: ContainerToken | keyof Services): this | Services[keyof Services] {\n        if (token === CONTAINER) return this;\n        const factory = this.factories[token];\n        if (!factory) {\n            throw new Error(\n                `[Container::get] Could not find Service for Token \"${String(token)}\". This should've caused a ` +\n                    \"compile-time error. If the Token is 'undefined', check all your calls to the Injectable \" +\n                    \"function. Make sure you define dependencies using string literals or string constants that are \" +\n                    \"definitely initialized before the call to Injectable.\"\n            );\n        }\n        return factory(this);\n    }\n\n    /**\n     * Run the services in this [PartialContainer]. \"Run\" simply means that [Container::get] will be called for each\n     * Service, which invokes that Service's factory function, creating the Service.\n     *\n     * This may be useful e.g. if services need to initialize themselves, since generally a Service factory is only\n     * invoked when the Service is needed.\n     *\n     * Note this method cannot be used to add services to a Container. – that is, calling this method does not provide\n     * the services in a new Container.\n     *\n     * @param container Optionally provide a [PartialContainer], which will be used as a filter – the only services\n     * from *this* container that will run are those with a token that is also present in this PartialContainer.\n     * @returns No mutation is done to the Container, it is returned as-is (convenient for chaining).\n     */\n    run<AdditionalServices, Dependencies, FulfilledDependencies extends Dependencies>(\n        // FullfilledDependencies is assignable to Dependencies -- by specifying Container<FulfilledDependencies> as the\n        // `this` type, we ensure this Container can provide all the Dependencies required by the PartialContainer.\n        this: Container<FulfilledDependencies>,\n        container: PartialContainer<AdditionalServices, Dependencies>\n    ): this;\n\n    /**\n     * Run the given Service. \"Run\" simply means that [Container::get] will be called for this Service, which invokes\n     * the Service's factory function, creating the Service.\n     *\n     * This may be useful e.g. if services need to initialize themselves, since generally a Service factory is only\n     * invoked when the Service is needed.\n     *\n     * Note this method cannot be used to add services to a Container. – that is, calling this method does not provide\n     * the services in a new Container.\n     *\n     * @param fn Optionally provide an [InjectableFunction], which will be used as a filter – the only services\n     * from *this* container that will run are those with a token that is also present in this PartialContainer.\n     * @returns No mutation is done to the Container, it is returned as-is (convenient for chaining).\n     */\n    run<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(\n        fn: InjectableFunction<Services, Tokens, Token, Service>\n    ): this;\n\n    run<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service, AdditionalServices>(\n        fnOrContainer:\n            | InjectableFunction<Services, Tokens, Token, Service>\n            | PartialContainer<AdditionalServices, Services>\n    ): this {\n        if (fnOrContainer instanceof PartialContainer) {\n            const runnableContainer = this.provides(fnOrContainer);\n            for (const token of fnOrContainer.getTokens()) {\n                runnableContainer.get(token);\n            }\n        } else {\n            this.provides(fnOrContainer).get(fnOrContainer.token);\n        }\n        return this;\n    }\n\n    /**\n     * Create a new Container from this Container with additional services from a given [PartialContainer].\n     *\n     * Services in the provided PartialContainer take precedence if there are service token conflicts.\n     *\n     * Services from the provided PartialContainer become scoped to the new Container – that is, if PartialContainer A\n     * is provided to Container X and Container Y, each resultant Container will contain its own copy of the services\n     * from PartialContainer A.\n     *\n     * @param container A [PartialContainer] providing additional services.\n     */\n    provides<AdditionalServices, Dependencies, FulfilledDependencies extends Dependencies>(\n        // FullfilledDependencies is assignable to Dependencies -- by specifying Container<FulfilledDependencies> as the\n        // `this` type, we ensure this Container can provide all the Dependencies required by the PartialContainer.\n        this: Container<FulfilledDependencies>,\n        container: PartialContainer<AdditionalServices, Dependencies>\n    ): Container<Services & AdditionalServices>;\n\n    /**\n     * Creates a new Container from this Container with additional services from another Container.\n     *\n     * Services in the provided PartialContainer take precedence if there are service token conflicts.\n     *\n     * Services from the provided Container become scoped to both Containers (the one from which they were provided\n     * and the new Container returned by this method) - that is, if Container A is provided to Container B,\n     * they will share the same instances of any Services provided by Container A.\n     * If Container B should re-create new instances of the Services from Container A,\n     * Container A must first be copied before providing it here.\n     *\n     * @param container A [Container] providing additional services.\n     */\n    provides<AdditionalServices>(container: Container<AdditionalServices>): Container<Services & AdditionalServices>;\n\n    /**\n     * Create a new Container 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     * If any of these required dependencies are missing from the Container (or if there is a mismatch between the types\n     * of those dependencies and the arguments of the InjectableFunction), a compiler error will be raised.\n     *\n     * @param fn A factory function, taking dependencies as arguments, which returns the Service.\n     */\n    provides<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(\n        fn: InjectableFunction<Services, Tokens, Token, Service>\n    ): Container<AddService<Services, Token, Service>>;\n\n    provides<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service, AdditionalServices>(\n        fnOrContainer:\n            | InjectableFunction<Services, Tokens, Token, Service>\n            | PartialContainer<AdditionalServices, Services>\n            | Container<AdditionalServices>\n    ): Container<any> {\n        if (fnOrContainer instanceof PartialContainer || fnOrContainer instanceof Container) {\n            const factories =\n                fnOrContainer instanceof PartialContainer ? fnOrContainer.getFactories(this) : fnOrContainer.factories;\n            // Safety: `this.factories` and `factories` are both properly type checked, so merging them produces\n            // a Factories object with keys from both Services and AdditionalServices. The compiler is unable to\n            // infer that Factories<A> & Factories<B> == Factories<A & B>, so the cast is required.\n            return new Container({\n                ...this.factories,\n                ...factories,\n            } as unknown as MaybeMemoizedFactories<Services & AdditionalServices>);\n        }\n        return this.providesService(fnOrContainer);\n    }\n\n    private providesService<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(\n        fn: InjectableFunction<Services, Tokens, Token, Service>\n    ): Container<AddService<Services, Token, Service>> {\n        const token = fn.token;\n        const dependencies: readonly any[] = fn.dependencies;\n\n        const factory = memoize((container: Container<Services>) => {\n            return fn(\n                ...(dependencies.map((t) => {\n                    // To support overwriting an already-existing service with a new implementation, it should be\n                    // possibleto do `provide(A, [A], a => createNewServiceFromOld(a))` – that is, inject a dependency\n                    // with the same token as this service's token.\n                    //\n                    // To avoid a circular dependency (in which the factory for service A depends on itself), we always\n                    // use the service defined in the *parent* container (i.e. this) when injecting a dependency with\n                    // the same token as the service we're providing. If we did not do this, calling `container.get(t)`\n                    // would result in an infinite loop.\n                    return t === token ? this.get(t) : container.get(t);\n                }) as any)\n            );\n        });\n\n        // Safety: `token` and `factory` are property type checked, so extending `this.factories` produces a\n        // MaybeMemoizedFactories object with the expected set of services – but when using the spread operation to\n        // merge two objects, the compiler widens the Token type to string. So we must re-narrow via casting.\n        const factories = { ...this.factories, [token]: factory };\n        return new Container(factories as unknown as MaybeMemoizedFactories<AddService<Services, Token, Service>>);\n    }\n}\n"]}

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

@@ -1,19 +1,23 @@
-import { Container, Factories } from "./Container";
+import { Memoized } from "../common/memoize";
+import { Container } from "./Container";
 import { AddService, InjectableFunction, ServicesFromTokenizedParams, ValidTokens } from "./types";
-declare type AddDependencies<ParentDependencies, Dependencies> = ParentDependencies extends any ? {
+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 ? {
+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> = {
+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> = {
+type Injectables<Services, Dependencies> = {
     [K in keyof Services]: K extends string ? InjectableFunction<Services & Dependencies, readonly ValidTokens<Services & Dependencies>[], K, Services[K]> : never;
 };
+type PartialContainerFactories<Services, Dependecies> = {
+    [K in keyof Services]: Memoized<(c: Container<Partial<Services> & Dependecies>) => Services[K]>;
+};
 /**
  * Similar to [Container], with the exception that Services may be provided to a PartialContainer which *does not*
  * contain all of that Services dependencies.
@@ -75,7 +79,7 @@ export declare class PartialContainer<Services = {}, Dependencies = {}> {
      *
      * @param parent A [Container] which provides all the required Dependencies of this PartialContainer.
      */
-    getFactories(parent: Container<Dependencies>): Factories<Services>;
+    getFactories(parent: Container<Dependencies>): PartialContainerFactories<Services, Dependencies>;
     getTokens(): Array<keyof Services>;
 }
 export {};

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

@@ -1 +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"]}
+{"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,EAAY,MAAM,mBAAmB,CAAC;AAwCtD;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CACgD,CAAC;IAC3D,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, Memoized } from \"../common/memoize\";\nimport { Container } 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\ntype PartialContainerFactories<Services, Dependecies> = {\n    [K in keyof Services]: Memoized<(c: Container<Partial<Services> & Dependecies>) => Services[K]>;\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>): PartialContainerFactories<Services, Dependencies> {\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 PartialContainerFactories<Services, Dependencies>;\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

@@ -23,7 +23,7 @@ import { ServicesFromInjectables } from "./types";
 /**
  * All services available to be customized by client app.
  */
-export declare type PublicServices = ServicesFromInjectables<[
+export type PublicServices = ServicesFromInjectables<[
     ReturnType<typeof createCameraKitConfigurationFactory>,
     typeof defaultFetchHandlerFactory,
     typeof remoteMediaAssetLoaderFactory,
@@ -42,7 +42,7 @@ export declare type PublicServices = ServicesFromInjectables<[
  * 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 = {
+export type RootServices = {
     [lensCoreFactory.token]: LensCoreModule;
 } & PublicServices & ServicesFromInjectables<[
     typeof metricsEventTargetFactory,

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

@@ -1,14 +1,14 @@
 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;
+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 declare type ValidTokens<Services> = ContainerToken | keyof Services;
+export 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>[]> = {
+export type CorrespondingServices<Services, Tokens extends readonly ValidTokens<Services>[]> = {
     [K in keyof Tokens]: Tokens[K] extends ValidTokens<Services> ? CorrespondingService<Services, Tokens[K]> : never;
 };
 /**
@@ -22,13 +22,13 @@ export declare type CorrespondingServices<Services, Tokens extends readonly Vali
  * 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>[] ? {
+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 declare type AnyInjectable = InjectableFunction<any, readonly string[], string, any>;
-export declare type ServicesFromInjectables<Injectables extends readonly AnyInjectable[]> = {
+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;
     }>>;
@@ -36,7 +36,7 @@ export declare type ServicesFromInjectables<Injectables extends readonly AnyInje
 /**
  * Add a Service with a Token to an existing set of Services.
  */
-export declare type AddService<ParentServices, Token extends string, Service> = ParentServices extends any ? {
+export type AddService<ParentServices, Token extends string, Service> = ParentServices extends any ? {
     [K in keyof ParentServices | Token]: K extends keyof ParentServices ? ParentServices[K] : Service;
 } : never;
 /**
@@ -50,7 +50,7 @@ export declare type AddService<ParentServices, Token extends string, Service> =
  * 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 ? {
+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 {};

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

@@ -1 +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"]}
+{"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 } & ServicesFromTokenizedParams<\n                      RemainingTokens,\n                      RemainingParams\n                  >\n                : never\n            : never\n        : never\n    : never;\n"]}

package/lib/environment.json

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

package/lib/events/TypedCustomEvent.d.ts

@@ -1,4 +1,4 @@
-export declare type EventOfType<K extends string, Event extends TypedCustomEvent> = Extract<Event, TypedCustomEvent<K, any>>;
+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

package/lib/events/TypedEventTarget.d.ts

@@ -1,12 +1,12 @@
 import { EventOfType, TypedCustomEvent } from "./TypedCustomEvent";
-export declare type TypedEventListener<Event extends TypedCustomEvent> = (evt: Event) => void;
+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 declare type EventsFromTarget<Target extends TypedEventTarget> = Target extends TypedEventTarget<infer Events> ? Events : never;
+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

package/lib/events/scan.d.ts

@@ -12,4 +12,4 @@ import { EventsFromTarget, TypedEventTarget } from "./TypedEventTarget";
  * 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>>;
+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>>;

package/lib/events/scan.js

@@ -19,9 +19,9 @@ export const scan = (seedState) => (source, eventTypes, accumulator) => {
         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'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;

package/lib/events/scan.js.map

@@ -1 +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"]}
+{"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,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;IAEF,iGAAiG;IACjG,6FAA6F;IAC7F,8DAA8D;IAC9D,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,IAAmD,EAAE,EAAE;YAC5E,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,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 { 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 =\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 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/UriHandlers.d.ts

@@ -27,7 +27,7 @@ export interface UriHandler {
 /**
  * Array of {@link UriHandler} objects.
  */
-export declare type UriHandlers = UriHandler[];
+export type UriHandlers = UriHandler[];
 /**
  * An extension point for client URI handlers.
  */

package/lib/generated-proto/blizzard/cameraKitEvents.d.ts

@@ -5592,12 +5592,12 @@ export declare enum KitType {
     CAMERA_KIT_WEB = 10,
     UNRECOGNIZED = -1
 }
-export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;
-export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
     [K in keyof P]: Exact<P[K], I[K]>;
 } & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
-declare type KeysOfUnion<T> = T extends T ? keyof T : never;
-declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export {};

package/lib/generated-proto/pb_schema/camera_kit/v3/business_events.d.ts

@@ -81,8 +81,8 @@ export declare const ExtensionEventBase: {
         sessionId?: string | undefined;
     } & Record<Exclude<keyof I, keyof ExtensionEventBase>, never>>(object: I): ExtensionEventBase;
 };
-declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;
 } ? {
     [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
@@ -91,8 +91,8 @@ export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<inf
 } : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;
-declare type KeysOfUnion<T> = T extends T ? keyof T : never;
-export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
     [K in keyof P]: Exact<P[K], I[K]>;
 } & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
 export {};

package/lib/generated-proto/pb_schema/camera_kit/v3/business_events.js

@@ -135,7 +135,7 @@ function createBaseExtensionEventBase() {
         cameraKitFlavor: CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET,
         appId: "",
         deviceConnectivity: CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET,
-        sessionId: ""
+        sessionId: "",
     };
 }
 export const ExtensionEventBase = {
@@ -198,7 +198,7 @@ export const ExtensionEventBase = {
             deviceConnectivity: isSet(object.deviceConnectivity)
                 ? cameraKitConnectivityTypeFromJSON(object.deviceConnectivity)
                 : CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET,
-            sessionId: isSet(object.sessionId) ? String(object.sessionId) : ""
+            sessionId: isSet(object.sessionId) ? String(object.sessionId) : "",
         };
     },
     toJSON(message) {
@@ -231,7 +231,7 @@ export const ExtensionEventBase = {
             (_j = object.deviceConnectivity) !== null && _j !== void 0 ? _j : CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET;
         message.sessionId = (_k = object.sessionId) !== null && _k !== void 0 ? _k : "";
         return message;
-    }
+    },
 };
 var globalThis = (() => {
     if (typeof globalThis !== "undefined")

package/lib/generated-proto/pb_schema/camera_kit/v3/business_events.js.map

@@ -1 +1 @@
-{"version":3,"file":"business_events.js","sourceRoot":"","sources":["../../../../../src/generated-proto/pb_schema/camera_kit/v3/business_events.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,GAAG,MAAM,oBAAoB,CAAC;AACrC,MAAM,CAAC,MAAM,eAAe,GAAG,uBAAuB,CAAC;AACvD,wDAAwD;AACxD,MAAM,CAAN,IAAY,eAQX;AARD,WAAY,eAAe;IACvB,wDAAwD;IACxD,sEAAmD,CAAA;IACnD,6CAA6C;IAC7C,sEAAmD,CAAA;IACnD,iDAAiD;IACjD,0EAAuD,CAAA;IACvD,gDAA6B,CAAA;AACjC,CAAC,EARW,eAAe,KAAf,eAAe,QAQ1B;AACD,MAAM,UAAU,uBAAuB,CAAC,MAAW;IAC/C,QAAQ,MAAM,EAAE;QACZ,KAAK,CAAC,CAAC;QACP,KAAK,yBAAyB;YAC1B,OAAO,eAAe,CAAC,uBAAuB,CAAC;QACnD,KAAK,CAAC,CAAC;QACP,KAAK,yBAAyB;YAC1B,OAAO,eAAe,CAAC,uBAAuB,CAAC;QACnD,KAAK,CAAC,CAAC;QACP,KAAK,2BAA2B;YAC5B,OAAO,eAAe,CAAC,yBAAyB,CAAC;QACrD,KAAK,CAAC,CAAC,CAAC;QACR,KAAK,cAAc,CAAC;QACpB;YACI,OAAO,eAAe,CAAC,YAAY,CAAC;KAC3C;AACL,CAAC;AACD,MAAM,UAAU,qBAAqB,CAAC,MAAuB;IACzD,QAAQ,MAAM,EAAE;QACZ,KAAK,eAAe,CAAC,uBAAuB;YACxC,OAAO,yBAAyB,CAAC;QACrC,KAAK,eAAe,CAAC,uBAAuB;YACxC,OAAO,yBAAyB,CAAC;QACrC,KAAK,eAAe,CAAC,yBAAyB;YAC1C,OAAO,2BAA2B,CAAC;QACvC;YACI,OAAO,SAAS,CAAC;KACxB;AACL,CAAC;AACD,MAAM,UAAU,uBAAuB,CAAC,MAAuB;IAC3D,QAAQ,MAAM,EAAE;QACZ,KAAK,eAAe,CAAC,uBAAuB;YACxC,OAAO,CAAC,CAAC;QACb,KAAK,eAAe,CAAC,uBAAuB;YACxC,OAAO,CAAC,CAAC;QACb,KAAK,eAAe,CAAC,yBAAyB;YAC1C,OAAO,CAAC,CAAC;QACb;YACI,OAAO,CAAC,CAAC;KAChB;AACL,CAAC;AACD,gEAAgE;AAChE,MAAM,CAAN,IAAY,yBAYX;AAZD,WAAY,yBAAyB;IACjC,8EAA8E;IAC9E,sGAAyE,CAAA;IACzE,iEAAiE;IACjE,oGAAuE,CAAA;IACvE,qEAAqE;IACrE,wGAA2E,CAAA;IAC3E,+EAA+E;IAC/E,kHAAqF,CAAA;IACrF,2EAA2E;IAC3E,8GAAiF,CAAA;IACjF,0DAA6B,CAAA;AACjC,CAAC,EAZW,yBAAyB,KAAzB,yBAAyB,QAYpC;AACD,MAAM,UAAU,iCAAiC,CAAC,MAAW;IACzD,QAAQ,MAAM,EAAE;QACZ,KAAK,CAAC,CAAC;QACP,KAAK,oCAAoC;YACrC,OAAO,yBAAyB,CAAC,kCAAkC,CAAC;QACxE,KAAK,CAAC,CAAC;QACP,KAAK,mCAAmC;YACpC,OAAO,yBAAyB,CAAC,iCAAiC,CAAC;QACvE,KAAK,CAAC,CAAC;QACP,KAAK,qCAAqC;YACtC,OAAO,yBAAyB,CAAC,mCAAmC,CAAC;QACzE,KAAK,CAAC,CAAC;QACP,KAAK,0CAA0C;YAC3C,OAAO,yBAAyB,CAAC,wCAAwC,CAAC;QAC9E,KAAK,CAAC,CAAC;QACP,KAAK,wCAAwC;YACzC,OAAO,yBAAyB,CAAC,sCAAsC,CAAC;QAC5E,KAAK,CAAC,CAAC,CAAC;QACR,KAAK,cAAc,CAAC;QACpB;YACI,OAAO,yBAAyB,CAAC,YAAY,CAAC;KACrD;AACL,CAAC;AACD,MAAM,UAAU,+BAA+B,CAAC,MAAiC;IAC7E,QAAQ,MAAM,EAAE;QACZ,KAAK,yBAAyB,CAAC,kCAAkC;YAC7D,OAAO,oCAAoC,CAAC;QAChD,KAAK,yBAAyB,CAAC,iCAAiC;YAC5D,OAAO,mCAAmC,CAAC;QAC/C,KAAK,yBAAyB,CAAC,mCAAmC;YAC9D,OAAO,qCAAqC,CAAC;QACjD,KAAK,yBAAyB,CAAC,wCAAwC;YACnE,OAAO,0CAA0C,CAAC;QACtD,KAAK,yBAAyB,CAAC,sCAAsC;YACjE,OAAO,wCAAwC,CAAC;QACpD;YACI,OAAO,SAAS,CAAC;KACxB;AACL,CAAC;AACD,MAAM,UAAU,iCAAiC,CAAC,MAAiC;IAC/E,QAAQ,MAAM,EAAE;QACZ,KAAK,yBAAyB,CAAC,kCAAkC;YAC7D,OAAO,CAAC,CAAC;QACb,KAAK,yBAAyB,CAAC,iCAAiC;YAC5D,OAAO,CAAC,CAAC;QACb,KAAK,yBAAyB,CAAC,mCAAmC;YAC9D,OAAO,CAAC,CAAC;QACb,KAAK,yBAAyB,CAAC,wCAAwC;YACnE,OAAO,CAAC,CAAC;QACb,KAAK,yBAAyB,CAAC,sCAAsC;YACjE,OAAO,CAAC,CAAC;QACb;YACI,OAAO,CAAC,CAAC;KAChB;AACL,CAAC;AAwBD,SAAS,4BAA4B;IACjC,OAAO;QACH,aAAa,EAAE,EAAE;QACjB,gBAAgB,EAAE,EAAE;QACpB,aAAa,EAAE,CAAC;QAChB,gBAAgB,EAAE,EAAE;QACpB,eAAe,EAAE,EAAE;QACnB,WAAW,EAAE,EAAE;QACf,eAAe,EAAE,eAAe,CAAC,uBAAuB;QACxD,KAAK,EAAE,EAAE;QACT,kBAAkB,EAAE,yBAAyB,CAAC,kCAAkC;QAChF,SAAS,EAAE,EAAE;KAChB,CAAC;AACN,CAAC;AACD,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,MAAM,CAAC,KAA8B,EAAE,MAAe;QAClD,MAAM,MAAM,GAAG,KAAK,YAAY,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3E,IAAI,GAAG,GAAG,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC;QAClE,MAAM,OAAO,GAAG,4BAA4B,EAAE,CAAC;QAC/C,OAAO,MAAM,CAAC,GAAG,GAAG,GAAG,EAAE;YACrB,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;YAC5B,QAAQ,GAAG,KAAK,CAAC,EAAE;gBACf,KAAK,CAAC;oBACF,OAAO,CAAC,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBACxC,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBAC3C,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,aAAa,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,EAAU,CAAC,CAAC;oBAC7D,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBAC3C,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBAC1C,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBACtC,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,eAAe,GAAG,uBAAuB,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;oBAClE,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBAChC,MAAM;gBACV,KAAK,CAAC;oBACF,OAAO,CAAC,kBAAkB,GAAG,iCAAiC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;oBAC/E,MAAM;gBACV,KAAK,EAAE;oBACH,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;oBACpC,MAAM;gBACV;oBACI,MAAM,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;oBACzB,MAAM;aACb;SACJ;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,QAAQ,CAAC,MAAW;QAChB,OAAO;YACH,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE;YAC9E,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAAE;YACvF,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7E,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAAE;YACvF,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE;YACpF,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE;YACxE,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,eAAe,CAAC;gBAC1C,CAAC,CAAC,uBAAuB,CAAC,MAAM,CAAC,eAAe,CAAC;gBACjD,CAAC,CAAC,eAAe,CAAC,uBAAuB;YAC7C,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;YACtD,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,kBAAkB,CAAC;gBAChD,CAAC,CAAC,iCAAiC,CAAC,MAAM,CAAC,kBAAkB,CAAC;gBAC9D,CAAC,CAAC,yBAAyB,CAAC,kCAAkC;YAClE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;SACrE,CAAC;IACN,CAAC;IACD,MAAM,CAAC,OAA2B;QAC9B,MAAM,GAAG,GAAQ,EAAE,CAAC;QACpB,OAAO,CAAC,aAAa,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QACnF,OAAO,CAAC,gBAAgB,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAC5F,OAAO,CAAC,aAAa,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC;QAC/F,OAAO,CAAC,gBAAgB,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAC5F,OAAO,CAAC,eAAe,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QACzF,OAAO,CAAC,WAAW,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QAC7E,OAAO,CAAC,eAAe,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,qBAAqB,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC;QAChH,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC3D,OAAO,CAAC,kBAAkB,KAAK,SAAS;YACpC,CAAC,GAAG,CAAC,kBAAkB,GAAG,+BAA+B,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAC3F,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QACvE,OAAO,GAAG,CAAC;IACf,CAAC;IACD,WAAW,CAAsD,MAAS;;QACtE,MAAM,OAAO,GAAG,4BAA4B,EAAE,CAAC;QAC/C,OAAO,CAAC,aAAa,GAAG,MAAA,MAAM,CAAC,aAAa,mCAAI,EAAE,CAAC;QACnD,OAAO,CAAC,gBAAgB,GAAG,MAAA,MAAM,CAAC,gBAAgB,mCAAI,EAAE,CAAC;QACzD,OAAO,CAAC,aAAa,GAAG,MAAA,MAAM,CAAC,aAAa,mCAAI,CAAC,CAAC;QAClD,OAAO,CAAC,gBAAgB,GAAG,MAAA,MAAM,CAAC,gBAAgB,mCAAI,EAAE,CAAC;QACzD,OAAO,CAAC,eAAe,GAAG,MAAA,MAAM,CAAC,eAAe,mCAAI,EAAE,CAAC;QACvD,OAAO,CAAC,WAAW,GAAG,MAAA,MAAM,CAAC,WAAW,mCAAI,EAAE,CAAC;QAC/C,OAAO,CAAC,eAAe,GAAG,MAAA,MAAM,CAAC,eAAe,mCAAI,eAAe,CAAC,uBAAuB,CAAC;QAC5F,OAAO,CAAC,KAAK,GAAG,MAAA,MAAM,CAAC,KAAK,mCAAI,EAAE,CAAC;QACnC,OAAO,CAAC,kBAAkB;YACtB,MAAA,MAAM,CAAC,kBAAkB,mCAAI,yBAAyB,CAAC,kCAAkC,CAAC;QAC9F,OAAO,CAAC,SAAS,GAAG,MAAA,MAAM,CAAC,SAAS,mCAAI,EAAE,CAAC;QAC3C,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ,CAAC;AAIF,IAAI,UAAU,GAAQ,CAAC,GAAG,EAAE;IACxB,IAAI,OAAO,UAAU,KAAK,WAAW;QACjC,OAAO,UAAU,CAAC;IACtB,IAAI,OAAO,IAAI,KAAK,WAAW;QAC3B,OAAO,IAAI,CAAC;IAChB,IAAI,OAAO,MAAM,KAAK,WAAW;QAC7B,OAAO,MAAM,CAAC;IAClB,IAAI,OAAO,MAAM,KAAK,WAAW;QAC7B,OAAO,MAAM,CAAC;IAClB,MAAM,gCAAgC,CAAC;AAC3C,CAAC,CAAC,EAAE,CAAC;AAeL,SAAS,YAAY,CAAC,IAAU;IAC5B,IAAI,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE;QAClC,MAAM,IAAI,UAAU,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC;KAC9E;IACD,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;AAC3B,CAAC;AACD,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;IACxB,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAW,CAAC;IAC5B,GAAG,CAAC,SAAS,EAAE,CAAC;CACnB;AACD,SAAS,KAAK,CAAC,KAAU;IACrB,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;AACjD,CAAC","sourcesContent":["/* eslint-disable */\nimport Long from \"long\";\nimport _m0 from \"protobufjs/minimal\";\nexport const protobufPackage = \"com.snap.camerakit.v3\";\n/** Camera kit flavor to be used in to Blizzard event */\nexport enum CameraKitFlavor {\n    /** CAMERA_KIT_FLAVOR_UNSET - Unset or unknown flavor */\n    CAMERA_KIT_FLAVOR_UNSET = \"CAMERA_KIT_FLAVOR_UNSET\",\n    /** CAMERA_KIT_FLAVOR_DEBUG - Debug flavor */\n    CAMERA_KIT_FLAVOR_DEBUG = \"CAMERA_KIT_FLAVOR_DEBUG\",\n    /** CAMERA_KIT_FLAVOR_RELEASE - Release flavor */\n    CAMERA_KIT_FLAVOR_RELEASE = \"CAMERA_KIT_FLAVOR_RELEASE\",\n    UNRECOGNIZED = \"UNRECOGNIZED\"\n}\nexport function cameraKitFlavorFromJSON(object: any): CameraKitFlavor {\n    switch (object) {\n        case 0:\n        case \"CAMERA_KIT_FLAVOR_UNSET\":\n            return CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET;\n        case 1:\n        case \"CAMERA_KIT_FLAVOR_DEBUG\":\n            return CameraKitFlavor.CAMERA_KIT_FLAVOR_DEBUG;\n        case 2:\n        case \"CAMERA_KIT_FLAVOR_RELEASE\":\n            return CameraKitFlavor.CAMERA_KIT_FLAVOR_RELEASE;\n        case -1:\n        case \"UNRECOGNIZED\":\n        default:\n            return CameraKitFlavor.UNRECOGNIZED;\n    }\n}\nexport function cameraKitFlavorToJSON(object: CameraKitFlavor): string {\n    switch (object) {\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET:\n            return \"CAMERA_KIT_FLAVOR_UNSET\";\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_DEBUG:\n            return \"CAMERA_KIT_FLAVOR_DEBUG\";\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_RELEASE:\n            return \"CAMERA_KIT_FLAVOR_RELEASE\";\n        default:\n            return \"UNKNOWN\";\n    }\n}\nexport function cameraKitFlavorToNumber(object: CameraKitFlavor): number {\n    switch (object) {\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET:\n            return 0;\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_DEBUG:\n            return 1;\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_RELEASE:\n            return 2;\n        default:\n            return 0;\n    }\n}\n/** Camera kit connectivity type to be used in Blizzard event */\nexport enum CameraKitConnectivityType {\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_UNSET - Unset or unknown connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_UNSET = \"CAMERA_KIT_CONNECTIVITY_TYPE_UNSET\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_WIFI - Wifi connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_WIFI = \"CAMERA_KIT_CONNECTIVITY_TYPE_WIFI\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE - Mobile connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE = \"CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE - Unreachable connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE = \"CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH - Bluetooth connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH = \"CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH\",\n    UNRECOGNIZED = \"UNRECOGNIZED\"\n}\nexport function cameraKitConnectivityTypeFromJSON(object: any): CameraKitConnectivityType {\n    switch (object) {\n        case 0:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_UNSET\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET;\n        case 1:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_WIFI\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_WIFI;\n        case 2:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE;\n        case 3:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE;\n        case 4:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH;\n        case -1:\n        case \"UNRECOGNIZED\":\n        default:\n            return CameraKitConnectivityType.UNRECOGNIZED;\n    }\n}\nexport function cameraKitConnectivityTypeToJSON(object: CameraKitConnectivityType): string {\n    switch (object) {\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_UNSET\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_WIFI:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_WIFI\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH\";\n        default:\n            return \"UNKNOWN\";\n    }\n}\nexport function cameraKitConnectivityTypeToNumber(object: CameraKitConnectivityType): number {\n    switch (object) {\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET:\n            return 0;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_WIFI:\n            return 1;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE:\n            return 2;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE:\n            return 3;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH:\n            return 4;\n        default:\n            return 0;\n    }\n}\n/** Extension base data */\nexport interface ExtensionEventBase {\n    /** CameraKit Extension name */\n    extensionName: string;\n    /** Full CameraKit Extension version */\n    extensionVersion: string;\n    /** Device cluster value. Android clients will receive it from COF/Configs endpoint. iOS will use manual mapping */\n    deviceCluster: number;\n    /** Full CameraKit SDK version (e.g. 0.2.0-12adb50.38) Major, Minor, Patch, Build version metadata */\n    cameraKitVersion: string;\n    /** Version of LensCore (e.g. 77) */\n    lensCoreVersion: string;\n    /** Model of the device (e.g. SM 955U) */\n    deviceModel: string;\n    /** Flavor of CameraKit: debug or release */\n    cameraKitFlavor: CameraKitFlavor;\n    /** BundleID/package of the app */\n    appId: string;\n    /** Device connectivity: wifi, mobile, unreachable, bluetooth */\n    deviceConnectivity: CameraKitConnectivityType;\n    /** Random UUID generated each time session created */\n    sessionId: string;\n}\nfunction createBaseExtensionEventBase(): ExtensionEventBase {\n    return {\n        extensionName: \"\",\n        extensionVersion: \"\",\n        deviceCluster: 0,\n        cameraKitVersion: \"\",\n        lensCoreVersion: \"\",\n        deviceModel: \"\",\n        cameraKitFlavor: CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET,\n        appId: \"\",\n        deviceConnectivity: CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET,\n        sessionId: \"\"\n    };\n}\nexport const ExtensionEventBase = {\n    decode(input: _m0.Reader | Uint8Array, length?: number): ExtensionEventBase {\n        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseExtensionEventBase();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.extensionName = reader.string();\n                    break;\n                case 2:\n                    message.extensionVersion = reader.string();\n                    break;\n                case 3:\n                    message.deviceCluster = longToNumber(reader.int64() as Long);\n                    break;\n                case 4:\n                    message.cameraKitVersion = reader.string();\n                    break;\n                case 5:\n                    message.lensCoreVersion = reader.string();\n                    break;\n                case 6:\n                    message.deviceModel = reader.string();\n                    break;\n                case 7:\n                    message.cameraKitFlavor = cameraKitFlavorFromJSON(reader.int32());\n                    break;\n                case 8:\n                    message.appId = reader.string();\n                    break;\n                case 9:\n                    message.deviceConnectivity = cameraKitConnectivityTypeFromJSON(reader.int32());\n                    break;\n                case 10:\n                    message.sessionId = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromJSON(object: any): ExtensionEventBase {\n        return {\n            extensionName: isSet(object.extensionName) ? String(object.extensionName) : \"\",\n            extensionVersion: isSet(object.extensionVersion) ? String(object.extensionVersion) : \"\",\n            deviceCluster: isSet(object.deviceCluster) ? Number(object.deviceCluster) : 0,\n            cameraKitVersion: isSet(object.cameraKitVersion) ? String(object.cameraKitVersion) : \"\",\n            lensCoreVersion: isSet(object.lensCoreVersion) ? String(object.lensCoreVersion) : \"\",\n            deviceModel: isSet(object.deviceModel) ? String(object.deviceModel) : \"\",\n            cameraKitFlavor: isSet(object.cameraKitFlavor)\n                ? cameraKitFlavorFromJSON(object.cameraKitFlavor)\n                : CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET,\n            appId: isSet(object.appId) ? String(object.appId) : \"\",\n            deviceConnectivity: isSet(object.deviceConnectivity)\n                ? cameraKitConnectivityTypeFromJSON(object.deviceConnectivity)\n                : CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET,\n            sessionId: isSet(object.sessionId) ? String(object.sessionId) : \"\"\n        };\n    },\n    toJSON(message: ExtensionEventBase): unknown {\n        const obj: any = {};\n        message.extensionName !== undefined && (obj.extensionName = message.extensionName);\n        message.extensionVersion !== undefined && (obj.extensionVersion = message.extensionVersion);\n        message.deviceCluster !== undefined && (obj.deviceCluster = Math.round(message.deviceCluster));\n        message.cameraKitVersion !== undefined && (obj.cameraKitVersion = message.cameraKitVersion);\n        message.lensCoreVersion !== undefined && (obj.lensCoreVersion = message.lensCoreVersion);\n        message.deviceModel !== undefined && (obj.deviceModel = message.deviceModel);\n        message.cameraKitFlavor !== undefined && (obj.cameraKitFlavor = cameraKitFlavorToJSON(message.cameraKitFlavor));\n        message.appId !== undefined && (obj.appId = message.appId);\n        message.deviceConnectivity !== undefined &&\n            (obj.deviceConnectivity = cameraKitConnectivityTypeToJSON(message.deviceConnectivity));\n        message.sessionId !== undefined && (obj.sessionId = message.sessionId);\n        return obj;\n    },\n    fromPartial<I extends Exact<DeepPartial<ExtensionEventBase>, I>>(object: I): ExtensionEventBase {\n        const message = createBaseExtensionEventBase();\n        message.extensionName = object.extensionName ?? \"\";\n        message.extensionVersion = object.extensionVersion ?? \"\";\n        message.deviceCluster = object.deviceCluster ?? 0;\n        message.cameraKitVersion = object.cameraKitVersion ?? \"\";\n        message.lensCoreVersion = object.lensCoreVersion ?? \"\";\n        message.deviceModel = object.deviceModel ?? \"\";\n        message.cameraKitFlavor = object.cameraKitFlavor ?? CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET;\n        message.appId = object.appId ?? \"\";\n        message.deviceConnectivity =\n            object.deviceConnectivity ?? CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET;\n        message.sessionId = object.sessionId ?? \"\";\n        return message;\n    }\n};\ndeclare var self: any | undefined;\ndeclare var window: any | undefined;\ndeclare var global: any | undefined;\nvar globalThis: any = (() => {\n    if (typeof globalThis !== \"undefined\")\n        return globalThis;\n    if (typeof self !== \"undefined\")\n        return self;\n    if (typeof window !== \"undefined\")\n        return window;\n    if (typeof global !== \"undefined\")\n        return global;\n    throw \"Unable to locate global object\";\n})();\ntype Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;\nexport type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {\n    $case: string;\n} ? {\n    [K in keyof Omit<T, \"$case\">]?: DeepPartial<T[K]>;\n} & {\n    $case: T[\"$case\"];\n} : T extends {} ? {\n    [K in keyof T]?: DeepPartial<T[K]>;\n} : Partial<T>;\ntype KeysOfUnion<T> = T extends T ? keyof T : never;\nexport type Exact<P, I extends P> = P extends Builtin ? P : P & {\n    [K in keyof P]: Exact<P[K], I[K]>;\n} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;\nfunction longToNumber(long: Long): number {\n    if (long.gt(Number.MAX_SAFE_INTEGER)) {\n        throw new globalThis.Error(\"Value is larger than Number.MAX_SAFE_INTEGER\");\n    }\n    return long.toNumber();\n}\nif (_m0.util.Long !== Long) {\n    _m0.util.Long = Long as any;\n    _m0.configure();\n}\nfunction isSet(value: any): boolean {\n    return value !== null && value !== undefined;\n}\n"]}
+{"version":3,"file":"business_events.js","sourceRoot":"","sources":["../../../../../src/generated-proto/pb_schema/camera_kit/v3/business_events.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\nimport Long from \"long\";\nimport _m0 from \"protobufjs/minimal\";\nexport const protobufPackage = \"com.snap.camerakit.v3\";\n/** Camera kit flavor to be used in to Blizzard event */\nexport enum CameraKitFlavor {\n    /** CAMERA_KIT_FLAVOR_UNSET - Unset or unknown flavor */\n    CAMERA_KIT_FLAVOR_UNSET = \"CAMERA_KIT_FLAVOR_UNSET\",\n    /** CAMERA_KIT_FLAVOR_DEBUG - Debug flavor */\n    CAMERA_KIT_FLAVOR_DEBUG = \"CAMERA_KIT_FLAVOR_DEBUG\",\n    /** CAMERA_KIT_FLAVOR_RELEASE - Release flavor */\n    CAMERA_KIT_FLAVOR_RELEASE = \"CAMERA_KIT_FLAVOR_RELEASE\",\n    UNRECOGNIZED = \"UNRECOGNIZED\"\n}\nexport function cameraKitFlavorFromJSON(object: any): CameraKitFlavor {\n    switch (object) {\n        case 0:\n        case \"CAMERA_KIT_FLAVOR_UNSET\":\n            return CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET;\n        case 1:\n        case \"CAMERA_KIT_FLAVOR_DEBUG\":\n            return CameraKitFlavor.CAMERA_KIT_FLAVOR_DEBUG;\n        case 2:\n        case \"CAMERA_KIT_FLAVOR_RELEASE\":\n            return CameraKitFlavor.CAMERA_KIT_FLAVOR_RELEASE;\n        case -1:\n        case \"UNRECOGNIZED\":\n        default:\n            return CameraKitFlavor.UNRECOGNIZED;\n    }\n}\nexport function cameraKitFlavorToJSON(object: CameraKitFlavor): string {\n    switch (object) {\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET:\n            return \"CAMERA_KIT_FLAVOR_UNSET\";\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_DEBUG:\n            return \"CAMERA_KIT_FLAVOR_DEBUG\";\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_RELEASE:\n            return \"CAMERA_KIT_FLAVOR_RELEASE\";\n        default:\n            return \"UNKNOWN\";\n    }\n}\nexport function cameraKitFlavorToNumber(object: CameraKitFlavor): number {\n    switch (object) {\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET:\n            return 0;\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_DEBUG:\n            return 1;\n        case CameraKitFlavor.CAMERA_KIT_FLAVOR_RELEASE:\n            return 2;\n        default:\n            return 0;\n    }\n}\n/** Camera kit connectivity type to be used in Blizzard event */\nexport enum CameraKitConnectivityType {\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_UNSET - Unset or unknown connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_UNSET = \"CAMERA_KIT_CONNECTIVITY_TYPE_UNSET\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_WIFI - Wifi connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_WIFI = \"CAMERA_KIT_CONNECTIVITY_TYPE_WIFI\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE - Mobile connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE = \"CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE - Unreachable connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE = \"CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE\",\n    /** CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH - Bluetooth connectivity type */\n    CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH = \"CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH\",\n    UNRECOGNIZED = \"UNRECOGNIZED\"\n}\nexport function cameraKitConnectivityTypeFromJSON(object: any): CameraKitConnectivityType {\n    switch (object) {\n        case 0:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_UNSET\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET;\n        case 1:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_WIFI\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_WIFI;\n        case 2:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE;\n        case 3:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE;\n        case 4:\n        case \"CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH\":\n            return CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH;\n        case -1:\n        case \"UNRECOGNIZED\":\n        default:\n            return CameraKitConnectivityType.UNRECOGNIZED;\n    }\n}\nexport function cameraKitConnectivityTypeToJSON(object: CameraKitConnectivityType): string {\n    switch (object) {\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_UNSET\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_WIFI:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_WIFI\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE\";\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH:\n            return \"CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH\";\n        default:\n            return \"UNKNOWN\";\n    }\n}\nexport function cameraKitConnectivityTypeToNumber(object: CameraKitConnectivityType): number {\n    switch (object) {\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET:\n            return 0;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_WIFI:\n            return 1;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_MOBILE:\n            return 2;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNREACHABLE:\n            return 3;\n        case CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_BLUETOOTH:\n            return 4;\n        default:\n            return 0;\n    }\n}\n/** Extension base data */\nexport interface ExtensionEventBase {\n    /** CameraKit Extension name */\n    extensionName: string;\n    /** Full CameraKit Extension version */\n    extensionVersion: string;\n    /** Device cluster value. Android clients will receive it from COF/Configs endpoint. iOS will use manual mapping */\n    deviceCluster: number;\n    /** Full CameraKit SDK version (e.g. 0.2.0-12adb50.38) Major, Minor, Patch, Build version metadata */\n    cameraKitVersion: string;\n    /** Version of LensCore (e.g. 77) */\n    lensCoreVersion: string;\n    /** Model of the device (e.g. SM 955U) */\n    deviceModel: string;\n    /** Flavor of CameraKit: debug or release */\n    cameraKitFlavor: CameraKitFlavor;\n    /** BundleID/package of the app */\n    appId: string;\n    /** Device connectivity: wifi, mobile, unreachable, bluetooth */\n    deviceConnectivity: CameraKitConnectivityType;\n    /** Random UUID generated each time session created */\n    sessionId: string;\n}\nfunction createBaseExtensionEventBase(): ExtensionEventBase {\n    return {\n        extensionName: \"\",\n        extensionVersion: \"\",\n        deviceCluster: 0,\n        cameraKitVersion: \"\",\n        lensCoreVersion: \"\",\n        deviceModel: \"\",\n        cameraKitFlavor: CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET,\n        appId: \"\",\n        deviceConnectivity: CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET,\n        sessionId: \"\",\n    };\n}\nexport const ExtensionEventBase = {\n    decode(input: _m0.Reader | Uint8Array, length?: number): ExtensionEventBase {\n        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseExtensionEventBase();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.extensionName = reader.string();\n                    break;\n                case 2:\n                    message.extensionVersion = reader.string();\n                    break;\n                case 3:\n                    message.deviceCluster = longToNumber(reader.int64() as Long);\n                    break;\n                case 4:\n                    message.cameraKitVersion = reader.string();\n                    break;\n                case 5:\n                    message.lensCoreVersion = reader.string();\n                    break;\n                case 6:\n                    message.deviceModel = reader.string();\n                    break;\n                case 7:\n                    message.cameraKitFlavor = cameraKitFlavorFromJSON(reader.int32());\n                    break;\n                case 8:\n                    message.appId = reader.string();\n                    break;\n                case 9:\n                    message.deviceConnectivity = cameraKitConnectivityTypeFromJSON(reader.int32());\n                    break;\n                case 10:\n                    message.sessionId = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromJSON(object: any): ExtensionEventBase {\n        return {\n            extensionName: isSet(object.extensionName) ? String(object.extensionName) : \"\",\n            extensionVersion: isSet(object.extensionVersion) ? String(object.extensionVersion) : \"\",\n            deviceCluster: isSet(object.deviceCluster) ? Number(object.deviceCluster) : 0,\n            cameraKitVersion: isSet(object.cameraKitVersion) ? String(object.cameraKitVersion) : \"\",\n            lensCoreVersion: isSet(object.lensCoreVersion) ? String(object.lensCoreVersion) : \"\",\n            deviceModel: isSet(object.deviceModel) ? String(object.deviceModel) : \"\",\n            cameraKitFlavor: isSet(object.cameraKitFlavor)\n                ? cameraKitFlavorFromJSON(object.cameraKitFlavor)\n                : CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET,\n            appId: isSet(object.appId) ? String(object.appId) : \"\",\n            deviceConnectivity: isSet(object.deviceConnectivity)\n                ? cameraKitConnectivityTypeFromJSON(object.deviceConnectivity)\n                : CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET,\n            sessionId: isSet(object.sessionId) ? String(object.sessionId) : \"\",\n        };\n    },\n    toJSON(message: ExtensionEventBase): unknown {\n        const obj: any = {};\n        message.extensionName !== undefined && (obj.extensionName = message.extensionName);\n        message.extensionVersion !== undefined && (obj.extensionVersion = message.extensionVersion);\n        message.deviceCluster !== undefined && (obj.deviceCluster = Math.round(message.deviceCluster));\n        message.cameraKitVersion !== undefined && (obj.cameraKitVersion = message.cameraKitVersion);\n        message.lensCoreVersion !== undefined && (obj.lensCoreVersion = message.lensCoreVersion);\n        message.deviceModel !== undefined && (obj.deviceModel = message.deviceModel);\n        message.cameraKitFlavor !== undefined && (obj.cameraKitFlavor = cameraKitFlavorToJSON(message.cameraKitFlavor));\n        message.appId !== undefined && (obj.appId = message.appId);\n        message.deviceConnectivity !== undefined &&\n            (obj.deviceConnectivity = cameraKitConnectivityTypeToJSON(message.deviceConnectivity));\n        message.sessionId !== undefined && (obj.sessionId = message.sessionId);\n        return obj;\n    },\n    fromPartial<I extends Exact<DeepPartial<ExtensionEventBase>, I>>(object: I): ExtensionEventBase {\n        const message = createBaseExtensionEventBase();\n        message.extensionName = object.extensionName ?? \"\";\n        message.extensionVersion = object.extensionVersion ?? \"\";\n        message.deviceCluster = object.deviceCluster ?? 0;\n        message.cameraKitVersion = object.cameraKitVersion ?? \"\";\n        message.lensCoreVersion = object.lensCoreVersion ?? \"\";\n        message.deviceModel = object.deviceModel ?? \"\";\n        message.cameraKitFlavor = object.cameraKitFlavor ?? CameraKitFlavor.CAMERA_KIT_FLAVOR_UNSET;\n        message.appId = object.appId ?? \"\";\n        message.deviceConnectivity =\n            object.deviceConnectivity ?? CameraKitConnectivityType.CAMERA_KIT_CONNECTIVITY_TYPE_UNSET;\n        message.sessionId = object.sessionId ?? \"\";\n        return message;\n    },\n};\ndeclare var self: any | undefined;\ndeclare var window: any | undefined;\ndeclare var global: any | undefined;\nvar globalThis: any = (() => {\n    if (typeof globalThis !== \"undefined\")\n        return globalThis;\n    if (typeof self !== \"undefined\")\n        return self;\n    if (typeof window !== \"undefined\")\n        return window;\n    if (typeof global !== \"undefined\")\n        return global;\n    throw \"Unable to locate global object\";\n})();\ntype Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;\nexport type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {\n    $case: string;\n} ? {\n    [K in keyof Omit<T, \"$case\">]?: DeepPartial<T[K]>;\n} & {\n    $case: T[\"$case\"];\n} : T extends {} ? {\n    [K in keyof T]?: DeepPartial<T[K]>;\n} : Partial<T>;\ntype KeysOfUnion<T> = T extends T ? keyof T : never;\nexport type Exact<P, I extends P> = P extends Builtin ? P : P & {\n    [K in keyof P]: Exact<P[K], I[K]>;\n} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;\nfunction longToNumber(long: Long): number {\n    if (long.gt(Number.MAX_SAFE_INTEGER)) {\n        throw new globalThis.Error(\"Value is larger than Number.MAX_SAFE_INTEGER\");\n    }\n    return long.toNumber();\n}\nif (_m0.util.Long !== Long) {\n    _m0.util.Long = Long as any;\n    _m0.configure();\n}\nfunction isSet(value: any): boolean {\n    return value !== null && value !== undefined;\n}\n"]}

package/lib/generated-proto/pb_schema/camera_kit/v3/export.d.ts

@@ -526,8 +526,8 @@ export interface Export {
      */
     ExportLensesById(request: ExportLensesByIdRequest): Promise<ExportLensesByIdResponse>;
 }
-declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;
 } ? {
     [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
@@ -536,8 +536,8 @@ export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<inf
 } : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;
-declare type KeysOfUnion<T> = T extends T ? keyof T : never;
-export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
     [K in keyof P]: Exact<P[K], I[K]>;
 } & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
 export {};