ts-ioc-container 72.1.0 → 72.3.0

package/AGENTS.md

@@ -0,0 +1,179 @@
+# ts-ioc-container — guide for AI coding agents
+
+This file ships inside the npm package, so it matches the version installed in
+`node_modules`. **Trust it over what you remember**: the API changed a lot
+between major versions, and code written for an older version usually compiles
+badly or not at all. Every recipe below is executed by the package's test suite
+(`__tests__/readme/agentRecipes.spec.ts`).
+
+More detail: `README.md` next to this file. Types with JSDoc: `typings/`.
+Source: `lib/`.
+
+## Setup
+
+```shell
+npm install ts-ioc-container reflect-metadata
+```
+
+```typescript
+import 'reflect-metadata'; // first line of the entrypoint
+```
+
+```json
+{ "compilerOptions": { "experimentalDecorators": true, "emitDecoratorMetadata": true } }
+```
+
+## Recipes
+
+### Register a class and inject it by token
+
+```typescript
+import { bindTo, by, Container, inject, register, Registration as R, scope, singleton, SingleToken } from 'ts-ioc-container';
+
+interface ILogger {
+  log(message: string): void;
+}
+const ILoggerToken = new SingleToken<ILogger>('ILogger');
+
+@register(bindTo(ILoggerToken), scope((s) => s.hasTag('application')), singleton())
+class Logger implements ILogger {
+  log(message: string) {}
+}
+
+class App {
+  constructor(@inject(by(ILoggerToken)) private logger: ILogger) {}
+}
+
+const container = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger));
+const app = container.resolve(App); // an unregistered class is constructed by the injector
+```
+
+### Request-scoped service depending on an application singleton
+
+```typescript
+const IRepositoryToken = new SingleToken<Repository>('IRepository');
+
+@register(bindTo(IRepositoryToken), scope((s) => s.hasTag('request')), singleton())
+class Repository {
+  constructor(@inject(by(ILoggerToken)) readonly logger: ILogger) {}
+}
+
+const app = new Container({ tags: ['application'] })
+  .addRegistration(R.fromClass(Logger))
+  .addRegistration(R.fromClass(Repository));
+
+const request = app.createScope({ tags: ['request'] }); // one per request
+const repo = IRepositoryToken.resolve(request);
+request.dispose(); // when the request ends; child scopes are not disposed automatically
+```
+
+Use tags `application` / `request` / `transaction` on a backend and
+`application` / `page` / `widget` on a frontend.
+
+### Values and factories
+
+```typescript
+container
+  .addRegistration(R.fromValue('https://api.example.com').bindTo('API_URL'))
+  .addRegistration(R.fromFn(({ scope }) => `${scope.resolve<string>('API_URL')}/v1`).bindTo('API_V1'));
+```
+
+Use the fluent `.bindTo(...)` only for `fromValue` / `fromFn` and for classes
+you don't own. For your own classes, use `@register(bindTo(...))`.
+
+### Runtime arguments
+
+```typescript
+@register(bindTo(IClientToken))
+class Client {
+  constructor(@inject(arg(0)) readonly baseUrl: string) {}
+}
+
+IClientToken.args('https://a.example.com').resolve(container);
+IClientToken.resolve(container, { args: ['https://b.example.com'] });
+container.resolve<Client>('IClient', { args: ['https://c.example.com'] });
+```
+
+`token.args(...)`, `token.argsFn(...)` and `token.lazy()` return a **new**
+token; the original is never changed.
+
+### Lifecycle hooks (you run them)
+
+The library only **collects** hooks. It ships no hook names, no hook modules and
+no runner. Define the hook name, collect on an event, and run the actions:
+
+```typescript
+import { hook, HookCollector, type HookType, runInOrder, toTask } from 'ts-ioc-container';
+
+const onInit = (fn: HookType) => hook('onInit', fn);
+const onInitHooks = new HookCollector({ key: 'onInit' });
+
+class Service {
+  @onInit((ctx) => {
+    ctx.invokeMethod({ args: ctx.resolveArgs() }); // hook functions return void
+  })
+  init() {}
+}
+
+container.getInjector().onConstructed((instance, scope) => {
+  void runInOrder(onInitHooks.getActions(instance, { scope }).map(toTask));
+});
+```
+
+Other events to collect on: `container.scopeDisposed.subscribe(...)`,
+`container.registered.subscribe((provider) => provider.onResolved(...))`, or the
+`onResolve(...)` registration pipe for a single registration. Combine several
+hooks on one member with `sequential(...)`, `parallel(...)` or
+`oncePerInstance(...)`. Decorating one member twice with the same key replaces
+the first hook.
+
+## Pitfalls
+
+| Symptom | Cause | Fix |
+| --- | --- | --- |
+| Constructor param is `undefined` | Params without `@inject` are never injected | Annotate every param: `@inject(by(Token))` |
+| TS error on `@inject(Token)` | `inject` takes one `InjectFn` | `@inject(by(Token))`, `@inject(by('Key'))`, `@inject(by(Class))` |
+| TS error on `container.resolve(Token)` | `container.resolve` takes a key or a class | `Token.resolve(container)` |
+| A "singleton" differs per request | A registration without `scope(...)` is copied into every child scope | Add `scope((s) => s.hasTag('application'))` |
+| `DependencyNotFoundError` from an outer scope | Outer scopes cannot resolve inner-scope-only dependencies | Register the dependency in the outer scope too, or move the consumer inward |
+| Registration missing in an existing child scope | Scopes copy registrations when `createScope()` runs | Register before creating the scope, or add it to the child |
+| Constructor receives a token object instead of an instance | Args are passed as-is, never resolved | `Token.argsFn((scope) => [Other.resolve(scope)])` |
+| Hook method never runs | Nothing runs hooks for you | Collect with `HookCollector` and run the actions (see above) |
+| TS error on a hook arrow function | `HookFn` must return `void` or `Promise<void>` | Use a block body: `(ctx) => { ... }` |
+| `@inject` metadata missing at runtime | `reflect-metadata` not imported first | `import 'reflect-metadata'` at the top of the entrypoint |
+
+## Removed APIs (do not use)
+
+| Removed | Use instead |
+| --- | --- |
+| `@inject(Token)`, `@inject('Key')`, `@inject(Token, ...mappers)` | `@inject(by(Token))`, `@inject(pipe(by(Token), mapFn))` |
+| `toMappedToken` | `pipe(by(Token), ...mappers)` |
+| `InjectFn` as `(scope, options)` | `({ scope, args }) => ...` — the scope is inside the options object |
+| `onConstruct`, `onDispose`, `onResolved` decorators from the library | Define your own: `const onConstruct = (fn: HookType) => hook('onConstruct', fn)` |
+| `OnConstructModule`, `OnDisposeModule`, `OnResolvedModule`, `resolved(...)` | Subscribe to `getInjector().onConstructed`, `scopeDisposed`, `registered` yourself |
+| Hook execution strategies, `onError` options | Run the collected actions yourself (`runInOrder`, `runAtOnce`, `toTask`) |
+| `Async`-suffixed hooks and modules | Hooks are async-capable by default |
+| `onceResolved`, `onceResolvedAsync` | `oncePerInstance(hook)` |
+| Several hooks passed to one `@hook(...)` | `@hook(key, sequential(a, b))` or `parallel(a, b)` |
+| `container.onScopeCreated(...)` and similar methods | `container.scopeCreated.subscribe(...)` (events return an unsubscribe fn) |
+| `args(index)` injector helper | `arg(index)`; `args` now injects the whole args array |
+| `InjectionToken.getKey()` | Tokens are `Serializable` |
+| Args that are tokens being auto-resolved | `token.argsFn((scope) => [Other.resolve(scope)])` |
+| `isProxy`, `getProxyTarget` | `unwrapProxy` |
+
+## Errors
+
+All errors extend `ContainerError` and carry a stable `code`:
+
+| Code | Error | Usually means |
+| --- | --- | --- |
+| `IOC_DEPENDENCY_NOT_FOUND` | `DependencyNotFoundError` | Key not registered in this scope chain, or excluded by `scope(...)` / `scopeAccess(...)` |
+| `IOC_DEPENDENCY_MISSING_KEY` | `DependencyMissingKeyError` | A registration has no key: add `bindTo(...)` |
+| `IOC_CONTAINER_DISPOSED` | `ContainerDisposedError` | Using a scope after `dispose()` |
+| `IOC_PROVIDER_DISPOSED` | `ProviderDisposedError` | Using a provider after its scope was disposed |
+| `IOC_EVENT_DISPOSED` | `TypedEventDisposedError` | Subscribing to an event of a disposed scope |
+| `IOC_SINGLETON_APPLIED_TWICE` | `CannotApplySingletonTwiceError` | `singleton()` appears twice in one registration |
+| `IOC_UNSUPPORTED_TOKEN_TYPE` | `UnsupportedTokenTypeError` | `toToken(...)` got a value that is not a key, class or token |
+| `IOC_ARGUMENT_NOT_FOUND` | `ArgumentNotFoundError` | `findOrFail` / `argsFn` predicate matched nothing |
+| `IOC_CONTAINER_NOT_FOUND` | `ContainerNotFoundError` | No container is associated with the target |
+| `IOC_METHOD_NOT_IMPLEMENTED` | `MethodNotImplementedError` | Called a method the object does not support (e.g. on `EmptyContainer`) |

package/README.md

@@ -53,6 +53,7 @@ provider pipelines, aliases, and custom injector strategies.
   - [Token](#token) `bindTo`
   - [Scope](#scope) `scope`
   - [Composing decorators](#composing-decorators) `createComposeClassDecorator`
+  - [Feature flags](#feature-flags) `MultiVariantFeatureToken` `ToggleFeatureToken`
 - [Module](#module)
 - [Hook](#hook) `@hook`
   - [Hook domains](#hook-domains) `ScopeHook` `InjectorHook` `ProviderHook`
@@ -2887,6 +2888,174 @@ describe('composing decorators', () => {
 
 ```
 
+### Feature flags
+
+Feature tokens let a feature flag choose which implementation is injected, so
+consumers depend on one type and never see the flag. The implementations
+decide where they belong - each one's own token declares its role:
+
+- `token.variantOf(Feature, 'blue')` - used while the flag serves the variant `blue` (`getVariant`)
+- `token.primaryVariantOf(Feature)` - used while the flag is on and no named variant implementation matches
+- `token.fallbackOf(Feature)` - used otherwise: the flag is off, serves nothing implemented, or its client throws
+
+**Every flag has a fallback**: resolving a feature without one registered is a
+`DependencyNotFoundError`, whatever the flag serves. `MultiVariantFeatureToken<T, V>`
+is the general case; `ToggleFeatureToken<T>` is its on/off case - no named
+variants, only a primary one (`isEnabled`). Each implementation stays
+injectable through its own token.
+
+The flag client comes from `IFeatureFlagsToken` and the context it evaluates
+for from `IFeatureContextToken`, both resolved from the resolving scope on every
+resolution - register the context in your `request` scope. A missing client or
+context is a `DependencyNotFoundError`, never a silent fallback.
+
+`IFeatureFlags` is shaped after Unleash (`isEnabled(name, context)`,
+`getVariant(name, context)`), so an Unleash client is registered as is:
+`R.fromValue(unleash).bindTo(IFeatureFlagsToken)`. Resolution is synchronous;
+wrap an asynchronous client (e.g. the OpenFeature server SDK) in an adapter
+that evaluates ahead of time. `Feature.lazy()` defers the evaluation to first use.
+
+```typescript
+import 'reflect-metadata';
+import {
+  by,
+  Container,
+  type FeatureContext,
+  type FeatureVariant,
+  type IFeatureFlags,
+  IFeatureContextToken,
+  IFeatureFlagsToken,
+  inject,
+  MultiVariantFeatureToken,
+  register,
+  Registration as R,
+  SingleToken,
+  ToggleFeatureToken,
+} from 'ts-ioc-container';
+
+/**
+ * Checkout Domain - Feature Flags
+ *
+ * A flag chooses which implementation is injected; the consumer depends on one
+ * type and never sees the flag. The implementations decide where they belong:
+ * each one's own token declares it
+ *
+ * - `.variantOf(feature, name)` - used while the flag serves the variant `name`;
+ * - `.primaryVariantOf(feature)` - used while the flag is on and no named
+ *   variant implementation matches (the "on" side of a toggle);
+ * - `.fallbackOf(feature)` - used otherwise. Every flag has one.
+ *
+ * `ToggleFeatureToken` is the on/off case of `MultiVariantFeatureToken`: no
+ * named variants, only a primary one.
+ *
+ * The flag client is any object with `isEnabled(name, context)` and
+ * `getVariant(name, context)` - an Unleash client works as is:
+ *   container.addRegistration(R.fromValue(unleash).bindTo(IFeatureFlagsToken));
+ */
+
+// Toggle: new checkout on / off
+interface IPaymentGateway {
+  pay(amount: number): string;
+}
+
+const PaymentGatewayToken = new ToggleFeatureToken<IPaymentGateway>('new-checkout');
+
+// Each implementation's own token declares where it belongs
+@register(new SingleToken<IPaymentGateway>('LegacyGateway').fallbackOf(PaymentGatewayToken))
+class LegacyGateway implements IPaymentGateway {
+  pay(amount: number) {
+    return `legacy charged ${amount}`;
+  }
+}
+
+@register(new SingleToken<IPaymentGateway>('StripeGateway').primaryVariantOf(PaymentGatewayToken))
+class StripeGateway implements IPaymentGateway {
+  pay(amount: number) {
+    return `stripe charged ${amount}`;
+  }
+}
+
+// Multi-variant: A/B/n experiment on the checkout button
+interface ICheckoutButton {
+  render(): string;
+}
+
+const CheckoutButtonToken = new MultiVariantFeatureToken<ICheckoutButton, 'blue' | 'green'>('checkout-button');
+
+@register(new SingleToken<ICheckoutButton>('GreyButton').fallbackOf(CheckoutButtonToken))
+class GreyButton implements ICheckoutButton {
+  render() {
+    return 'grey button';
+  }
+}
+
+@register(new SingleToken<ICheckoutButton>('BlueButton').variantOf(CheckoutButtonToken, 'blue'))
+class BlueButton implements ICheckoutButton {
+  render() {
+    return 'blue button';
+  }
+}
+
+@register(new SingleToken<ICheckoutButton>('GreenButton').variantOf(CheckoutButtonToken, 'green'))
+class GreenButton implements ICheckoutButton {
+  render() {
+    return 'green button';
+  }
+}
+
+class CheckoutPage {
+  constructor(
+    @inject(by(PaymentGatewayToken)) private readonly gateway: IPaymentGateway,
+    @inject(by(CheckoutButtonToken)) private readonly button: ICheckoutButton,
+  ) {}
+
+  render(amount: number) {
+    return `${this.button.render()}, ${this.gateway.pay(amount)}`;
+  }
+}
+
+// Stands in for an Unleash client
+class InMemoryFlags implements IFeatureFlags {
+  isEnabled(name: string, context?: FeatureContext) {
+    return name === 'new-checkout' && context?.userId === 'beta-tester';
+  }
+
+  getVariant(name: string, context?: FeatureContext): FeatureVariant {
+    const bucket = { 'beta-tester': 'green', 'user-1': 'blue' }[context?.userId ?? ''];
+    return name === 'checkout-button' && bucket
+      ? { name: bucket, enabled: true }
+      : { name: 'disabled', enabled: false };
+  }
+}
+
+describe('Feature flags', () => {
+  const app = new Container({ tags: ['application'] })
+    .addRegistration(R.fromValue(new InMemoryFlags()).bindTo(IFeatureFlagsToken))
+    .addRegistration(R.fromClass(LegacyGateway))
+    .addRegistration(R.fromClass(GreyButton))
+    .addRegistration(R.fromClass(StripeGateway))
+    .addRegistration(R.fromClass(BlueButton))
+    .addRegistration(R.fromClass(GreenButton));
+
+  // The context is per request: each request evaluates the flags for its own user
+  const handleRequest = (userId: string) => {
+    const request = app.createScope({ tags: ['request'] });
+    request.addRegistration(R.fromValue({ userId }).bindTo(IFeatureContextToken));
+    return request.resolve(CheckoutPage).render(42);
+  };
+
+  it('serves each user the implementations their flags select', () => {
+    expect(handleRequest('beta-tester')).toBe('green button, stripe charged 42');
+    expect(handleRequest('user-1')).toBe('blue button, legacy charged 42');
+  });
+
+  it('serves the fallbacks to everyone else', () => {
+    expect(handleRequest('regular-user')).toBe('grey button, legacy charged 42');
+  });
+});
+
+```
+
 ## Module
 
 Sometimes you want to encapsulate registration logic in separate module. This is what `IContainerModule` is for.

package/cjm/container/Container.js

@@ -129,6 +129,9 @@ class Container {
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
+    hasAlias(alias) {
+        return this.aliases.getKeysByAlias(alias).length > 0 || this.parent.hasAlias(alias);
+    }
     addInstance(instance) {
         this.instances.add(instance);
     }
@@ -164,12 +167,12 @@ class Container {
     }
     validateContainer() {
         if (this.isDisposed) {
-            throw new ContainerDisposedError_1.ContainerDisposedError('Container is already disposed');
+            throw new ContainerDisposedError_1.ContainerDisposedError('Container is already disposed: a scope cannot be used after dispose(). Create a new scope.');
         }
     }
     findProviderByKeyOrFail(key) {
         if (!this.providers.has(key)) {
-            throw new DependencyNotFoundError_1.DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
+            throw new DependencyNotFoundError_1.DependencyNotFoundError(`Provider ${key.toString()} does not exist: an alias points at a key with no provider in this scope.`);
         }
         return this.providers.get(key);
     }

package/cjm/container/EmptyContainer.js

@@ -5,7 +5,7 @@ const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError
 const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
 class EmptyContainer {
     get isDisposed() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.isDisposed is not implemented');
     }
     addInstance(instance) { }
     getParent() {
@@ -21,25 +21,25 @@ class EmptyContainer {
         return false;
     }
     createScope() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.createScope is not implemented');
     }
     getInjector() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.getInjector is not implemented');
     }
     autoResolve(options) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.autoResolve is not implemented');
     }
     dispose() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.dispose is not implemented');
     }
     register(key, value) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.register is not implemented');
     }
     hasTag(tag) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.hasTag is not implemented');
     }
     addTags(...tags) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.addTags is not implemented');
     }
     getRegistrations() {
         return [];
@@ -47,30 +47,35 @@ class EmptyContainer {
     hasRegistration(key) {
         return false;
     }
+    hasAlias(alias) {
+        return false;
+    }
     removeScope() { }
     useModule(module) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.useModule is not implemented');
     }
     addRegistration(registration) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.addRegistration is not implemented');
     }
     resolve(key, options) {
-        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find ${key.toString()}`);
+        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find ${key.toString()}: no provider for this key in the resolving scope or any parent. ` +
+            'Check that it is registered, that its scope(...) rule matches this scope, that its scopeAccess(...) rule allows it, ' +
+            'and that it was registered before createScope() (existing child scopes are not updated).');
     }
     resolveByAlias(alias, options) {
         return [];
     }
     resolveOneByAlias(alias, options) {
-        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
+        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find alias ${alias.toString()}: no accessible registration carries this alias in the resolving scope or any parent.`);
     }
     get scopeCreated() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.scopeCreated is not implemented');
     }
     get scopeDisposed() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.scopeDisposed is not implemented');
     }
     get registered() {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('EmptyContainer.registered is not implemented');
     }
 }
 exports.EmptyContainer = EmptyContainer;

package/cjm/errors/ArgumentNotFoundError.js

@@ -4,6 +4,7 @@ exports.ArgumentNotFoundError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class ArgumentNotFoundError extends ContainerError_1.ContainerError {
     name = 'ArgumentNotFoundError';
+    code = 'IOC_ARGUMENT_NOT_FOUND';
     constructor(message = 'Argument not found') {
         super(message);
         Object.setPrototypeOf(this, ArgumentNotFoundError.prototype);

package/cjm/errors/CannonSingletonApplyTwiceError.js

@@ -1,17 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CannonSingletonApplyTwiceError = void 0;
-const ContainerError_1 = require("./ContainerError");
-class CannonSingletonApplyTwiceError extends ContainerError_1.ContainerError {
-    name = 'CannonSingletonApplyTwiceError';
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, CannonSingletonApplyTwiceError.prototype);
-    }
-    static assert(isTrue, failMessage) {
-        if (!isTrue) {
-            throw new CannonSingletonApplyTwiceError(failMessage);
-        }
-    }
-}
-exports.CannonSingletonApplyTwiceError = CannonSingletonApplyTwiceError;
+const CannotApplySingletonTwiceError_1 = require("./CannotApplySingletonTwiceError");
+exports.CannonSingletonApplyTwiceError = CannotApplySingletonTwiceError_1.CannotApplySingletonTwiceError;

package/cjm/errors/CannotApplySingletonTwiceError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CannotApplySingletonTwiceError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class CannotApplySingletonTwiceError extends ContainerError_1.ContainerError {
+    name = 'CannotApplySingletonTwiceError';
+    code = 'IOC_SINGLETON_APPLIED_TWICE';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CannotApplySingletonTwiceError.prototype);
+    }
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new CannotApplySingletonTwiceError(failMessage);
+        }
+    }
+}
+exports.CannotApplySingletonTwiceError = CannotApplySingletonTwiceError;

package/cjm/errors/ContainerDisposedError.js

@@ -4,6 +4,7 @@ exports.ContainerDisposedError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class ContainerDisposedError extends ContainerError_1.ContainerError {
     name = 'ContainerDisposedError';
+    code = 'IOC_CONTAINER_DISPOSED';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, ContainerDisposedError.prototype);

package/cjm/errors/ContainerError.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContainerError = void 0;
 class ContainerError extends Error {
     name = 'ContainerError';
+    code = 'IOC_CONTAINER_ERROR';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, ContainerError.prototype);

package/cjm/errors/ContainerNotFoundError.js

@@ -4,6 +4,7 @@ exports.ContainerNotFoundError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class ContainerNotFoundError extends ContainerError_1.ContainerError {
     name = 'ContainerNotFoundError';
+    code = 'IOC_CONTAINER_NOT_FOUND';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, ContainerNotFoundError.prototype);

package/cjm/errors/DependencyMissingKeyError.js

@@ -4,6 +4,7 @@ exports.DependencyMissingKeyError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class DependencyMissingKeyError extends ContainerError_1.ContainerError {
     name = 'DependencyMissingKeyError';
+    code = 'IOC_DEPENDENCY_MISSING_KEY';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, DependencyMissingKeyError.prototype);

package/cjm/errors/DependencyNotFoundError.js

@@ -4,6 +4,7 @@ exports.DependencyNotFoundError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class DependencyNotFoundError extends ContainerError_1.ContainerError {
     name = 'DependencyNotFoundError';
+    code = 'IOC_DEPENDENCY_NOT_FOUND';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, DependencyNotFoundError.prototype);

package/cjm/errors/MethodNotImplementedError.js

@@ -4,6 +4,7 @@ exports.MethodNotImplementedError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class MethodNotImplementedError extends ContainerError_1.ContainerError {
     name = 'MethodNotImplementedError';
+    code = 'IOC_METHOD_NOT_IMPLEMENTED';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, MethodNotImplementedError.prototype);

package/cjm/errors/ProviderDisposedError.js

@@ -4,6 +4,7 @@ exports.ProviderDisposedError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class ProviderDisposedError extends ContainerError_1.ContainerError {
     name = 'ProviderDisposedError';
+    code = 'IOC_PROVIDER_DISPOSED';
     static assert(isTrue, failMessage) {
         if (!isTrue) {
             throw new ProviderDisposedError(failMessage);

package/cjm/errors/TypedEventDisposedError.js

@@ -4,6 +4,7 @@ exports.TypedEventDisposedError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class TypedEventDisposedError extends ContainerError_1.ContainerError {
     name = 'TypedEventDisposedError';
+    code = 'IOC_EVENT_DISPOSED';
     static assert(isTrue, failMessage) {
         if (!isTrue) {
             throw new TypedEventDisposedError(failMessage);

package/cjm/errors/UnsupportedTokenTypeError.js

@@ -4,6 +4,7 @@ exports.UnsupportedTokenTypeError = void 0;
 const ContainerError_1 = require("./ContainerError");
 class UnsupportedTokenTypeError extends ContainerError_1.ContainerError {
     name = 'UnsupportedTokenTypeError';
+    code = 'IOC_UNSUPPORTED_TOKEN_TYPE';
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, UnsupportedTokenTypeError.prototype);

package/cjm/feature/IFeatureFlags.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IFeatureContextToken = exports.IFeatureFlagsToken = void 0;
+const SingleToken_1 = require("../token/SingleToken");
+exports.IFeatureFlagsToken = new SingleToken_1.SingleToken('IFeatureFlags');
+exports.IFeatureContextToken = new SingleToken_1.SingleToken('IFeatureContext');