@snap/camera-kit 0.16.2 → 0.18.0

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

@@ -0,0 +1,177 @@
+import type { Memoized } from "../common/memoize";
+import { PartialContainer } from "./PartialContainer";
+import type { AddService, InjectableFunction, ValidTokens } from "./types";
+type MaybeMemoizedFactories<Services> = {
+    [K in keyof Services]: ((c: Container<Services>) => Services[K]) | Memoized<(c: Container<Services>) => Services[K]>;
+};
+export type Factories<Services> = {
+    [K in keyof Services]: Memoized<(c: Container<any>) => Services[K]>;
+};
+export declare const CONTAINER = "$container";
+export type ContainerToken = typeof CONTAINER;
+/**
+ * A Container of values, indexed each by a unique token, which can be used throughout CameraKit. This is how CameraKit
+ * implements simple dependency injection.
+ *
+ * Dependency injection is a way to decouple the *use* of a dependency from the *creation* of that dependency. This
+ * improves modularity and re-usability, since components only care about the *interfaces* of dependencies (since that
+ * determines their use) and not about their concrete creation. New implementations of a particular dependency may be
+ * provided without the need to change any of the consumers of that dependency.
+ *
+ * There are a few commonly-used terms used when talking about dependency injection:
+ *
+ *   - Container (or Injector): Maintains a registry of all available Services and understands how to create them.
+ *   - Service: Anything that can be provided by the Container is called a Service – this can be a value of any type.
+ *   - Token: Each Service is associated with a unique name, or Token. In order to obtain a Service from the Container,
+ *     the consumer must provide the Token corresponding to that Service.
+ *   - InjectableFunction: Services are created by InjectableFunctions. When adding a Service to a Container, the
+ *     Service provider gives the Container a InjectableFunction which, when called will return the Service. These
+ *     InjectableFunctions may themselves use other Services, which will be passed to them as arguments.
+ *
+ * Services are, by default, singletons – that is, each call to `get()` a particular Service will return a reference
+ * to the same value. In other words, InjectableFunctions are only invoked once. If multiple instances of a Service are
+ * desired, a new Container can be created using the `copy([Token])` method – passing a Token to this method forces the
+ * new Container to recreate the corresponding Service (the InjectableFunction will be invoked again). We say that the
+ * Service is then "scoped" to the new Container.
+ *
+ *
+ * One common downside of many dependency injection implementations is that the dependency graph formed by the various
+ * Services can only be validated at runtime. That is, if a dependency is missing or a circular dependency is found, the
+ * developer must wait until runtime to discover the error. These errors can often be confusing and hard to debug.
+ *
+ * This implementation eliminates this issue by moving these sorts of errors to compile time. If an unknown dependency
+ * is used in a InjectableFunction, for example, the code simply won't compile.
+ *
+ * To achieve this, we do lose the ability to implicitly define the dependency graph, as is common with many dependency
+ * injection frameworks that employ decorators to define Services and their dependencies. Instead, the dependency graph
+ * must be constructed explicitly, step-by-step, via successive calls to the `provide()` method. This is a suitable
+ * trade-off for CameraKit, as there are a relatively small number of Services.
+ *
+ * Here's a simple example of Container usage:
+ * ```ts
+ * const fooFactory = Injectable('Foo', () => new Foo())
+ * const barFactory = Injectable('Bar', ['Foo'] as const, (foo: Foo) => new Bar(foo))
+ * const container = Container.empy()
+ *   .provide(fooFactory)
+ *   .provide(barFactory)
+ *
+ * const bar: Bar = container.get('Bar')
+ * ```
+ */
+/** @internal */
+export declare class Container<Services = {}> {
+    /**
+     * Create a new [Container] by providing a [PartialContainer] that has no dependencies.
+     */
+    static provides<Services>(container: PartialContainer<Services, {}> | Container<Services>): Container<Services>;
+    /**
+     * Create a new [Container] by providing a Service that has no dependencies.
+     */
+    static provides<Token extends string, Service>(fn: InjectableFunction<{}, [], Token, Service>): Container<AddService<{}, Token, Service>>;
+    private readonly factories;
+    constructor(factories: MaybeMemoizedFactories<Services>);
+    /**
+     * Create a copy of this Container, optionally providing a list of Services which will be scoped to the copy.
+     *
+     * This can be useful, for example, if different parts of an application wish to use the same Service interface, but
+     * do not want to share a reference to same Service instance.
+     *
+     * Say we have a Service which manages a list of Users. Our application wishes to display two lists of Users, which
+     * may be edited independently. In this case it may be desirable to create a Container for each list component, with
+     * the UserList Service scoped to those Containers – that way, each list component gets a unique copy of the
+     * UserList Service that can be edited independently of the other.
+     *
+     * @param scopedServices A list of Tokens identifying Services which will be scoped to the new Container – that is,
+     * if those Services had already been created by the source Container, they will be re-created by their Factory
+     * functions when provided by the new Container.
+     * @returns A new copy of this Container, sharing all of this Container's Services. Services corresponding to any
+     * Tokens passed to this method will be re-created by the new Container (i.e. they become "scoped" to the new
+     * Container).
+     */
+    copy<Tokens extends readonly (keyof Services)[]>(scopedServices?: Tokens): Container<Services>;
+    /**
+     * Gets a reference to this Container.
+     *
+     * @param token The CONTAINER token.
+     * @returns This Container.
+     */
+    get(token: ContainerToken): this;
+    /**
+     * Get a specific Service provided by this Container.
+     *
+     * @param token A unique string corresponding to a Service
+     * @returns A Service corresponding to the given Token.
+     */
+    get<Token extends keyof Services>(token: Token): Services[Token];
+    /**
+     * Run the services in this [PartialContainer]. "Run" simply means that [Container::get] will be called for each
+     * Service, which invokes that Service's factory function, creating the Service.
+     *
+     * This may be useful e.g. if services need to initialize themselves, since generally a Service factory is only
+     * invoked when the Service is needed.
+     *
+     * Note this method cannot be used to add services to a Container. – that is, calling this method does not provide
+     * the services in a new Container.
+     *
+     * @param container Optionally provide a [PartialContainer], which will be used as a filter – the only services
+     * from *this* container that will run are those with a token that is also present in this PartialContainer.
+     * @returns No mutation is done to the Container, it is returned as-is (convenient for chaining).
+     */
+    run<AdditionalServices, Dependencies, FulfilledDependencies extends Dependencies>(this: Container<FulfilledDependencies>, container: PartialContainer<AdditionalServices, Dependencies>): this;
+    /**
+     * Run the given Service. "Run" simply means that [Container::get] will be called for this Service, which invokes
+     * the Service's factory function, creating the Service.
+     *
+     * This may be useful e.g. if services need to initialize themselves, since generally a Service factory is only
+     * invoked when the Service is needed.
+     *
+     * Note this method cannot be used to add services to a Container. – that is, calling this method does not provide
+     * the services in a new Container.
+     *
+     * @param fn Optionally provide an [InjectableFunction], which will be used as a filter – the only services
+     * from *this* container that will run are those with a token that is also present in this PartialContainer.
+     * @returns No mutation is done to the Container, it is returned as-is (convenient for chaining).
+     */
+    run<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(fn: InjectableFunction<Services, Tokens, Token, Service>): this;
+    /**
+     * Create a new Container from this Container with additional services from a given [PartialContainer].
+     *
+     * Services in the provided PartialContainer take precedence if there are service token conflicts.
+     *
+     * Services from the provided PartialContainer become scoped to the new Container – that is, if PartialContainer A
+     * is provided to Container X and Container Y, each resultant Container will contain its own copy of the services
+     * from PartialContainer A.
+     *
+     * @param container A [PartialContainer] providing additional services.
+     */
+    provides<AdditionalServices, Dependencies, FulfilledDependencies extends Dependencies>(this: Container<FulfilledDependencies>, container: PartialContainer<AdditionalServices, Dependencies>): Container<Services & AdditionalServices>;
+    /**
+     * Creates a new Container from this Container with additional services from another Container.
+     *
+     * Services in the provided PartialContainer take precedence if there are service token conflicts.
+     *
+     * Services from the provided Container become scoped to both Containers (the one from which they were provided
+     * and the new Container returned by this method) - that is, if Container A is provided to Container B,
+     * they will share the same instances of any Services provided by Container A.
+     * If Container B should re-create new instances of the Services from Container A,
+     * Container A must first be copied before providing it here.
+     *
+     * @param container A [Container] providing additional services.
+     */
+    provides<AdditionalServices>(container: Container<AdditionalServices>): Container<Services & AdditionalServices>;
+    /**
+     * Create a new Container which provides a Service created by the given [InjectableFunction].
+     *
+     * The InjectableFunction contains metadata specifying the Token by which the created Service will be known, as well
+     * as an ordered list of Tokens to be resolved and provided to the InjectableFunction as arguments.
+     *
+     * If any of these required dependencies are missing from the Container (or if there is a mismatch between the types
+     * of those dependencies and the arguments of the InjectableFunction), a compiler error will be raised.
+     *
+     * @param fn A factory function, taking dependencies as arguments, which returns the Service.
+     */
+    provides<Token extends string, Tokens extends readonly ValidTokens<Services>[], Service>(fn: InjectableFunction<Services, Tokens, Token, Service>): Container<AddService<Services, Token, Service>>;
+    private providesService;
+}
+export {};
+//# sourceMappingURL=Container.d.ts.map

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

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

package/dist/dependency-injection/Container.js

@@ -0,0 +1,72 @@
+import { isMemoized, memoize } from "../common/memoize";
+import { PartialContainer } from "./PartialContainer";
+export const CONTAINER = "$container";
+export class Container {
+    static provides(fnOrContainer) {
+        if (fnOrContainer instanceof PartialContainer)
+            return new Container({}).provides(fnOrContainer);
+        if (fnOrContainer instanceof Container)
+            return new Container({}).provides(fnOrContainer);
+        return new Container({}).provides(fnOrContainer);
+    }
+    constructor(factories) {
+        this.factories = {};
+        for (const k in factories) {
+            const fn = factories[k];
+            if (isMemoized(fn))
+                this.factories[k] = fn;
+            else
+                this.factories[k] = memoize(fn);
+        }
+    }
+    copy(scopedServices) {
+        const factories = Object.assign({}, this.factories);
+        (scopedServices || []).forEach((token) => {
+            factories[token] = this.factories[token].delegate;
+        });
+        return new Container(factories);
+    }
+    get(token) {
+        if (token === CONTAINER)
+            return this;
+        const factory = this.factories[token];
+        if (!factory) {
+            throw new Error(`[Container::get] Could not find Service for Token "${String(token)}". This should've caused a ` +
+                "compile-time error. If the Token is 'undefined', check all your calls to the Injectable " +
+                "function. Make sure you define dependencies using string literals or string constants that are " +
+                "definitely initialized before the call to Injectable.");
+        }
+        return factory(this);
+    }
+    run(fnOrContainer) {
+        if (fnOrContainer instanceof PartialContainer) {
+            const runnableContainer = this.provides(fnOrContainer);
+            for (const token of fnOrContainer.getTokens()) {
+                runnableContainer.get(token);
+            }
+        }
+        else {
+            this.provides(fnOrContainer).get(fnOrContainer.token);
+        }
+        return this;
+    }
+    provides(fnOrContainer) {
+        if (fnOrContainer instanceof PartialContainer || fnOrContainer instanceof Container) {
+            const factories = fnOrContainer instanceof PartialContainer ? fnOrContainer.getFactories(this) : fnOrContainer.factories;
+            return new Container(Object.assign(Object.assign({}, this.factories), factories));
+        }
+        return this.providesService(fnOrContainer);
+    }
+    providesService(fn) {
+        const token = fn.token;
+        const dependencies = fn.dependencies;
+        const factory = memoize((container) => {
+            return fn(...dependencies.map((t) => {
+                return t === token ? this.get(t) : container.get(t);
+            }));
+        });
+        const factories = Object.assign(Object.assign({}, this.factories), { [token]: factory });
+        return new Container(factories);
+    }
+}
+//# sourceMappingURL=Container.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Container.js","sourceRoot":"","sources":["../../src/dependency-injection/Container.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AA+BtD,MAAM,CAAC,MAAM,SAAS,GAAG,YAAY,CAAC;AAqDtC,MAAM,OAAO,SAAS;IAalB,MAAM,CAAC,QAAQ,CACX,aAAmG;QAKnG,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;IAID,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;IAoBD,IAAI,CAA6C,cAAuB;QACpE,MAAM,SAAS,qBAA0C,IAAI,CAAC,SAAS,CAAE,CAAC;QAK1E,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;YAI3G,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;gBASvB,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;QAKH,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 type { Memoized } from \"../common/memoize\";\nimport { isMemoized, memoize } from \"../common/memoize\";\nimport { PartialContainer } from \"./PartialContainer\";\nimport type { 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    // We'd like the Container type constructor to be covariant -- if type A ≤ B (that is, if A is more\n    // specific than B), we would like Container<A> ≤ Container<B>.\n    //\n    // But here in this Factories type (which is used to type the `factories` property of Container), we want to use\n    // our type variable in *both* a covariant and contravariant position -- we use the keys of Services as the index\n    // type (covariant), but we also want to use Container<Services> as the argument of the factory function\n    // (contravariant).\n    //\n    // This would result the Container type (by virtue of containing the `factories` property) being *invariant* -- that\n    // is, only if types A and B are each assignable to the other will Container<B> be assignable to Container<A>.\n    //\n    // To avoid this, we use Container<any> in the contravariant position -- that way the Services type variable is only\n    // used in covariant position and our Container type constructor remains covariant.\n    //\n    // Safety: this does mean that calling the factory function (as is done in `Container.get()`) is not type safe.\n    // But we only use this type as a private property of Container, which still type checks the constructor argument\n    // used to populate the `factories` property. So there's no way we can end up with a `factories` property containing\n    // functions which require Services not provided by the Container.\n    [K in keyof Services]: Memoized<(c: Container<any>) => 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    /**\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    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 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 properly 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/dist/dependency-injection/Injectable.d.ts

@@ -0,0 +1,96 @@
+import type { InjectableFunction, ServicesFromTokenizedParams } from "./types";
+/**
+ * Create an Injectable factory function with no dependencies (i.e. the factory function has no arguments).
+ *
+ * Ex:
+ * ```ts
+ * const createMyService = Injectable(
+ *   'MyService',
+ *   () => { return ... },
+ * )
+ * ```
+ *
+ * @param token A unique string Token which will correspond to the created Service.
+ * @param fn A function with no arguments which returns the Service.
+ */
+export declare function Injectable<Token extends string, Service>(token: Token, fn: () => Service): InjectableFunction<any, [], Token, Service>;
+/**
+ * Create an Injectable factory function with dependencies (i.e. the factory function has arguments).
+ *
+ * **Note:** the list of dependencies must contain only string literals or string consts.
+ *
+ * Ex:
+ * ```ts
+ * const DependencyB = 'DependencyB'
+ * const createMyService = Injectable(
+ *   'MyService',
+ *   ['DependencyA', DependencyB] as const,
+ *   (a: A, b: B) => { return ... },
+ * )
+ * ```
+ *
+ * @param token A unique string Token which will correspond to the created Service.
+ * @param dependencies A *readonly* list of Tokens corresponding to dependencies (i.e. arguments to the Factory), which
+ * will be resolved by the Container to which this Injectable is provided.
+ * @param fn A function with arguments matching in type and length to the given list of dependencies. When called, it
+ * must return the Service.
+ */
+export declare function Injectable<Token extends string, Tokens extends readonly string[], Params extends readonly any[], Service>(token: Token, dependencies: Tokens, fn: (...args: Tokens["length"] extends Params["length"] ? Params : void[]) => Service): Tokens["length"] extends Params["length"] ? InjectableFunction<ServicesFromTokenizedParams<Tokens, Params>, Tokens, Token, Service> : never;
+/**
+ * Create an Injectable factory function without dependencies (i.e. the factory function has no arguments) that appends
+ * a Service onto an existing array of Services of the same type.
+ *
+ * Ex:
+ * ```ts
+ * import { myServiceFactory, MyService } from './my-service'
+ *
+ * const createMyService = ConcatInjectable(
+ *   myServiceFactory.token,
+ *   (): MyService => { return ... },
+ * )
+ *
+ * // Consumers then do:
+ * const myConsumingServiceFactory = Injectable(
+ *   'myConsumingService',
+ *   [myServiceFactory.token] as const,
+ *   (myServices: MyService[]) => { return ... }
+ * )
+ * ```
+ *
+ * @param token A string Token identifying an existing Service that has an Array type, to which will be appended the
+ * Service created by this factory function.
+ * @param fn A function with no arguments which returns the Service.
+ */
+export declare function ConcatInjectable<Token extends string, Service>(token: Token, fn: () => Service): InjectableFunction<{
+    [T in keyof Token]: Service[];
+}, [], Token, Service[]>;
+/**
+ * Create an Injectable factory function with dependencies (i.e. the factory function has arguments) that appends
+ * a Service onto an existing array of Services of the same type.
+ *
+ * Ex:
+ * ```ts
+ * import { myServiceFactory, MyService } from './my-service'
+ *
+ * const createMyService = ConcatInjectable(
+ *   myServiceFactory.token,
+ *   ['DependencyA', 'DependencyB'] as const,
+ *   (a: A, b: B): MyService => { return ... },
+ * )
+ *
+ * // Consumers then do:
+ * const myConsumingServiceFactory = Injectable(
+ *   'myConsumingService',
+ *   [myServiceFactory.token] as const,
+ *   (myServices: MyService[]) => { return ... }
+ * )
+ * ```
+ *
+ * @param token A string Token identifying an existing Service that has an Array type, to which will be appended the
+ * Service created by this factory function.
+ * @param dependencies A *readonly* list of Tokens corresponding to dependencies (i.e. arguments to the Factory), which
+ * will be resolved by the Container to which this Injectable is provided.
+ * @param fn A function with no arguments which returns the Service.
+ */
+export declare function ConcatInjectable<Token extends string, Tokens extends readonly string[], Params extends readonly any[], Service>(token: Token, dependencies: Tokens, fn: (...args: Tokens["length"] extends Params["length"] ? Params : void[]) => Service): InjectableFunction<ServicesFromTokenizedParams<Tokens, Params>, Tokens, Token, Service[]>;
+//# sourceMappingURL=Injectable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Injectable.d.ts","sourceRoot":"","sources":["../../src/dependency-injection/Injectable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE/E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,EACpD,KAAK,EAAE,KAAK,EACZ,EAAE,EAAE,MAAM,OAAO,GAClB,kBAAkB,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CACtB,KAAK,SAAS,MAAM,EACpB,MAAM,SAAS,SAAS,MAAM,EAAE,EAChC,MAAM,SAAS,SAAS,GAAG,EAAE,EAC7B,OAAO,EAEP,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM,EAIpB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI,EAAE,KAAK,OAAO,GACtF,MAAM,CAAC,QAAQ,CAAC,SAAS,MAAM,CAAC,QAAQ,CAAC,GACtC,kBAAkB,CAAC,2BAA2B,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,GACvF,KAAK,CAAC;AA+BZ;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,EAC1D,KAAK,EAAE,KAAK,EACZ,EAAE,EAAE,MAAM,OAAO,GAClB,kBAAkB,CAAC;KAAG,CAAC,IAAI,MAAM,KAAK,GAAG,OAAO,EAAE;CAAE,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC5B,KAAK,SAAS,MAAM,EACpB,MAAM,SAAS,SAAS,MAAM,EAAE,EAChC,MAAM,SAAS,SAAS,GAAG,EAAE,EAC7B,OAAO,EAEP,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM,EACpB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI,EAAE,KAAK,OAAO,GACtF,kBAAkB,CAAC,2BAA2B,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"Injectable.js","sourceRoot":"","sources":["../../src/dependency-injection/Injectable.ts"],"names":[],"mappings":"AA0DA,MAAM,UAAU,UAAU,CACtB,KAAa,EACb,gBAAkD,EAClD,OAAiC;IAEjC,MAAM,YAAY,GAAa,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IACvF,MAAM,EAAE,GAAG,OAAO,gBAAgB,KAAK,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC;IAE/E,IAAI,CAAC,EAAE,EAAE;QACL,MAAM,IAAI,SAAS,CACf,0FAA0F;YACtF,oBAAoB,CAC3B,CAAC;KACL;IAED,IAAI,EAAE,CAAC,MAAM,KAAK,YAAY,CAAC,MAAM,EAAE;QACnC,MAAM,IAAI,SAAS,CACf,4FAA4F;YACxF,GAAG,EAAE,CAAC,MAAM,SAAS,YAAY,CAAC,MAAM,+BAA+B;YACvE,mBAAmB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CACxD,CAAC;KACL;IAED,MAAM,OAAO,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;IAChD,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;IACtB,OAAO,CAAC,YAAY,GAAG,YAAY,CAAC;IACpC,OAAO,OAAO,CAAC;AACnB,CAAC;AAuED,MAAM,UAAU,gBAAgB,CAC5B,KAAa,EACb,gBAAkD,EAClD,OAAiC;IAEjC,MAAM,YAAY,GAAa,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IACvF,MAAM,EAAE,GAAG,OAAO,gBAAgB,KAAK,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC;IAE/E,IAAI,CAAC,EAAE,EAAE;QACL,MAAM,IAAI,SAAS,CACf,gGAAgG;YAC5F,oBAAoB,CAC3B,CAAC;KACL;IAED,IAAI,EAAE,CAAC,MAAM,KAAK,YAAY,CAAC,MAAM,EAAE;QACnC,MAAM,IAAI,SAAS,CACf,4FAA4F;YACxF,GAAG,EAAE,CAAC,MAAM,SAAS,YAAY,CAAC,MAAM,+BAA+B;YACvE,mBAAmB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CACxD,CAAC;KACL;IAED,MAAM,OAAO,GAAG,CAAC,KAAY,EAAE,GAAG,IAAW,EAAE,EAAE;QAC7C,OAAO,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACrC,CAAC,CAAC;IACF,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;IACtB,OAAO,CAAC,YAAY,GAAG,CAAC,KAAK,EAAE,GAAG,YAAY,CAAC,CAAC;IAChD,OAAO,OAAO,CAAC;AACnB,CAAC","sourcesContent":["import type { InjectableFunction, ServicesFromTokenizedParams } from \"./types\";\n\n/**\n * Create an Injectable factory function with no dependencies (i.e. the factory function has no arguments).\n *\n * Ex:\n * ```ts\n * const createMyService = Injectable(\n *   'MyService',\n *   () => { return ... },\n * )\n * ```\n *\n * @param token A unique string Token which will correspond to the created Service.\n * @param fn A function with no arguments which returns the Service.\n */\nexport function Injectable<Token extends string, Service>(\n    token: Token,\n    fn: () => Service\n): InjectableFunction<any, [], Token, Service>;\n\n/**\n * Create an Injectable factory function with dependencies (i.e. the factory function has arguments).\n *\n * **Note:** the list of dependencies must contain only string literals or string consts.\n *\n * Ex:\n * ```ts\n * const DependencyB = 'DependencyB'\n * const createMyService = Injectable(\n *   'MyService',\n *   ['DependencyA', DependencyB] as const,\n *   (a: A, b: B) => { return ... },\n * )\n * ```\n *\n * @param token A unique string Token which will correspond to the created Service.\n * @param dependencies A *readonly* list of Tokens corresponding to dependencies (i.e. arguments to the Factory), which\n * will be resolved by the Container to which this Injectable is provided.\n * @param fn A function with arguments matching in type and length to the given list of dependencies. When called, it\n * must return the Service.\n */\nexport function Injectable<\n    Token extends string,\n    Tokens extends readonly string[],\n    Params extends readonly any[],\n    Service\n>(\n    token: Token,\n    dependencies: Tokens,\n    // The function arity (number of arguments) must match the number of dependencies specified – if they don't, we'll\n    // force a compiler error by saying the arguments should be `void[]`. We'll also throw at runtime, so the return\n    // type will be `never`.\n    fn: (...args: Tokens[\"length\"] extends Params[\"length\"] ? Params : void[]) => Service\n): Tokens[\"length\"] extends Params[\"length\"]\n    ? InjectableFunction<ServicesFromTokenizedParams<Tokens, Params>, Tokens, Token, Service>\n    : never;\n\nexport function Injectable(\n    token: string,\n    dependenciesOrFn?: readonly string[] | (() => any),\n    maybeFn?: (...args: any[]) => any\n): InjectableFunction<any, readonly string[], string, any> {\n    const dependencies: string[] = Array.isArray(dependenciesOrFn) ? dependenciesOrFn : [];\n    const fn = typeof dependenciesOrFn === \"function\" ? dependenciesOrFn : maybeFn;\n\n    if (!fn) {\n        throw new TypeError(\n            \"[Injectable] Received invalid arguments. The factory function must be either the second \" +\n                \"or third argument.\"\n        );\n    }\n\n    if (fn.length !== dependencies.length) {\n        throw new TypeError(\n            \"[Injectable] Function arity does not match the number of dependencies. Function has arity \" +\n                `${fn.length}, but ${dependencies.length} dependencies were specified.` +\n                `\\nDependencies: ${JSON.stringify(dependencies)}`\n        );\n    }\n\n    const factory = (...args: any[]) => fn(...args);\n    factory.token = token;\n    factory.dependencies = dependencies;\n    return factory;\n}\n\n/**\n * Create an Injectable factory function without dependencies (i.e. the factory function has no arguments) that appends\n * a Service onto an existing array of Services of the same type.\n *\n * Ex:\n * ```ts\n * import { myServiceFactory, MyService } from './my-service'\n *\n * const createMyService = ConcatInjectable(\n *   myServiceFactory.token,\n *   (): MyService => { return ... },\n * )\n *\n * // Consumers then do:\n * const myConsumingServiceFactory = Injectable(\n *   'myConsumingService',\n *   [myServiceFactory.token] as const,\n *   (myServices: MyService[]) => { return ... }\n * )\n * ```\n *\n * @param token A string Token identifying an existing Service that has an Array type, to which will be appended the\n * Service created by this factory function.\n * @param fn A function with no arguments which returns the Service.\n */\nexport function ConcatInjectable<Token extends string, Service>(\n    token: Token,\n    fn: () => Service\n): InjectableFunction<{ [T in keyof Token]: Service[] }, [], Token, Service[]>;\n\n/**\n * Create an Injectable factory function with dependencies (i.e. the factory function has arguments) that appends\n * a Service onto an existing array of Services of the same type.\n *\n * Ex:\n * ```ts\n * import { myServiceFactory, MyService } from './my-service'\n *\n * const createMyService = ConcatInjectable(\n *   myServiceFactory.token,\n *   ['DependencyA', 'DependencyB'] as const,\n *   (a: A, b: B): MyService => { return ... },\n * )\n *\n * // Consumers then do:\n * const myConsumingServiceFactory = Injectable(\n *   'myConsumingService',\n *   [myServiceFactory.token] as const,\n *   (myServices: MyService[]) => { return ... }\n * )\n * ```\n *\n * @param token A string Token identifying an existing Service that has an Array type, to which will be appended the\n * Service created by this factory function.\n * @param dependencies A *readonly* list of Tokens corresponding to dependencies (i.e. arguments to the Factory), which\n * will be resolved by the Container to which this Injectable is provided.\n * @param fn A function with no arguments which returns the Service.\n */\nexport function ConcatInjectable<\n    Token extends string,\n    Tokens extends readonly string[],\n    Params extends readonly any[],\n    Service\n>(\n    token: Token,\n    dependencies: Tokens,\n    fn: (...args: Tokens[\"length\"] extends Params[\"length\"] ? Params : void[]) => Service\n): InjectableFunction<ServicesFromTokenizedParams<Tokens, Params>, Tokens, Token, Service[]>;\n\nexport function ConcatInjectable(\n    token: string,\n    dependenciesOrFn?: readonly string[] | (() => any),\n    maybeFn?: (...args: any[]) => any\n): InjectableFunction<any, readonly string[], string, any[]> {\n    const dependencies: string[] = Array.isArray(dependenciesOrFn) ? dependenciesOrFn : [];\n    const fn = typeof dependenciesOrFn === \"function\" ? dependenciesOrFn : maybeFn;\n\n    if (!fn) {\n        throw new TypeError(\n            \"[ConcatInjectable] Received invalid arguments. The factory function must be either the second \" +\n                \"or third argument.\"\n        );\n    }\n\n    if (fn.length !== dependencies.length) {\n        throw new TypeError(\n            \"[Injectable] Function arity does not match the number of dependencies. Function has arity \" +\n                `${fn.length}, but ${dependencies.length} dependencies were specified.` +\n                `\\nDependencies: ${JSON.stringify(dependencies)}`\n        );\n    }\n\n    const factory = (array: any[], ...args: any[]) => {\n        return array.concat(fn(...args));\n    };\n    factory.token = token;\n    factory.dependencies = [token, ...dependencies];\n    return factory;\n}\n"]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"PartialContainer.d.ts","sourceRoot":"","sources":["../../src/dependency-injection/PartialContainer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAIxG,KAAK,eAAe,CAAC,kBAAkB,EAAE,YAAY,IAAI,kBAAkB,SAAS,GAAG,GAEjF;KACK,CAAC,IAAI,MAAM,kBAAkB,GAAG,MAAM,YAAY,GAAG,CAAC,SAAS,MAAM,kBAAkB,GAClF,kBAAkB,CAAC,CAAC,CAAC,GACrB,CAAC,SAAS,MAAM,YAAY,GAC5B,YAAY,CAAC,CAAC,CAAC,GACf,KAAK;CACd,GACD,KAAK,CAAC;AAEZ,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,GAAG,GAAG;KAAG,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAC;AAErF,KAAK,yBAAyB,CAC1B,MAAM,SAAS,SAAS,GAAG,EAAE,EAC7B,MAAM,SAAS,SAAS,MAAM,EAAE,EAChC,KAAK,SAAS,MAAM,EACpB,OAAO,IACP;IACA,CAAC,GAAG,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,CAAC,QAAQ,EAAE,YAAY,IAAI;KACtC,CAAC,IAAI,MAAM,QAAQ,GAAG,CAAC,SAAS,MAAM,GACjC,kBAAkB,CAAC,QAAQ,GAAG,YAAY,EAAE,SAAS,WAAW,CAAC,QAAQ,GAAG,YAAY,CAAC,EAAE,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,GAC5G,KAAK;CACd,CAAC;AAEF,KAAK,yBAAyB,CAAC,QAAQ,EAAE,WAAW,IAAI;KACnD,CAAC,IAAI,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;CAClG,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gBAAgB;AAChB,qBAAa,gBAAgB,CAAC,QAAQ,GAAG,EAAE,EAAE,YAAY,GAAG,EAAE;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,WAAW,CAAC,QAAQ,EAAE,YAAY,CAAC;IAE7E;;;;;;;;;;;OAWG;IACH,QAAQ,CACJ,sBAAsB,SAAS,SAAS,GAAG,EAAE,EAC7C,MAAM,SAAS,SAAS,MAAM,EAAE,EAChC,KAAK,SAAS,MAAM,EACpB,OAAO,EAEP,EAAE,EAAE,yBAAyB,CAAC,sBAAsB,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,GAC9E,gBAAgB,CACf,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,EAIpC,UAAU,CACN,eAAe,CACX,UAAU,CAAC,YAAY,EAAE,KAAK,CAAC,EAC/B,2BAA2B,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAC9D,EACD,MAAM,QAAQ,CACjB,CACJ;IAID;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,YAAY,CAAC,GAAG,yBAAyB,CAAC,QAAQ,EAAE,YAAY,CAAC;IAmBhG,SAAS,IAAI,KAAK,CAAC,MAAM,QAAQ,CAAC;CAGrC"}

package/dist/dependency-injection/PartialContainer.js

@@ -0,0 +1,28 @@
+import { entries } from "../common/entries";
+import { memoize } from "../common/memoize";
+export class PartialContainer {
+    constructor(injectables) {
+        this.injectables = injectables;
+    }
+    provides(fn) {
+        return new PartialContainer(Object.assign(Object.assign({}, this.injectables), { [fn.token]: fn }));
+    }
+    getFactories(parent) {
+        return Object.fromEntries(entries(this.injectables).map(([token, fn]) => {
+            return [
+                token,
+                memoize((c) => {
+                    return fn(...fn.dependencies.map((t) => {
+                        return t === token
+                            ? parent.get(t)
+                            : c.get(t);
+                    }));
+                }),
+            ];
+        }));
+    }
+    getTokens() {
+        return Object.keys(this.injectables);
+    }
+}
+//# sourceMappingURL=PartialContainer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PartialContainer.js","sourceRoot":"","sources":["../../src/dependency-injection/PartialContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAqE5C,MAAM,OAAO,gBAAgB;IACzB,YAA6B,WAAgD;QAAhD,gBAAW,GAAX,WAAW,CAAqC;IAAG,CAAC;IAcjF,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;IAkBD,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 type { Memoized } from \"../common/memoize\";\nimport { memoize } from \"../common/memoize\";\nimport type { Container } from \"./Container\";\nimport type { 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"]}