siringa 0.0.1

package/LICENSE.md

@@ -0,0 +1,211 @@
+# Apache License
+
+Version 2.0, January 2004
+
+[http://www.apache.org/licenses/](http://www.apache.org/licenses/)
+
+##### TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+### 1. Definitions.
+
+"**License**" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"**Licensor**" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"**Legal Entity**" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"**control**" means **(i)** the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, _or_ **(ii)** ownership of fifty percent (50%) or more of
+the outstanding shares, _or_ **(iii)** beneficial ownership of such
+entity.
+
+"**You**" (or "**Your**") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"**Source**" form shall mean the preferred form for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"**Object**" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but not
+limited to compiled object code, generated documentation, and
+conversions to other media types.
+
+"**Work**" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work (an example
+is provided in the Appendix below).
+
+"**Derivative Works**" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"**Contribution**" shall mean any work of authorship, including the
+original version of the Work and any modifications or additions to that
+Work or Derivative Works thereof, that is intentionally submitted to
+Licensor for inclusion in the Work by the copyright owner or by an
+individual or Legal Entity authorized to submit on behalf of the
+copyright owner. For the purposes of this definition, "**submitted**"
+means any form of electronic, verbal, or written communication sent to
+the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "**Not a
+Contribution**".
+
+"**Contributor**" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+### 2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor
+hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable copyright license to reproduce, prepare
+Derivative Works of, publicly display, publicly perform, sublicense,
+and distribute the Work and such Derivative Works in Source or Object
+form.
+
+### 3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor
+hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and
+otherwise transfer the Work, where such license applies only to those
+patent claims licensable by such Contributor that are necessarily
+infringed by their Contribution(s) alone or by combination of their
+Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+the Work or a Contribution incorporated within the Work constitutes
+direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of
+the date such litigation is filed.
+
+### 4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works
+thereof in any medium, with or without modifications, and in Source or
+Object form, provided that You meet the following conditions:
+
+<ol type="a">
+  <li>You must give any other recipients of the Work or Derivative Works
+    a copy of this License; and
+  <li>You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+  <li>You must retain, in the Source form of any Derivative Works that
+    You distribute, all copyright, patent, trademark, and attribution
+    notices from the Source form of the Work, excluding those notices
+    that do not pertain to any part of the Derivative Works; and
+  <li>If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained within
+    such NOTICE file, excluding those notices that do not pertain to any
+    part of the Derivative Works, in at least one of the following
+    places: within a NOTICE text file distributed as part of the
+    Derivative Works; within the Source form or documentation, if
+    provided along with the Derivative Works; or, within a display
+    generated by the Derivative Works, if and wherever such third-party
+    notices normally appear. The contents of the NOTICE file are for
+    informational purposes only and do not modify the License. You may
+    add Your own attribution notices within Derivative Works that You
+    distribute, alongside or as an addendum to the NOTICE text from the
+    Work, provided that such additional attribution notices cannot be
+    construed as modifying the License.
+</ol>
+
+You may add Your own copyright statement to Your modifications and may
+provide additional or different license terms and conditions for use,
+reproduction, or distribution of Your modifications, or for any such
+Derivative Works as a whole, provided Your use, reproduction, and
+distribution of the Work otherwise complies with the conditions stated
+in this License.
+
+### 5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally
+submitted for inclusion in the Work by You to the Licensor shall be
+under the terms and conditions of this License, without any additional
+terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may
+have executed with Licensor regarding such Contributions.
+
+### 6. Trademarks.
+
+This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as
+required for reasonable and customary use in describing the origin of
+the Work and reproducing the content of the NOTICE file.
+
+### 7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor
+provides the Work (and each Contributor provides its Contributions) on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR
+A PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+### 8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including
+negligence), contract, or otherwise, unless required by applicable law
+(such as deliberate and grossly negligent acts) or agreed to in writing,
+shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or
+inability to use the Work (including but not limited to damages for loss
+of goodwill, work stoppage, computer failure or malfunction, or any and
+all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+### 9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may
+choose to offer, and charge a fee for, acceptance of support, warranty,
+indemnity, or other liability obligations and/or rights consistent with
+this License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf of any
+other Contributor, and only if You agree to indemnify, defend, and hold
+each Contributor harmless for any liability incurred by, or claims
+asserted against, such Contributor by reason of your accepting any
+such warranty or additional liability.
+
+##### END OF TERMS AND CONDITIONS
+
+## APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include the
+brackets!)  The text should be enclosed in the appropriate comment
+syntax for the file format. We also recommend that a file or class name
+and description of purpose be included on the same "printed page" as the
+copyright notice for easier identification within third-party archives.
+
+> #### Copyright [yyyy] [name of copyright owner]
+>
+> Licensed under the Apache License, Version 2.0 (the "License");
+> you may not use this file except in compliance with the License.
+> You may obtain a copy of the License at
+>
+> [http://www.apache.org/licenses/](http://www.apache.org/licenses/)
+>
+> Unless required by applicable law or agreed to in writing, software
+> distributed under the License is distributed on an "AS IS" BASIS,
+> WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+> See the License for the specific language governing permissions and
+> limitations under the License.

package/NOTICE.md

@@ -0,0 +1,13 @@
+# Copyright 2022 Juit GmbH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+[http://www.apache.org/licenses/](http://www.apache.org/licenses/)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,299 @@
+SIRINGA
+=======
+
+> _"**siringa**"_ (italian): _"syringe"_, a tool for administering injections.
+
+SIRINGA is an extremely simple dependency injection framework focusing on type
+correctness and asynchronous injections, without relying on decorators and/or
+decorator metadata.
+
+* [Quick Start](#quick-start)
+* [One-Time Injection](#one-time-injection)
+* [Name-based Injection](#name-based-injection)
+* [Using Factories](#using-factories)
+* [Using Instances](#using-instances)
+* [Child Injectors](#child-injectors)
+* [API Reference](#api-reference)
+  * [`class Injector`](#class-injector)
+  * [`interface Injections`](#interface-injections)
+* [Copyright Notice](NOTICE.md)
+* [License](LICENSE.md)
+
+Quick Start
+-----------
+
+At its core, SIRINGA tries to make dependency injection as easy as possible.
+
+Classes can be _injected_ their dependencies by specifying a static `$inject`
+property (a _tuple_ of injection keys):
+
+```ts
+// A class with no dependencies, and an implicit zero-args constructor
+class Foo {
+  foo() { /* ... your code... */ }
+}
+
+// Here "Bar" needs an instance of "Foo" to be injected
+class Bar {
+  // The _tuple_ of required injections, this must be declared `as const`
+  // and the resolved types must match the constructor's arguments
+  static $inject = [ Foo ] as const
+
+  // Called by the injector with the correct dependencies
+  constructor(private _foo: Foo) {}
+
+  // Your code
+  bar() {
+    this._foo.bar()
+  }
+}
+
+// Create a new injector
+const injector = new Injector()
+  .bind(Foo) // Bind "Foo" (no dependencies required)
+  .bind(Bar) // Bind "Bar" (requires "Foo")
+
+// Get the singleton instance of "Bar"
+const bar = await injector.get(Bar)
+// Get the singleton instance of "Foo" (injection magically happens!)
+const foo = await injector.get(Foo)
+```
+
+One-Time Injection
+------------------
+
+We can use an `Injector` also to perform one-time injections (the instance
+injected won't be managed by the `Injector` itself).
+
+Using the same `Foo` and `Bar` classes from above:
+
+```ts
+// Create a new injector and bind Foo
+const injector = new Injector().bind(Foo)
+
+// Create a new "Bar" instance injected with its required "Foo"
+const bar = await injector.inject(Bar)
+
+// Will return the same instance given to "Bar"'s constructor
+const foo = await injector.get(Foo)
+
+// The code below will miserably fail, as "Bar" is not managed by the injector
+// const bar2 = await injector.get(Bar)
+```
+
+
+Name-based Injection
+--------------------
+
+Injection keys must not _necessarily_ be classes, they can also be `string`s:
+
+```ts
+class Foo {
+  foo() { /* ... your code... */ }
+}
+
+class Bar {
+  // The string `foo` is used to identify the binding
+  static $inject = [ 'foo' ] as const
+
+  // Called by the injector with the correct dependencies
+  constructor(private _foo: Foo) {}
+
+  // Your code
+  bar() {
+    this._foo.bar()
+  }
+}
+
+// Create a new injector
+const injector = new Injector()
+  .bind('foo', Foo) // Bind "Foo" to the string 'foo'
+  .bind('bar', Bar) // Bind "Bar" to the string 'bar'
+
+// Get the singleton instance of "Bar"
+const bar = await injector.get('bar')
+// Get the singleton instance of "Foo"
+const foo = await injector.get('foo')
+```
+
+Using Factories
+---------------
+
+The injector's `create(...)` method allows to use a _factory pattern_ to
+create instances to be injected:
+
+```ts
+class Foo {
+  constructor(public _value: number)
+}
+
+class Bar {
+  // The string `foo` is used to identify the binding
+  static $inject = [ Foo ] as const
+
+  // Called by the injector with the correct dependencies
+  constructor(private _foo: Foo) {}
+
+  // Your code
+  bar() {
+    console.log(this._foo._value)
+  }
+}
+
+// Create a new injector
+const injector = new Injector()
+  .bind(Foo, (injections) => {
+    // The "injections" object can be used to resolve dependencies
+    // in the injector itself using "get(...)" or "inject(...)"
+
+    return new Foo(12345)
+  })
+
+// Inject "Bar" with "Foo"
+const bar = await injector.inject(Bar)
+
+// This will print "12345"
+bar.bar()
+```
+
+As in the example above, factory methods will be given an `Injections` instance
+which can be used to get instances, inject new objects, or create sub-injectors.
+
+See the reference for [`Injections`](#interface-injections) below.
+
+Using Instances
+---------------
+
+Similar to factories (above) the injector's `use(...)` method allows to use
+pre-baked instances as dependencies for other objects:
+
+```ts
+class Foo {
+  constructor(public _value: number)
+}
+
+class Bar {
+  // The string `foo` is used to identify the binding
+  static $inject = [ Foo ] as const
+
+  // Called by the injector with the correct dependencies
+  constructor(private _foo: Foo) {}
+
+  // Your code
+  bar() {
+    console.log(this._foo._value)
+  }
+}
+
+// Create a new injector
+const injector = new Injector()
+  .use(Foo, new Foo(12345))
+
+// Inject "Bar" with "Foo"
+const bar = await injector.inject(Bar)
+
+// This will print "12345"
+bar.bar()
+```
+
+Child Injectors
+---------------
+
+In some cases it is useful to create _child injectors_.
+
+A _child injector_ inherits all the bindings from its parent, but any extra
+binding declared in it won't affect its parent.
+
+Also, a _child injector_ can _redeclare_ a binding without affecting its parent.
+
+For example (using silly strings to simplify the inner workings!)
+
+```ts
+const parent = new Injector()
+  .use('foo', 'parent foo')
+
+const child = parent.injector()
+  .create('parentFoo', async (injections) => {
+    const s = await injections.get('foo') // this is the parent's value!!!
+    return `${s} from a child`
+  }
+  .use('foo', 'child foo')
+
+await parent.get('foo') // this will return "parent foo"
+await child.get('foo') // this will return "child foo" (overrides parent)
+
+await child.get('parentFoo') // this will return "parent foo from a child"
+// await parent.get('parentFoo') // fails, as parent doesn't define "parentFoo"
+```
+
+API Reference
+-------------
+
+Quick-and-dirty reference for our types (for details, everything should be
+annotated with _JSDoc_).
+
+### `class Injector`
+
+#### Binding
+
+* `injector.bind(component: Constructor): Injector` \
+  Bind the specified constructor (a _class_) to the injector
+
+* `injector.bind(component: Constructor, implementation: Constructor): Injector` \
+  Bind the specified component (a _class_) to the injector, and use the
+  specified implementation (another _class_ extending the component) to
+  create instances
+
+* `injector.bind(name: string, implementation: Constructor): Injector` \
+  Bind the specified name (a _string) to the injector, and use the
+  specified implementation (a _class_ ) to create instances
+
+#### Factories
+
+* `injector.create(component: Constructor, factory: Factory): Injector` \
+  Use the specified factory (a _function_) to create instances for the
+  specified _component_ (a _class_)
+
+* `injector.create(name: string, factory: Factory): Injector` \
+  Use the specified factory (a _function_) to create instances for the
+  specified name (a _string_)
+
+#### Instances
+
+* `injector.use(component: Constructor, instance: any): Injector` \
+  Bind the specified instance  to a component (a _class_).
+
+* `injector.create(name: string, instance: any): Injector` \
+  Bind the specified instance  to a name (a _string_).
+
+#### Injections
+
+* `injections.get(component: Constructor): Instance` \
+  Returns the instance bound to the specified constructor (a _class_)
+
+* `injections.get(name: string): Instance` \
+  Returns the instance bound to the specified name (a _string_)
+
+* `injections.inject(injectable: Constructor): Instance` \
+  Create a new instance of the given injectable (a _class_) injecting all its
+  required dependencies
+
+#### Sub Injectors
+
+* `injections.injector(): Injector` \
+  Create a sub-injector (child) of the current one
+
+### `class Injections`
+
+* `injections.get(component: Constructor): Instance` \
+  Returns the instance bound to the specified constructor (a _class_)
+
+* `injections.get(name: string): Instance` \
+  Returns the instance bound to the specified name (a _string_)
+
+* `injections.inject(injectable: Constructor): Instance` \
+  Create a new instance of the given injectable (a _class_) injecting all its
+  required dependencies
+
+* `injections.injector(): Injector` \
+  Create a sub-injector (child) of the current one

package/dist/index.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Injector: () => Injector
+});
+function bindingName(binding) {
+  return typeof binding === "function" ? `[class ${binding.name}]` : `"${binding}"`;
+}
+var Injector = class {
+  #factories = /* @__PURE__ */ new Map();
+  #promises = /* @__PURE__ */ new Map();
+  #parent;
+  async #get(binding, stack) {
+    if (stack.includes(binding)) {
+      if (this.#parent)
+        return this.#parent.#get(binding, []);
+      const message2 = `Recursion detected injecting ${bindingName(binding)}`;
+      return Promise.reject(new Error(message2));
+    }
+    const promise = this.#promises.get(binding);
+    if (promise)
+      return promise;
+    const factory = this.#factories.get(binding);
+    if (factory) {
+      const promise2 = Promise.resolve().then(() => factory([...stack, binding]));
+      this.#promises.set(binding, promise2);
+      return promise2;
+    }
+    if (this.#parent)
+      return this.#parent.#get(binding, []);
+    const message = `Unable to resolve binding ${bindingName(binding)}`;
+    return Promise.reject(new Error(message));
+  }
+  async #inject(injectable, stack) {
+    var _a;
+    const promises = (_a = injectable.$inject) == null ? void 0 : _a.map((binding) => this.#get(binding, stack));
+    const injections = promises ? await Promise.all(promises) : [];
+    return new injectable(...injections);
+  }
+  bind(binding, maybeInjectable) {
+    const injectable = maybeInjectable ? maybeInjectable : binding;
+    this.#factories.set(binding, async (stack) => this.#inject(injectable, stack));
+    return this;
+  }
+  create(binding, factory) {
+    this.#factories.set(binding, async (stack) => factory({
+      get: (component) => this.#get(component, stack),
+      inject: async (injectable) => this.#inject(injectable, stack),
+      injector: () => this.injector()
+    }));
+    return this;
+  }
+  use(binding, instance) {
+    this.#promises.set(binding, Promise.resolve(instance));
+    return this;
+  }
+  async get(binding) {
+    return this.#get(binding, []);
+  }
+  async inject(injectable) {
+    return this.#inject(injectable, []);
+  }
+  injector() {
+    const injector = new Injector();
+    injector.#parent = this;
+    return injector;
+  }
+};
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Injector
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AA4HA,qBAAqB,SAA0B;AAC7C,SAAO,OAAO,YAAY,aAAa,UAAU,QAAQ,UAAU,IAAI;AAAA;AA0DlE,qBAGyC;AAAA,EACrC,aAA+D,oBAAI;AAAA,EACnE,YAAwC,oBAAI;AAAA,EACrD;AAAA,QAIM,KAAK,SAAkB,OAAgC;AAC3D,QAAI,MAAM,SAAS,UAAU;AAC3B,UAAI;AAAc,eAAO,kBAAkB,SAAS;AACpD,YAAM,WAAU,gCAAgC,YAAY;AAC5D,aAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAGlC,UAAM,UAAU,eAAe,IAAI;AACnC,QAAI;AAAS,aAAO;AAEpB,UAAM,UAAU,gBAAgB,IAAI;AACpC,QAAI,SAAS;AACX,YAAM,WAAU,QAAQ,UAAU,KAAK,MAAM,QAAQ,CAAE,GAAG,OAAO;AACjE,qBAAe,IAAI,SAAS;AAC5B,aAAO;AAAA;AAGT,QAAI;AAAc,aAAO,kBAAkB,SAAS;AAEpD,UAAM,UAAU,6BAA6B,YAAY;AACzD,WAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAAA,QAG5B,QAAQ,YAAgD,OAAgC;AAxNhG;AAyNI,UAAM,WAAW,iBAAW,YAAX,mBAAoB,IAAI,CAAC,YAAiB,UAAU,SAAS;AAC9E,UAAM,aAAa,WAAW,MAAM,QAAQ,IAAI,YAAY;AAG5D,WAAO,IAAI,WAAW,GAAG;AAAA;AAAA,EAuB3B,KACE,SACA,iBACM;AACN,UAAM,aAAa,kBAAkB,kBACjC;AAEJ,oBAAgB,IAAI,SAAS,OAAO,UAAU,aAAa,YAAY;AACvE,WAAO;AAAA;AAAA,EAkBT,OACE,SACA,SACM;AACN,oBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ;AAAA,MACpD,KAAK,CAAC,cAAmB,UAAU,WAAW;AAAA,MAC9C,QAAQ,OAAO,eAAoB,aAAa,YAAY;AAAA,MAC5D,UAAU,MAAM,KAAK;AAAA;AAGvB,WAAO;AAAA;AAAA,EAkBT,IACE,SACA,UACM;AACN,mBAAe,IAAI,SAAS,QAAQ,QAAQ;AAC5C,WAAO;AAAA;AAAA,QAYH,IACJ,SACc;AACd,WAAO,UAAU,SAAS;AAAA;AAAA,QAStB,OACJ,YAC0B;AAC1B,WAAO,aAAa,YAAY;AAAA;AAAA,EAMlC,WAA6C;AAC3C,UAAM,WAAW,IAAI;AACrB,uBAAmB;AACnB,WAAO;AAAA;AAAA;",
+  "names": []
+}

package/dist/index.mjs

@@ -0,0 +1,68 @@
+// src/index.ts
+function bindingName(binding) {
+  return typeof binding === "function" ? `[class ${binding.name}]` : `"${binding}"`;
+}
+var Injector = class {
+  #factories = /* @__PURE__ */ new Map();
+  #promises = /* @__PURE__ */ new Map();
+  #parent;
+  async #get(binding, stack) {
+    if (stack.includes(binding)) {
+      if (this.#parent)
+        return this.#parent.#get(binding, []);
+      const message2 = `Recursion detected injecting ${bindingName(binding)}`;
+      return Promise.reject(new Error(message2));
+    }
+    const promise = this.#promises.get(binding);
+    if (promise)
+      return promise;
+    const factory = this.#factories.get(binding);
+    if (factory) {
+      const promise2 = Promise.resolve().then(() => factory([...stack, binding]));
+      this.#promises.set(binding, promise2);
+      return promise2;
+    }
+    if (this.#parent)
+      return this.#parent.#get(binding, []);
+    const message = `Unable to resolve binding ${bindingName(binding)}`;
+    return Promise.reject(new Error(message));
+  }
+  async #inject(injectable, stack) {
+    var _a;
+    const promises = (_a = injectable.$inject) == null ? void 0 : _a.map((binding) => this.#get(binding, stack));
+    const injections = promises ? await Promise.all(promises) : [];
+    return new injectable(...injections);
+  }
+  bind(binding, maybeInjectable) {
+    const injectable = maybeInjectable ? maybeInjectable : binding;
+    this.#factories.set(binding, async (stack) => this.#inject(injectable, stack));
+    return this;
+  }
+  create(binding, factory) {
+    this.#factories.set(binding, async (stack) => factory({
+      get: (component) => this.#get(component, stack),
+      inject: async (injectable) => this.#inject(injectable, stack),
+      injector: () => this.injector()
+    }));
+    return this;
+  }
+  use(binding, instance) {
+    this.#promises.set(binding, Promise.resolve(instance));
+    return this;
+  }
+  async get(binding) {
+    return this.#get(binding, []);
+  }
+  async inject(injectable) {
+    return this.#inject(injectable, []);
+  }
+  injector() {
+    const injector = new Injector();
+    injector.#parent = this;
+    return injector;
+  }
+};
+export {
+  Injector
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "mappings": ";AA4HA,qBAAqB,SAA0B;AAC7C,SAAO,OAAO,YAAY,aAAa,UAAU,QAAQ,UAAU,IAAI;AAAA;AA0DlE,qBAGyC;AAAA,EACrC,aAA+D,oBAAI;AAAA,EACnE,YAAwC,oBAAI;AAAA,EACrD;AAAA,QAIM,KAAK,SAAkB,OAAgC;AAC3D,QAAI,MAAM,SAAS,UAAU;AAC3B,UAAI;AAAc,eAAO,kBAAkB,SAAS;AACpD,YAAM,WAAU,gCAAgC,YAAY;AAC5D,aAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAGlC,UAAM,UAAU,eAAe,IAAI;AACnC,QAAI;AAAS,aAAO;AAEpB,UAAM,UAAU,gBAAgB,IAAI;AACpC,QAAI,SAAS;AACX,YAAM,WAAU,QAAQ,UAAU,KAAK,MAAM,QAAQ,CAAE,GAAG,OAAO;AACjE,qBAAe,IAAI,SAAS;AAC5B,aAAO;AAAA;AAGT,QAAI;AAAc,aAAO,kBAAkB,SAAS;AAEpD,UAAM,UAAU,6BAA6B,YAAY;AACzD,WAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAAA,QAG5B,QAAQ,YAAgD,OAAgC;AAxNhG;AAyNI,UAAM,WAAW,iBAAW,YAAX,mBAAoB,IAAI,CAAC,YAAiB,UAAU,SAAS;AAC9E,UAAM,aAAa,WAAW,MAAM,QAAQ,IAAI,YAAY;AAG5D,WAAO,IAAI,WAAW,GAAG;AAAA;AAAA,EAuB3B,KACE,SACA,iBACM;AACN,UAAM,aAAa,kBAAkB,kBACjC;AAEJ,oBAAgB,IAAI,SAAS,OAAO,UAAU,aAAa,YAAY;AACvE,WAAO;AAAA;AAAA,EAkBT,OACE,SACA,SACM;AACN,oBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ;AAAA,MACpD,KAAK,CAAC,cAAmB,UAAU,WAAW;AAAA,MAC9C,QAAQ,OAAO,eAAoB,aAAa,YAAY;AAAA,MAC5D,UAAU,MAAM,KAAK;AAAA;AAGvB,WAAO;AAAA;AAAA,EAkBT,IACE,SACA,UACM;AACN,mBAAe,IAAI,SAAS,QAAQ,QAAQ;AAC5C,WAAO;AAAA;AAAA,QAYH,IACJ,SACc;AACd,WAAO,UAAU,SAAS;AAAA;AAAA,QAStB,OACJ,YAC0B;AAC1B,WAAO,aAAa,YAAY;AAAA;AAAA,EAMlC,WAA6C;AAC3C,UAAM,WAAW,IAAI;AACrB,uBAAmB;AACnB,WAAO;AAAA;AAAA;",
+  "names": []
+}

package/index.d.ts

@@ -0,0 +1,109 @@
+/** A generic constructor */
+declare type Constructor<T = any> = abstract new (...args: any) => T;
+/**
+ * Check that an `Injector`'s static `$inject` member matches the `Injector`'s
+ * own components and provisions
+ */
+declare type CheckInject<Inject, // the tuple from "$inject"
+Components extends Constructor, // the `Injector`'s components
+Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends keyof Provisions ? readonly [I1] : I1 extends Extract<Components, I1> ? readonly [I1] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
+    ...CheckInject<[I1], Components, Provisions>,
+    ...CheckInject<I2, Components, Provisions>
+] : readonly [Components | keyof Provisions, ...(Components | keyof Provisions)[]];
+/**
+ * Map the contents of the static `$inject` member to their types, resolving
+ * named provisions.
+ */
+declare type MapInject<Inject, // the tuple from "$inject"
+Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends keyof Provisions ? readonly [Provisions[I1]] : I1 extends Constructor ? readonly [InstanceType<I1>] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
+    ...MapInject<[I1], Provisions>,
+    ...MapInject<I2, Provisions>
+] : readonly [never];
+/**
+ * Check that an `Injectable` is valid for a given `Injector`.
+ */
+declare type CheckInjectable<I extends Injectable<Components, Provisions>, // the `Injectable` to check
+Components extends Constructor, // the `Injector`'s components
+Provisions extends Record<string, any>> = I extends {
+    $inject: infer Inject;
+} ? {
+    $inject: CheckInject<Inject, Components, Provisions>;
+    new (...args: MapInject<Inject, Provisions>): any;
+} : I extends new () => any ? I : {
+    $inject: readonly [Components | keyof Provisions, ...(Components | keyof Provisions)[]];
+};
+/**
+ * Return the unrolled type of a `Promise`
+ */
+declare type UnrollPromise<T> = T extends Promise<infer T> ? UnrollPromise<T> : T;
+/**
+ * Override the type for an `Injector`'s existing provision, or add a new one
+ */
+declare type ExtendProvisions<Provisions extends Record<string, any>, // the `Injector`'s provisions
+P extends string, // the new (string) key of the provision
+T> = {
+    [key in P | keyof Provisions]: key extends P ? UnrollPromise<T> : Provisions[key];
+};
+/** An `Injectable` defines a constructor for an injectable class */
+export interface Injectable<Components extends Constructor, Provisions extends Record<string, any>, T = any> {
+    prototype: T;
+    new (...args: any): T;
+    $inject?: readonly (Components | keyof Provisions)[];
+}
+/**
+ * The `Injections` interface abstracts the idea of getting bound and
+ * provisioned instances from an `Injector`, injecting new `Injectable`
+ * instances, and creating sub-`Injector`s.
+ */
+export interface Injections<Components extends Constructor, Provisions extends Record<string, any>> {
+    /** Get a _bound_ instance from an `Injector`. */
+    get<C extends Components>(component: C): Promise<InstanceType<C>>;
+    /** Get a _provisioned_ instance from an `Injector`. */
+    get<P extends keyof Provisions>(provision: P): Promise<Provisions[P]>;
+    /**
+     * Create a new instance of the specified `Injectable`, providing it with all
+     * necessary injections.
+     *
+     * @param injectable The constructor of the instance to create.
+     */
+    inject<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Promise<InstanceType<I>>;
+    /** Create a sub-`Injector` child of the current one. */
+    injector(): Injector<Components, Provisions>;
+}
+/** A `Factory` is a _function_ creating instances of a given type. */
+export declare type Factory<Components extends Constructor = Constructor, Provisions extends Record<string, any> = Record<string, any>, T = any> = (injections: Injections<Components, Provisions>) => T | Promise<T>;
+/**
+ * The `Injector` class acts as a registry of components and provisions,
+ * creating instances and injecting dependencies.
+ */
+export declare class Injector<Components extends Constructor = never, Provisions extends Record<string, any> = {}> implements Injections<Components, Provisions> {
+    #private;
+    /** Bind an `Injectable` to this `Injector`. */
+    bind<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Injector<Components | I, Provisions>;
+    /** Bind an `Injectable` to a `Constructor` in this `Injector`. */
+    bind<C extends Constructor, I extends Injectable<Components, Provisions, InstanceType<C>>>(component: C, injectable: I & CheckInjectable<I, Components, Provisions>): Injector<Components | C, Provisions>;
+    /** Bind an `Injectable` to a name in this `Injector`. */
+    bind<P extends string, I extends Injectable<Components, Provisions>>(provision: P, injectable: I & CheckInjectable<I, Components, Provisions>): Injector<Components, ExtendProvisions<Provisions, P, InstanceType<I>>>;
+    /** Use a `Factory` to create instances bound to the given `Constructor`. */
+    create<C extends Constructor>(component: C, factory: Factory<Components, Provisions, InstanceType<C>>): Injector<Components | C, Provisions>;
+    /** Use a `Factory` to create instances bound to the given name. */
+    create<P extends string, F extends Factory<Components, Provisions>>(provision: P, factory: F): Injector<Components, ExtendProvisions<Provisions, P, ReturnType<F>>>;
+    /** Use the given instance binding it to to the given `Constructor`. */
+    use<C extends Constructor>(component: C, instance: InstanceType<C>): Injector<Components | C, Provisions>;
+    /** Use the given instance binding it to to the given name. */
+    use<P extends string, T>(provision: P, instance: T): Injector<Components, ExtendProvisions<Provisions, P, T>>;
+    /** Get a _bound_ instance from an `Injector` */
+    get<C extends Components>(component: C): Promise<InstanceType<C>>;
+    /** Get a _provisioned_ instance from an `Injector` */
+    get<P extends keyof Provisions>(provision: P): Promise<Provisions[P]>;
+    /**
+     * Create a new instance of the specified `Injectable`, providing all
+     * necessary injections.
+     *
+     * @param injectable The constructor of the instance to create.
+     */
+    inject<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Promise<InstanceType<I>>;
+    /** Create a sub-`Injector` child of this one. */
+    injector(): Injector<Components, Provisions>;
+}
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "siringa",
+  "version": "0.0.1",
+  "description": "Simple type-checking injection library for Typescript",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "scripts": {
+    "build": "./build.sh",
+    "dev": "nodemon -e ts -x ./build.sh -w src -w test -w test-d",
+    "lint": "eslint src test test-d",
+    "prepare": "patch -N -p0 -i .nyc.patch || true"
+  },
+  "author": "Juit Developers <developers@juit.com>",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/chai": "^4.3.0",
+    "@types/chai-as-promised": "^7.1.5",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "~16.11.26",
+    "@typescript-eslint/eslint-plugin": "^5.12.1",
+    "@typescript-eslint/parser": "^5.12.1",
+    "chai": "^4.3.6",
+    "chai-as-promised": "^7.1.1",
+    "esbuild": "^0.14.23",
+    "eslint": "^8.9.0",
+    "eslint-config-google": "^0.14.0",
+    "mocha": "^9.2.1",
+    "nodemon": "^2.0.15",
+    "nyc": "^15.1.0",
+    "source-map-support": "^0.5.21",
+    "tsd": "^0.19.1",
+    "typescript": "^4.5.5"
+  },
+  "directories": {
+    "test": "test"
+  }
+}

package/src/index.ts

@@ -0,0 +1,342 @@
+/** A generic constructor */
+type Constructor<T = any> = abstract new (...args: any) => T
+
+/* ========================================================================== */
+
+/**
+ * Check that an `Injector`'s static `$inject` member matches the `Injector`'s
+ * own components and provisions
+ */
+type CheckInject<
+  Inject, // the tuple from "$inject"
+  Components extends Constructor, // the `Injector`'s components
+  Provisions extends Record<string, any>, // the `Injector`'s provisions
+> =
+  // if "$inject" is an empty array, then we're fine
+  Inject extends readonly [] ?
+    readonly [] :
+
+  // if "$inject" is a single-element tuple, check that that this element is
+  // actually included in the list of components
+  Inject extends readonly [ infer I1 ] ?
+    I1 extends keyof Provisions ?
+      readonly [ I1 ] :
+    I1 extends Extract<Components, I1> ?
+      readonly [ I1 ] :
+    readonly [ never ] :
+
+  // if "$inject" is a multi-element tuple, recurse (twice) by cheking the first
+  // element as a single-element tuple (see above), and the remaining members.
+  Inject extends readonly [ infer I1, ...infer I2 ] ?
+    readonly [
+      ...CheckInject<[ I1 ], Components, Provisions>,
+      ...CheckInject<I2, Components, Provisions>,
+    ] :
+
+  // "$inject" here is something else (likely, an array but not "as const")
+  // so we want to fail by re-declaring it as a tuple
+  readonly [ Components | keyof Provisions, ...(Components | keyof Provisions)[] ]
+
+/* ========================================================================== */
+
+/**
+ * Map the contents of the static `$inject` member to their types, resolving
+ * named provisions.
+ */
+type MapInject<
+  Inject, // the tuple from "$inject"
+  Provisions extends Record<string, any>, // the `Injector`'s provisions
+> =
+  // if "$inject" is an empty array, then we're fine
+  Inject extends readonly [] ?
+    readonly [] :
+
+  // "$inject" is a single-element tuple
+  Inject extends readonly [ infer I1 ] ?
+    I1 extends keyof Provisions ?
+      readonly [ Provisions[I1] ] :
+    I1 extends Constructor ?
+      readonly [ InstanceType<I1> ] :
+    readonly [ never ] :
+
+  // "$inject" is a multi-element tuple (recurse)
+  Inject extends readonly [ infer I1, ...infer I2 ] ?
+    readonly [
+      ...MapInject<[ I1 ], Provisions>,
+      ...MapInject<I2, Provisions>,
+    ] :
+
+  // "$inject" is something else
+  readonly [ never ]
+
+/* ========================================================================== */
+
+/**
+ * Check that an `Injectable` is valid for a given `Injector`.
+ */
+type CheckInjectable<
+  I extends Injectable<Components, Provisions>, // the `Injectable` to check
+  Components extends Constructor, // the `Injector`'s components
+  Provisions extends Record<string, any>, // the `Injector`'s provisions
+> =
+  // If the static "$inject" member is specified, check it and map its
+  // types as constructor arguments for the `Injectable`
+  I extends { $inject: infer Inject } ?
+    {
+      $inject: CheckInject<Inject, Components, Provisions>,
+      new (...args: MapInject<Inject, Provisions>): any,
+    } :
+
+  // If "$inject" is not specified, the only valid injector is one with
+  // an empty (zero arguments) constructor
+  I extends new () => any ?
+    I :
+
+  // Anything else requires "$inject" to be present
+  { $inject: readonly [ Components | keyof Provisions, ...(Components | keyof Provisions)[] ] }
+
+/* ========================================================================== */
+
+/**
+ * Return the unrolled type of a `Promise`
+ */
+type UnrollPromise<T> = T extends Promise<infer T> ? UnrollPromise<T> : T
+
+/* ========================================================================== */
+
+/**
+ * Override the type for an `Injector`'s existing provision, or add a new one
+ */
+type ExtendProvisions<
+  Provisions extends Record<string, any>, // the `Injector`'s provisions
+  P extends string, // the new (string) key of the provision
+  T, // the new type associated with the provision key
+> = {
+  [ key in P | keyof Provisions ]:
+    key extends P ?
+      UnrollPromise<T> :
+      Provisions[key]
+}
+
+/* ========================================================================== */
+
+type Binding = Constructor | string
+
+function bindingName(binding: Binding): string {
+  return typeof binding === 'function' ? `[class ${binding.name}]` : `"${binding}"`
+}
+
+/* ========================================================================== *
+ * EXPORTED TYPES                                                             *
+ * ========================================================================== */
+
+/** An `Injectable` defines a constructor for an injectable class */
+export interface Injectable<
+  Components extends Constructor,
+  Provisions extends Record<string, any>,
+  T = any,
+> {
+  prototype: T
+  new (...args: any): T
+  $inject?: readonly (Components | keyof Provisions)[]
+}
+
+/**
+ * The `Injections` interface abstracts the idea of getting bound and
+ * provisioned instances from an `Injector`, injecting new `Injectable`
+ * instances, and creating sub-`Injector`s.
+ */
+export interface Injections<
+  Components extends Constructor,
+  Provisions extends Record<string, any>,
+> {
+  /** Get a _bound_ instance from an `Injector`. */
+  get<C extends Components>(component: C): Promise<InstanceType<C>>
+
+  /** Get a _provisioned_ instance from an `Injector`. */
+  get<P extends keyof Provisions>(provision: P): Promise<Provisions[P]>
+
+  /**
+   * Create a new instance of the specified `Injectable`, providing it with all
+   * necessary injections.
+   *
+   * @param injectable The constructor of the instance to create.
+   */
+  inject<I extends Injectable<Components, Provisions>>(
+    injectable: I & CheckInjectable<I, Components, Provisions>,
+  ): Promise<InstanceType<I>>
+
+  /** Create a sub-`Injector` child of the current one. */
+  injector(): Injector<Components, Provisions>
+}
+
+/** A `Factory` is a _function_ creating instances of a given type. */
+export type Factory<
+  Components extends Constructor = Constructor,
+  Provisions extends Record<string, any> = Record<string, any>,
+  T = any,
+> = (injections: Injections<Components, Provisions>) => T | Promise<T>
+
+/**
+ * The `Injector` class acts as a registry of components and provisions,
+ * creating instances and injecting dependencies.
+ */
+export class Injector<
+  Components extends Constructor = never,
+  Provisions extends Record<string, any> = {},
+> implements Injections<Components, Provisions> {
+  readonly #factories: Map<Binding, (stack: Binding[]) => Promise<any>> = new Map()
+  readonly #promises: Map<Binding, Promise<any>> = new Map()
+  #parent?: Injector<Constructor, Record<string, any>>
+
+  /* INTERNALS ============================================================== */
+
+  async #get(binding: Binding, stack: Binding[]): Promise<any> {
+    if (stack.includes(binding)) {
+      if (this.#parent) return this.#parent.#get(binding, [])
+      const message = `Recursion detected injecting ${bindingName(binding)}`
+      return Promise.reject(new Error(message))
+    }
+
+    const promise = this.#promises.get(binding)
+    if (promise) return promise
+
+    const factory = this.#factories.get(binding)
+    if (factory) {
+      const promise = Promise.resolve().then(() => factory([ ...stack, binding ]))
+      this.#promises.set(binding, promise)
+      return promise
+    }
+
+    if (this.#parent) return this.#parent.#get(binding, [])
+
+    const message = `Unable to resolve binding ${bindingName(binding)}`
+    return Promise.reject(new Error(message))
+  }
+
+  async #inject(injectable: Injectable<Components, Provisions>, stack: Binding[]): Promise<any> {
+    const promises = injectable.$inject?.map((binding: any) => this.#get(binding, stack))
+    const injections = promises ? await Promise.all(promises) : []
+
+    // eslint-disable-next-line new-cap
+    return new injectable(...injections)
+  }
+
+  /* BINDING ================================================================ */
+
+  /** Bind an `Injectable` to this `Injector`. */
+  bind<I extends Injectable<Components, Provisions>>(
+    injectable: I & CheckInjectable<I, Components, Provisions>,
+  ): Injector<Components | I, Provisions>
+
+  /** Bind an `Injectable` to a `Constructor` in this `Injector`. */
+  bind<C extends Constructor, I extends Injectable<Components, Provisions, InstanceType<C>>>(
+    component: C,
+    injectable: I & CheckInjectable<I, Components, Provisions>,
+  ): Injector<Components | C, Provisions>
+
+  /** Bind an `Injectable` to a name in this `Injector`. */
+  bind<P extends string, I extends Injectable<Components, Provisions>>(
+    provision: P,
+    injectable: I & CheckInjectable<I, Components, Provisions>,
+  ): Injector<Components, ExtendProvisions<Provisions, P, InstanceType<I>>>
+
+  // Overloaded implementation
+  bind(
+    binding: Binding,
+    maybeInjectable?: Injectable<Components, Provisions>,
+  ): this {
+    const injectable = maybeInjectable ? maybeInjectable :
+        binding as Injectable<Components, Provisions>
+
+    this.#factories.set(binding, async (stack) => this.#inject(injectable, stack))
+    return this
+  }
+
+  /* FACTORIES ============================================================== */
+
+  /** Use a `Factory` to create instances bound to the given `Constructor`. */
+  create<C extends Constructor>(
+    component: C,
+    factory: Factory<Components, Provisions, InstanceType<C>>,
+  ): Injector<Components | C, Provisions>
+
+  /** Use a `Factory` to create instances bound to the given name. */
+  create<P extends string, F extends Factory<Components, Provisions>>(
+    provision: P,
+    factory: F,
+  ): Injector<Components, ExtendProvisions<Provisions, P, ReturnType<F>>>
+
+  // Overloaded implementation
+  create(
+    binding: Binding,
+    factory: Factory<Components, Provisions>,
+  ): this {
+    this.#factories.set(binding, async (stack) => factory({
+      get: (component: any) => this.#get(component, stack),
+      inject: async (injectable: any) => this.#inject(injectable, stack),
+      injector: () => this.injector(),
+    }))
+
+    return this
+  }
+
+  /* INSTANCES ============================================================== */
+
+  /** Use the given instance binding it to to the given `Constructor`. */
+  use<C extends Constructor>(
+    component: C,
+    instance: InstanceType<C>,
+  ): Injector<Components | C, Provisions>
+
+  /** Use the given instance binding it to to the given name. */
+  use<P extends string, T>(
+    provision: P,
+    instance: T,
+  ): Injector<Components, ExtendProvisions<Provisions, P, T>>
+
+  // Overloaded implementation
+  use(
+    binding: Binding,
+    instance: any,
+  ): this {
+    this.#promises.set(binding, Promise.resolve(instance))
+    return this
+  }
+
+  /* INSTANCES ============================================================== */
+
+  /** Get a _bound_ instance from an `Injector` */
+  get<C extends Components>(component: C): Promise<InstanceType<C>>
+
+  /** Get a _provisioned_ instance from an `Injector` */
+  get<P extends keyof Provisions>(provision: P): Promise<Provisions[P]>
+
+  // Overloaded implementation
+  async get<B extends Binding>(
+    binding: B,
+  ): Promise<any> {
+    return this.#get(binding, [])
+  }
+
+  /**
+   * Create a new instance of the specified `Injectable`, providing all
+   * necessary injections.
+   *
+   * @param injectable The constructor of the instance to create.
+   */
+  async inject<I extends Injectable<Components, Provisions>>(
+    injectable: I & CheckInjectable<I, Components, Provisions>,
+  ): Promise<InstanceType<I>> {
+    return this.#inject(injectable, [])
+  }
+
+  /* CHILD INJECTORS ======================================================== */
+
+  /** Create a sub-`Injector` child of this one. */
+  injector(): Injector<Components, Provisions> {
+    const injector = new Injector<Components, Provisions>()
+    injector.#parent = this
+    return injector
+  }
+}