@wirestate/lit 0.6.0 → 0.6.1

package/cjs/development/index.js

@@ -2,14 +2,60 @@
 
 var context = require('@lit/context');
 var core = require('@wirestate/core');
+var tslib = require('tslib');
 
+/**
+ * Context key for the IoC container.
+ *
+ * @group context
+ */
 var IOC_CONTAINER_KEY = Symbol("ContainerContext");
+/**
+ * Lit context for providing and consuming the IoC container.
+ *
+ * @group context
+ */
 var ContainerContext = context.createContext(IOC_CONTAINER_KEY);
 
-function injection(_a) {
-  var injectionId = _a.injectionId,
-    subscribe = _a.subscribe;
+/**
+ * Decorator to inject a service from the IoC container into a Lit element property.
+ *
+ * @group consumption
+ *
+ * @param optionsOrInjectionId - injection options including the service identifier or the service identifier itself
+ * @returns injection decorator instance
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @injection(MyService)
+ *   private myService!: MyService;
+ *
+ *   public render() {
+ *     return html`<div>${this.myService.getName()}</div>`;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @injection({ injectionId: MyService, once: true })
+ *   private myService!: MyService;
+ *
+ *   public render() {
+ *     return html`<div>${this.myService.getName()}</div>`;
+ *   }
+ * }
+ * ```
+ */
+function injection(optionsOrInjectionId) {
+  var options = typeof optionsOrInjectionId === "object" && optionsOrInjectionId !== null && "injectionId" in optionsOrInjectionId ? optionsOrInjectionId : {
+    injectionId: optionsOrInjectionId
+  };
   return function (protoOrTarget, nameOrContext) {
+    var injectionId = options.injectionId,
+      once = options.once;
     // Standard decorators branch.
     if (typeof nameOrContext === "object") {
       nameOrContext.addInitializer(function () {
@@ -19,7 +65,7 @@ function injection(_a) {
           callback: function (it) {
             protoOrTarget.set.call(_this, it.container.get(injectionId));
           },
-          subscribe: subscribe
+          subscribe: !once
         });
       });
     } else {
@@ -28,20 +74,53 @@ function injection(_a) {
         new context.ContextConsumer(element, {
           context: ContainerContext,
           callback: function (it) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             element[nameOrContext] = it.container.get(injectionId);
           },
-          subscribe: subscribe
+          subscribe: !once
         });
       });
     }
   };
 }
 
-function useInjection(host, _a) {
-  var once = _a.once,
-    injectionId = _a.injectionId,
-    value = _a.value;
+/**
+ * Hook (controller) to inject a service from the IoC container in a Lit component.
+ *
+ * @group consumption
+ *
+ * @param host - the host element
+ * @param optionsOrInjectionId - injection options including the service identifier or the service identifier itself
+ * @returns injection descriptor object
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private myService = useInjection(this, MyService);
+ *
+ *   render() {
+ *     return html`<div>${this.myService.value.getName()}</div>`;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private myService = useInjection(this, { injectionId: MyService, once: true });
+ *
+ *   render() {
+ *     return html`<div>${this.myService.value.getName()}</div>`;
+ *   }
+ * }
+ * ```
+ */
+function useInjection(host, optionsOrInjectionId) {
+  var options = typeof optionsOrInjectionId === "object" && optionsOrInjectionId !== null && "injectionId" in optionsOrInjectionId ? optionsOrInjectionId : {
+    injectionId: optionsOrInjectionId
+  };
+  var once = options.once,
+    injectionId = options.injectionId,
+    value = options.value;
   var current = {
     value: value,
     injectionId: injectionId
@@ -56,13 +135,427 @@ function useInjection(host, _a) {
   return current;
 }
 
-var ContainerProviderController = /** @class */function () {
-  function ContainerProviderController(host, container) {
+/**
+ * Reactive controller that registers a command handler on the {@link CommandBus} for the host element's lifetime.
+ *
+ * The handler is registered when the host connects and unregistered when it disconnects.
+ * When the IoC context is updated (container revision change), the handler is re-registered automatically.
+ *
+ * @group commands
+ */
+var OnCommandController = /** @class */function () {
+  /**
+   * @param host - The host element.
+   * @param type - The command type to handle.
+   * @param handler - The command handler function.
+   */
+  function OnCommandController(host, type, handler) {
+    var _this = this;
+    this.bus = null;
+    this.unregister = null;
+    host.addController(this);
+    this.type = type;
+    this.handler = handler;
+    new context.ContextConsumer(host, {
+      context: ContainerContext,
+      subscribe: true,
+      callback: function (context) {
+        _this.bus = context.container.get(core.CommandBus);
+        if (host.isConnected) {
+          _this.reregister();
+        }
+      }
+    });
+  }
+  OnCommandController.prototype.hostConnected = function () {
+    this.reregister();
+  };
+  OnCommandController.prototype.hostDisconnected = function () {
+    this.cleanup();
+  };
+  OnCommandController.prototype.reregister = function () {
+    this.cleanup();
+    if (this.bus) {
+      this.unregister = this.bus.register(this.type, this.handler);
+    }
+  };
+  OnCommandController.prototype.cleanup = function () {
+    var _a;
+    (_a = this.unregister) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregister = null;
+  };
+  return OnCommandController;
+}();
+
+/**
+ * Decorator that registers a Lit element method as a command handler for the given type.
+ *
+ * The handler is registered when the host element connects to the DOM and unregistered when it disconnects.
+ *
+ * @group commands
+ *
+ * @param type - the command type to handle
+ * @returns the decorator function.
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @onCommand("SAVE")
+ *   private handleSave(data: SomeData): void {
+ *     // handle command
+ *   }
+ * }
+ * ```
+ */
+function onCommand(type) {
+  return function (protoOrTarget, nameOrContext) {
+    if (typeof nameOrContext === "object") {
+      // Standard decorators:
+      nameOrContext.addInitializer(function () {
+        var _this = this;
+        new OnCommandController(this, type, function (data) {
+          return _this[nameOrContext.name](data);
+        });
+      });
+    } else {
+      // Experimental legacy decorators:
+      protoOrTarget.constructor.addInitializer(function (element) {
+        new OnCommandController(element, type, function (data) {
+          return element[nameOrContext](data);
+        });
+      });
+    }
+  };
+}
+
+/**
+ * Registers a command handler on the CommandBus for the host element's lifetime.
+ *
+ * @group commands
+ *
+ * @param host - the host element
+ * @param options - command handling options
+ * @param options.type - the command type to listen for
+ * @param options.handler - the command handler function
+ * @returns the command controller instance
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private onSave = useOnCommand(this, {
+ *     type: "SAVE",
+ *     handler: (data) => console.log("Saving:", data),
+ *   });
+ * }
+ * ```
+ */
+function useOnCommand(host, _a) {
+  var type = _a.type,
+    handler = _a.handler;
+  return new OnCommandController(host, type, handler);
+}
+
+/**
+ * Controller that subscribes to events from the event bus.
+ *
+ * It automatically handles subscription and unsubscription based on the host element's lifecycle.
+ *
+ * @group events
+ */
+var OnEventController = /** @class */function () {
+  /**
+   * @param host - the host element
+   * @param types - event types to listen for, if null, all events will be handled
+   * @param handler - the event handler function
+   */
+  function OnEventController(host, types, handler) {
+    var _this = this;
+    this.bus = null;
+    this.unsubscriber = null;
+    host.addController(this);
+    this.types = types;
+    this.handler = handler;
+    new context.ContextConsumer(host, {
+      context: ContainerContext,
+      subscribe: true,
+      callback: function (context) {
+        _this.bus = context.container.get(core.EventBus);
+        if (host.isConnected) {
+          _this.resubscribe();
+        }
+      }
+    });
+  }
+  OnEventController.prototype.hostConnected = function () {
+    this.resubscribe();
+  };
+  OnEventController.prototype.hostDisconnected = function () {
+    this.cleanup();
+  };
+  OnEventController.prototype.resubscribe = function () {
+    var _this = this;
+    this.cleanup();
+    if (this.bus) {
+      if (this.types === null) {
+        this.unsubscriber = this.bus.subscribe(this.handler);
+      } else {
+        this.unsubscriber = this.bus.subscribe(function (event) {
+          if (_this.types.includes(event.type)) {
+            _this.handler(event);
+          }
+        });
+      }
+    }
+  };
+  OnEventController.prototype.cleanup = function () {
+    var _a;
+    (_a = this.unsubscriber) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unsubscriber = null;
+  };
+  return OnEventController;
+}();
+
+/**
+ * Decorator to handle events from the event bus.
+ *
+ * @group events
+ *
+ * @param types - Event types to listen for. If omitted, all events will be handled.
+ * @returns The decorator function.
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @onEvent()
+ *   private onMyEvent(event: Event) {
+ *     console.log('Event received:', event);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @onEvent('MY_EVENT_TYPE')
+ *   private onMyEvent(event: MyEvent) {
+ *     console.log('Event received:', event);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @onEvent(['MY_EVENT_TYPE_1', 'MY_EVENT_TYPE_2'])
+ *   private onMyEvent(event: Event) {
+ *     console.log('Event received:', event);
+ *   }
+ * }
+ * ```
+ */
+function onEvent(types) {
+  var normalized = types === undefined ? null : Array.isArray(types) ? tslib.__spreadArray([], types, true) : [types];
+  return function (protoOrTarget, nameOrContext) {
+    if (typeof nameOrContext === "object") {
+      // Standard decorators:
+      nameOrContext.addInitializer(function () {
+        var _this = this;
+        new OnEventController(this, normalized, function (event) {
+          return _this[nameOrContext.name](event);
+        });
+      });
+    } else {
+      // Experimental legacy decorators:
+      protoOrTarget.constructor.addInitializer(function (element) {
+        new OnEventController(element, normalized, function (event) {
+          return element[nameOrContext](event);
+        });
+      });
+    }
+  };
+}
+
+/**
+ * Hook (controller) to handle events from the event bus.
+ *
+ * @group events
+ *
+ * @param host - the host element
+ * @param options - event handling options
+ * @param options.handler - event handler function
+ * @param options.types - event types to listen for, if null or undefined, all events will be handled
+ * @returns events subscription controller
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private eventHandler = useOnEvents(this, {
+ *     handler: (event) => console.log(event),
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private eventHandler = useOnEvents(this, {
+ *     types: [MyEvent],
+ *     handler: (event) => console.log(event),
+ *   });
+ * }
+ * ```
+ */
+function useOnEvents(host, _a) {
+  var types = _a.types,
+    handler = _a.handler;
+  var normalized = types ? Array.isArray(types) ? tslib.__spreadArray([], types, true) : [types] : null;
+  return new OnEventController(host, normalized, handler);
+}
+
+/**
+ * Reactive controller that registers a query handler on the {@link QueryBus} for the host element's lifetime.
+ *
+ * The handler is registered when the host connects and unregistered when it disconnects.
+ * When the IoC context is updated (container revision change), the handler is re-registered automatically.
+ *
+ * @group queries
+ */
+var OnQueryController = /** @class */function () {
+  /**
+   * @param host - the host element
+   * @param type - the query type to handle
+   * @param handler - the query handler function
+   */
+  function OnQueryController(host, type, handler) {
+    var _this = this;
+    this.bus = null;
+    this.unregister = null;
+    host.addController(this);
+    this.type = type;
+    this.handler = handler;
+    new context.ContextConsumer(host, {
+      context: ContainerContext,
+      subscribe: true,
+      callback: function (context) {
+        _this.bus = context.container.get(core.QueryBus);
+        if (host.isConnected) {
+          _this.reregister();
+        }
+      }
+    });
+  }
+  OnQueryController.prototype.hostConnected = function () {
+    this.reregister();
+  };
+  OnQueryController.prototype.hostDisconnected = function () {
+    this.cleanup();
+  };
+  OnQueryController.prototype.reregister = function () {
+    this.cleanup();
+    if (this.bus) {
+      this.unregister = this.bus.register(this.type, this.handler);
+    }
+  };
+  OnQueryController.prototype.cleanup = function () {
+    var _a;
+    (_a = this.unregister) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregister = null;
+  };
+  return OnQueryController;
+}();
+
+/**
+ * Decorator that registers a Lit element method as a query handler for the given type.
+ *
+ * The handler is registered when the host element connects to the DOM and unregistered when it disconnects.
+ *
+ * @group queries
+ *
+ * @param type - the query type to handle
+ * @returns the decorator function
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   @onQuery("GET_USER_NAME")
+ *   public onGetUserName(data: QueryData) {
+ *     return "Alice";
+ *   }
+ * }
+ * ```
+ */
+function onQuery(type) {
+  return function (protoOrTarget, nameOrContext) {
+    if (typeof nameOrContext === "object") {
+      // Standard decorators:
+      nameOrContext.addInitializer(function () {
+        var _this = this;
+        new OnQueryController(this, type, function (data) {
+          return _this[nameOrContext.name](data);
+        });
+      });
+    } else {
+      // Experimental legacy decorators:
+      protoOrTarget.constructor.addInitializer(function (element) {
+        new OnQueryController(element, type, function (data) {
+          return element[nameOrContext](data);
+        });
+      });
+    }
+  };
+}
+
+/**
+ * Registers a query handler on the {@link QueryBus} for the host element's lifetime.
+ *
+ * @group queries
+ *
+ * @param host - the host element
+ * @param options - query handling options
+ * @param options.type - the query type to handle
+ * @param options.handler - the query handler function
+ * @returns the query controller instance
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private getUserController = useOnQuery(this, {
+ *     type: "GET_USER",
+ *     handler: (data) => ({ name: "Alice" }),
+ *   });
+ * }
+ * ```
+ */
+function useOnQuery(host, _a) {
+  var type = _a.type,
+    handler = _a.handler;
+  return new OnQueryController(host, type, handler);
+}
+
+/**
+ * Controller that provides an IoC container context to the host element and its children.
+ *
+ * It manages the lifecycle of the container and handles revision updates to notify consumers.
+ *
+ * @group provision
+ */
+var IocProviderController = /** @class */function () {
+  /**
+   * @param host - the host element
+   * @param options - provisioning options
+   * @param options.container - optional existing container to use. If not provided, a new one will be created
+   * @param options.seed - optional seed data to apply to the container
+   */
+  function IocProviderController(host, _a) {
+    var _b = _a === void 0 ? {} : _a,
+      container = _b.container,
+      seed = _b.seed;
     var _this = this;
     this.host = host;
     this.revision = 1;
     this.host.addController(this);
     this.container = container !== null && container !== void 0 ? container : core.createIocContainer();
+    this.seed = seed;
     this.provider = new context.ContextProvider(host, {
       context: ContainerContext,
       initialValue: {
@@ -74,9 +567,23 @@ var ContainerProviderController = /** @class */function () {
       }
     });
   }
-  ContainerProviderController.prototype.hostConnected = function () {};
-  ContainerProviderController.prototype.hostDisconnected = function () {};
-  ContainerProviderController.prototype.nextRevision = function () {
+  Object.defineProperty(IocProviderController.prototype, "value", {
+    /**
+     * @returns current {@link IocContext} value served to child consumers
+     */
+    get: function () {
+      return this.provider.value;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  IocProviderController.prototype.hostConnected = function () {
+    if (this.seed) {
+      core.applySharedSeed(this.container, this.seed);
+    }
+  };
+  IocProviderController.prototype.hostDisconnected = function () {};
+  IocProviderController.prototype.nextRevision = function () {
     var _this = this;
     this.revision += 1;
     this.provider.setValue({
@@ -88,34 +595,148 @@ var ContainerProviderController = /** @class */function () {
     });
     return this.revision;
   };
-  return ContainerProviderController;
+  return IocProviderController;
 }();
 
-var ServicesProviderController = /** @class */function () {
-  function ServicesProviderController(host, options) {
+/**
+ * Decorator to provide an IoC container to child components.
+ *
+ * @group provision
+ *
+ * @param options - provisioning options including container and seed data
+ * @param options.container - optional existing container to use, if not provided, a new one will be created
+ * @param options.seed - optional seed data to apply to the container
+ * @returns IOC provision controller instance
+ *
+ * @example
+ * ```typescript
+ * class MyRootElement extends LitElement {
+ *   @iocProvide({ seed: { someData: 'value' } })
+ *   private ioc!: IocProviderController;
+ * }
+ * ```
+ */
+function iocProvide(_a) {
+  var _b = _a === void 0 ? {} : _a,
+    container = _b.container,
+    seed = _b.seed;
+  return function (protoOrTarget, nameOrContext) {
+    if (typeof nameOrContext === "object") {
+      // Standard decorators:
+      nameOrContext.addInitializer(function () {
+        protoOrTarget.set.call(this, new IocProviderController(this, {
+          container: container,
+          seed: seed
+        }));
+      });
+    } else {
+      var controller_1;
+      protoOrTarget.constructor.addInitializer(function (element) {
+        controller_1 = new IocProviderController(element, {
+          container: container,
+          seed: seed
+        });
+      });
+      return {
+        get: function () {
+          return controller_1;
+        },
+        set: function () {},
+        configurable: true,
+        enumerable: true
+      };
+    }
+  };
+}
+
+var ERROR_CODE_INVALID_ARGUMENTS = 2051;
+
+/**
+ * Controller that binds a set of injectables to an IoC container when the host connects
+ * and unbinds them when the host disconnects.
+ *
+ * When no `into` context is provided, the controller uses the nearest {@link IocProviderController}
+ * ancestor via Lit context. Seeds are applied before entries so that `@Inject(SEEDS_TOKEN)`
+ * works during service activation.
+ *
+ * @group provision
+ *
+ * @example
+ * ```typescript
+ * class MyComponent extends LitElement {
+ *   private services = new InjectablesProviderController(this, {
+ *     entries: [AuthService, UserService],
+ *     activate: [AuthService],
+ *     seeds: [[AuthService, { role: "admin" }]],
+ *   });
+ * }
+ * ```
+ */
+var InjectablesProviderController = /** @class */function () {
+  /**
+   * @param host - the host element
+   * @param options - provisioning options
+   * @param options.entries - list of service entries to bind to the container
+   * @param options.into - target IoC context; if omitted, uses the nearest provider context
+   * @param options.activate - list of service identifiers to activate immediately after binding
+   * @param options.seeds - seed data applied before binding
+   */
+  function InjectablesProviderController(host, options) {
+    var _this = this;
+    var _a, _b, _c;
     this.host = host;
+    /**
+     * Tracks the context to which entries are currently bound, for correct cleanup on disconnect.
+     */
+    this.boundContext = null;
     this.host.addController(this);
     this.entries = options.entries;
-    this.activate = options.activate;
-    this.seeds = options.seeds;
-    this.into = options.into;
-    this.consumer = new context.ContextConsumer(host, {
-      context: ContainerContext,
-      subscribe: true,
-      callback: function (it) {
-        return;
-      }
-    });
+    this.activate = (_a = options.activate) !== null && _a !== void 0 ? _a : null;
+    this.seeds = (_b = options.seeds) !== null && _b !== void 0 ? _b : null;
+    this.into = (_c = options.into) !== null && _c !== void 0 ? _c : null;
+    if (!this.into) {
+      // subscribe: false — binding happens once per connect, not on every revision update.
+      this.consumer = new context.ContextConsumer(host, {
+        context: ContainerContext,
+        subscribe: false,
+        callback: function (context) {
+          if (!host.isConnected) {
+            return;
+          }
+          _this.bind(context);
+        }
+      });
+    }
   }
-  ServicesProviderController.prototype.hostConnected = function () {
-    var context = this.into ? typeof this.into === "function" ? this.into() : this.into : this.consumer.value;
-    if (!context) {
-      if (this.consumer["provided"] === false) {
-        throw new Error("not provided");
+  InjectablesProviderController.prototype.hostConnected = function () {
+    var _a;
+    if (!this.into) {
+      // ContextConsumer with subscribe:false only invokes the user callback once (provided flag stays true
+      // after disconnect). On reconnect we fall back to the cached consumer.value so bind() still fires.
+      if ((_a = this.consumer) === null || _a === void 0 ? void 0 : _a.value) {
+        this.bind(this.consumer.value);
       }
-      throw new Error("todo");
+      return;
+    }
+    var context = typeof this.into === "function" ? this.into() : this.into;
+    if (!context) {
+      throw new core.WirestateError(ERROR_CODE_INVALID_ARGUMENTS, "InjectablesProviderController: the 'into' option resolved to null or undefined. " + "Ensure the value or resolver function returns a valid IocContext.");
+    }
+    this.bind(context);
+  };
+  InjectablesProviderController.prototype.hostDisconnected = function () {
+    if (!this.boundContext) {
+      return;
+    }
+    this.unbind(this.boundContext);
+  };
+  InjectablesProviderController.prototype.bind = function (context) {
+    if (this.boundContext) {
+      // Re-binding without unbinding first would leave stale entries; unbind the previous context.
+      this.unbind(this.boundContext);
     }
-    // Seed must be applied BEFORE binding so @Inject(INITIAL_STATE_TOKEN) works during activation.
+    this.boundContext = context;
+    // Seeds must be applied before binding so @Inject(SEEDS_TOKEN) resolves during activation.
     if (this.seeds) {
       core.applySeeds(context.container, this.seeds);
     }
@@ -125,38 +746,140 @@ var ServicesProviderController = /** @class */function () {
     }
     if (this.activate) {
       for (var _b = 0, _c = this.activate; _b < _c.length; _b++) {
-        var eager = _c[_b];
-        context.container.get(eager);
+        var token = _c[_b];
+        context.container.get(token);
       }
     }
   };
-  ServicesProviderController.prototype.hostDisconnected = function () {
-    var context = this.into ? typeof this.into === "function" ? this.into() : this.into : this.consumer.value;
-    if (!context) {
-      throw new Error("todo");
-    }
+  InjectablesProviderController.prototype.unbind = function (context) {
     for (var _i = 0, _a = this.entries; _i < _a.length; _i++) {
       var entry = _a[_i];
       var token = core.getEntryToken(entry);
-      context.container.unbind(token);
+      if (context.container.isBound(token)) {
+        context.container.unbind(token);
+      }
     }
-    // Remove only this provider's targeted initial state entries.
     if (this.seeds) {
       core.unapplySeeds(context.container, this.seeds);
     }
+    this.boundContext = null;
   };
-  return ServicesProviderController;
+  return InjectablesProviderController;
 }();
 
-function useContainerProvision(host, _a) {
-  var container = _a.container;
-  return new ContainerProviderController(host, container);
+/**
+ * Decorator that binds a set of injectables to the nearest IoC container for the host element's lifetime.
+ *
+ * Entries are bound when the host connects and unbound when it disconnects.
+ * The decorated accessor or property holds the resulting {@link InjectablesProviderController} instance.
+ *
+ * @group provision
+ *
+ * @param options - provisioning options
+ * @returns injectables provider decorator instance
+ *
+ * @example
+ * ```typescript
+ * class MyComponent extends LitElement {
+ *   @injectablesProvide({ entries: [AuthService, UserService], activate: [AuthService] })
+ *   public services!: InjectablesProviderController<MyComponent>;
+ * }
+ * ```
+ */
+function injectablesProvide(options) {
+  return function (protoOrTarget, nameOrContext) {
+    if (typeof nameOrContext === "object") {
+      // Standard decorators:
+      nameOrContext.addInitializer(function () {
+        protoOrTarget.set.call(this, new InjectablesProviderController(this, options));
+      });
+    } else {
+      var controller_1;
+      protoOrTarget.constructor.addInitializer(function (element) {
+        controller_1 = new InjectablesProviderController(element, options);
+      });
+      return {
+        get: function () {
+          return controller_1;
+        },
+        set: function () {},
+        configurable: true,
+        enumerable: true
+      };
+    }
+  };
+}
+
+/**
+ * Binds a set of injectables to the nearest IoC container for the host element's lifetime.
+ *
+ * Entries are bound when the host connects and unbound when it disconnects.
+ *
+ * @group provision
+ *
+ * @param host - the host element
+ * @param options - provisioning options
+ * @param options.entries - list of service entries to bind to the container
+ * @param options.into - target IoC context; if omitted, uses the nearest provider context
+ * @param options.activate - list of service identifiers to activate immediately after binding
+ * @param options.seeds - seed data applied before binding
+ * @returns the controller instance
+ *
+ * @example
+ * ```typescript
+ * class MyComponent extends LitElement {
+ *   private services = useInjectablesProvider(this, {
+ *     entries: [AuthService, UserService],
+ *     activate: [AuthService],
+ *   });
+ * }
+ * ```
+ */
+function useInjectablesProvider(host, options) {
+  return new InjectablesProviderController(host, options);
+}
+
+/**
+ * Hook (controller) to provide an IoC container to the host element and its children.
+ *
+ * @group provision
+ *
+ * @param host - the host element
+ * @param options - provisioning options
+ * @param options.container - optional existing container to use
+ * @param options.seed - optional seed data to apply to the container
+ * @returns ioc provision controller instance
+ *
+ * @example
+ * ```typescript
+ * class MyRootElement extends LitElement {
+ *   private ioc = useIocProvision(this, { seed: { initialData: '...' } });
+ * }
+ * ```
+ */
+function useIocProvision(host, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return new IocProviderController(host, options);
 }
 
 exports.ContainerContext = ContainerContext;
-exports.ContainerProviderController = ContainerProviderController;
-exports.ServicesProviderController = ServicesProviderController;
+exports.InjectablesProviderController = InjectablesProviderController;
+exports.IocProviderController = IocProviderController;
+exports.OnCommandController = OnCommandController;
+exports.OnEventController = OnEventController;
+exports.OnQueryController = OnQueryController;
+exports.injectablesProvide = injectablesProvide;
 exports.injection = injection;
-exports.useContainerProvision = useContainerProvision;
+exports.iocProvide = iocProvide;
+exports.onCommand = onCommand;
+exports.onEvent = onEvent;
+exports.onQuery = onQuery;
+exports.useInjectablesProvider = useInjectablesProvider;
 exports.useInjection = useInjection;
+exports.useIocProvision = useIocProvision;
+exports.useOnCommand = useOnCommand;
+exports.useOnEvents = useOnEvents;
+exports.useOnQuery = useOnQuery;
 //# sourceMappingURL=index.js.map