@wirestate/lit 0.7.0-experimental.2 → 0.7.0-experimental.3

package/cjs/development/index.js

@@ -2,20 +2,19 @@
 
 var context = require('@lit/context');
 var core = require('@wirestate/core');
-var tslib = require('tslib');
 
 /**
  * Unique symbol used as a key for the IoC context.
  *
  * @group Context
  */
-var CONTAINER_KEY = Symbol("ContainerContext");
+const CONTAINER_KEY = Symbol("ContainerContext");
 /**
  * Lit context object for providing and consuming the container.
  *
  * @group Context
  */
-var ContainerContext = context.createContext(CONTAINER_KEY);
+const ContainerContext = context.createContext(CONTAINER_KEY);
 
 /**
  * Decorator to inject a service from the IoC container into a Lit element property.
@@ -50,30 +49,31 @@ var ContainerContext = context.createContext(CONTAINER_KEY);
  * ```
  */
 function injection(optionsOrInjectionId) {
-  var options = typeof optionsOrInjectionId === "object" && optionsOrInjectionId !== null && "injectionId" in optionsOrInjectionId ? optionsOrInjectionId : {
+  const options = typeof optionsOrInjectionId === "object" && optionsOrInjectionId !== null && "injectionId" in optionsOrInjectionId ? optionsOrInjectionId : {
     injectionId: optionsOrInjectionId
   };
-  return function (protoOrTarget, nameOrContext) {
-    var injectionId = options.injectionId,
-      once = options.once;
+  return (protoOrTarget, nameOrContext) => {
+    const {
+      injectionId,
+      once
+    } = options;
     // Standard decorators branch.
     if (typeof nameOrContext === "object") {
       nameOrContext.addInitializer(function () {
-        var _this = this;
         new context.ContextConsumer(this, {
           context: ContainerContext,
-          callback: function (container) {
-            protoOrTarget.set.call(_this, container.get(injectionId));
+          callback: container => {
+            protoOrTarget.set.call(this, container.get(injectionId));
           },
           subscribe: !once
         });
       });
     } else {
       // Experimental decorators branch.
-      protoOrTarget.constructor.addInitializer(function (element) {
+      protoOrTarget.constructor.addInitializer(element => {
         new context.ContextConsumer(element, {
           context: ContainerContext,
-          callback: function (container) {
+          callback: container => {
             element[nameOrContext] = container.get(injectionId);
           },
           subscribe: !once
@@ -106,12 +106,12 @@ function injection(optionsOrInjectionId) {
  * ```
  */
 function useContainer(host) {
-  var current = {
+  const current = {
     value: null
   };
   new context.ContextConsumer(host, {
     context: ContainerContext,
-    callback: function (container) {
+    callback: container => {
       current.value = container;
     }
   });
@@ -150,20 +150,22 @@ function useContainer(host) {
  * ```
  */
 function useInjection(host, optionsOrInjectionId) {
-  var options = typeof optionsOrInjectionId === "object" && optionsOrInjectionId !== null && "injectionId" in optionsOrInjectionId ? optionsOrInjectionId : {
+  const options = typeof optionsOrInjectionId === "object" && optionsOrInjectionId !== null && "injectionId" in optionsOrInjectionId ? optionsOrInjectionId : {
     injectionId: optionsOrInjectionId
   };
-  var once = options.once,
-    injectionId = options.injectionId,
-    value = options.value;
-  var current = {
+  const {
+    once,
+    injectionId,
+    value
+  } = options;
+  const current = {
     value: value,
-    injectionId: injectionId
+    injectionId
   };
   new context.ContextConsumer(host, {
     context: ContainerContext,
     subscribe: !once,
-    callback: function (container) {
+    callback: container => {
       current.value = container.get(injectionId);
     }
   });
@@ -194,14 +196,14 @@ function useInjection(host, optionsOrInjectionId) {
  * ```
  */
 function useScope(host) {
-  var current = {
+  const current = {
     value: undefined,
     injectionId: core.WireScope
   };
   new context.ContextConsumer(host, {
     context: ContainerContext,
     subscribe: true,
-    callback: function (container) {
+    callback: container => {
       current.value = container.get(core.WireScope);
     }
   });
@@ -217,49 +219,46 @@ function useScope(host) {
  *
  * @group Commands
  */
-var OnCommandController = /** @class */function () {
+class OnCommandController {
+  bus = null;
+  unregister = null;
   /**
    * @param host - The host element.
    * @param type - Unique identifier of the command to handle.
    * @param handler - The command handler function.
    */
-  function OnCommandController(host, type, handler) {
-    var _this = this;
-    this.bus = null;
-    this.unregister = null;
+  constructor(host, type, handler) {
     host.addController(this);
     this.type = type;
     this.handler = handler;
     new context.ContextConsumer(host, {
       context: ContainerContext,
       subscribe: true,
-      callback: function (container) {
-        _this.bus = container.get(core.CommandBus);
+      callback: container => {
+        this.bus = container.get(core.CommandBus);
         if (host.isConnected) {
-          _this.reregister();
+          this.reregister();
         }
       }
     });
   }
-  OnCommandController.prototype.hostConnected = function () {
+  hostConnected() {
     this.reregister();
-  };
-  OnCommandController.prototype.hostDisconnected = function () {
+  }
+  hostDisconnected() {
     this.cleanup();
-  };
-  OnCommandController.prototype.reregister = function () {
+  }
+  reregister() {
     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);
+  }
+  cleanup() {
+    this.unregister?.();
     this.unregister = null;
-  };
-  return OnCommandController;
-}();
+  }
+}
 
 /**
  * Decorator for Lit element methods that handle a specific command.
@@ -283,21 +282,16 @@ var OnCommandController = /** @class */function () {
  * ```
  */
 function onCommand(type) {
-  return function (protoOrTarget, nameOrContext) {
+  return (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);
-        });
+        new OnCommandController(this, type, data => this[nameOrContext.name](data));
       });
     } else {
       // Experimental legacy decorators:
-      protoOrTarget.constructor.addInitializer(function (element) {
-        new OnCommandController(element, type, function (data) {
-          return element[nameOrContext](data);
-        });
+      protoOrTarget.constructor.addInitializer(element => {
+        new OnCommandController(element, type, data => element[nameOrContext](data));
       });
     }
   };
@@ -324,9 +318,10 @@ function onCommand(type) {
  * }
  * ```
  */
-function useOnCommand(host, _a) {
-  var type = _a.type,
-    handler = _a.handler;
+function useOnCommand(host, {
+  type,
+  handler
+}) {
   return new OnCommandController(host, type, handler);
 }
 
@@ -339,58 +334,54 @@ function useOnCommand(host, _a) {
  *
  * @group Events
  */
-var OnEventController = /** @class */function () {
+class OnEventController {
+  bus = null;
+  unsubscriber = null;
   /**
    * @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;
+  constructor(host, types, handler) {
     host.addController(this);
     this.types = types;
     this.handler = handler;
     new context.ContextConsumer(host, {
       context: ContainerContext,
       subscribe: true,
-      callback: function (container) {
-        _this.bus = container.get(core.EventBus);
+      callback: container => {
+        this.bus = container.get(core.EventBus);
         if (host.isConnected) {
-          _this.resubscribe();
+          this.resubscribe();
         }
       }
     });
   }
-  OnEventController.prototype.hostConnected = function () {
+  hostConnected() {
     this.resubscribe();
-  };
-  OnEventController.prototype.hostDisconnected = function () {
+  }
+  hostDisconnected() {
     this.cleanup();
-  };
-  OnEventController.prototype.resubscribe = function () {
-    var _this = this;
+  }
+  resubscribe() {
     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);
+        this.unsubscriber = this.bus.subscribe(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);
+  }
+  cleanup() {
+    this.unsubscriber?.();
     this.unsubscriber = null;
-  };
-  return OnEventController;
-}();
+  }
+}
 
 /**
  * Decorator for Lit element methods that handle events from the event bus.
@@ -434,22 +425,17 @@ var OnEventController = /** @class */function () {
  * ```
  */
 function onEvent(types) {
-  var normalized = types === undefined ? null : Array.isArray(types) ? tslib.__spreadArray([], types, true) : [types];
-  return function (protoOrTarget, nameOrContext) {
+  const normalized = types === undefined ? null : Array.isArray(types) ? [...types] : [types];
+  return (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);
-        });
+        new OnEventController(this, normalized, event => this[nameOrContext.name](event));
       });
     } else {
       // Experimental legacy decorators:
-      protoOrTarget.constructor.addInitializer(function (element) {
-        new OnEventController(element, normalized, function (event) {
-          return element[nameOrContext](event);
-        });
+      protoOrTarget.constructor.addInitializer(element => {
+        new OnEventController(element, normalized, event => element[nameOrContext](event));
       });
     }
   };
@@ -485,10 +471,11 @@ function onEvent(types) {
  * }
  * ```
  */
-function useOnEvents(host, _a) {
-  var types = _a.types,
-    handler = _a.handler;
-  var normalized = types ? Array.isArray(types) ? tslib.__spreadArray([], types, true) : [types] : null;
+function useOnEvents(host, {
+  types,
+  handler
+}) {
+  const normalized = types ? Array.isArray(types) ? [...types] : [types] : null;
   return new OnEventController(host, normalized, handler);
 }
 
@@ -501,49 +488,46 @@ function useOnEvents(host, _a) {
  *
  * @group Queries
  */
-var OnQueryController = /** @class */function () {
+class OnQueryController {
+  bus = null;
+  unregister = null;
   /**
    * @param host - The host element.
    * @param type - Unique identifier of the query to handle.
    * @param handler - The query handler function.
    */
-  function OnQueryController(host, type, handler) {
-    var _this = this;
-    this.bus = null;
-    this.unregister = null;
+  constructor(host, type, handler) {
     host.addController(this);
     this.type = type;
     this.handler = handler;
     new context.ContextConsumer(host, {
       context: ContainerContext,
       subscribe: true,
-      callback: function (container) {
-        _this.bus = container.get(core.QueryBus);
+      callback: container => {
+        this.bus = container.get(core.QueryBus);
         if (host.isConnected) {
-          _this.reregister();
+          this.reregister();
         }
       }
     });
   }
-  OnQueryController.prototype.hostConnected = function () {
+  hostConnected() {
     this.reregister();
-  };
-  OnQueryController.prototype.hostDisconnected = function () {
+  }
+  hostDisconnected() {
     this.cleanup();
-  };
-  OnQueryController.prototype.reregister = function () {
+  }
+  reregister() {
     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);
+  }
+  cleanup() {
+    this.unregister?.();
     this.unregister = null;
-  };
-  return OnQueryController;
-}();
+  }
+}
 
 /**
  * Decorator for Lit element methods that handle a specific query.
@@ -567,21 +551,16 @@ var OnQueryController = /** @class */function () {
  * ```
  */
 function onQuery(type) {
-  return function (protoOrTarget, nameOrContext) {
+  return (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);
-        });
+        new OnQueryController(this, type, data => this[nameOrContext.name](data));
       });
     } else {
       // Experimental legacy decorators:
-      protoOrTarget.constructor.addInitializer(function (element) {
-        new OnQueryController(element, type, function (data) {
-          return element[nameOrContext](data);
-        });
+      protoOrTarget.constructor.addInitializer(element => {
+        new OnQueryController(element, type, data => element[nameOrContext](data));
       });
     }
   };
@@ -608,13 +587,14 @@ function onQuery(type) {
  * }
  * ```
  */
-function useOnQuery(host, _a) {
-  var type = _a.type,
-    handler = _a.handler;
+function useOnQuery(host, {
+  type,
+  handler
+}) {
   return new OnQueryController(host, type, handler);
 }
 
-var ERROR_CODE_INVALID_ARGUMENTS = 2051;
+const ERROR_CODE_INVALID_ARGUMENTS = 2051;
 
 /**
  * Provider that exposes an IoC container context to the host element and its children.
@@ -631,56 +611,51 @@ var ERROR_CODE_INVALID_ARGUMENTS = 2051;
  *
  * @group Provision
  */
-var ContainerProvider = /** @class */function (_super) {
-  tslib.__extends(ContainerProvider, _super);
+class ContainerProvider extends context.ContextProvider {
+  destroyed = false;
   /**
    * @param host - The host element.
    * @param options - Provisioning options.
    * @param options.container - External container instance to provide.
    * @param options.options - Managed container creation options.
    */
-  function ContainerProvider(host, options) {
-    var _this = this;
+  constructor(host, options) {
     if (!options.container && !options.options) {
       throw new core.WirestateError(ERROR_CODE_INVALID_ARGUMENTS, "ContainerProvider requires a valid container instance or creation options.");
     } else if (options.container && options.options) {
       throw new core.WirestateError(ERROR_CODE_INVALID_ARGUMENTS, "ContainerProvider requires only container or valid options object to be provided.");
     }
-    _this = _super.call(this, host, {
+    super(host, {
       context: ContainerContext,
-      initialValue: options.container ? options.container : core.createContainer(tslib.__assign(tslib.__assign({}, options.options), {
+      initialValue: options.container ? options.container : core.createContainer({
+        ...options.options,
         activate: []
-      }))
-    }) || this;
-    _this.destroyed = false;
-    _this.options = options.options;
-    return _this;
+      })
+    });
+    this.options = options.options;
   }
-  ContainerProvider.prototype.hostConnected = function () {
-    var _a;
+  hostConnected() {
     if (this.options) {
       if (this.destroyed) {
         this.value = core.createContainer(this.options);
         this.destroyed = false;
       } else {
-        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.activate) {
-          for (var _i = 0, _b = this.options.activate; _i < _b.length; _i++) {
-            var entry = _b[_i];
+        if (this.options?.activate) {
+          for (const entry of this.options.activate) {
             this.value.get(entry);
           }
         }
       }
     }
-    _super.prototype.hostConnected.call(this);
-  };
-  ContainerProvider.prototype.hostDisconnected = function () {
+    super.hostConnected();
+  }
+  hostDisconnected() {
     if (this.options) {
       this.value.unbindAll();
       this.destroyed = true;
     }
-  };
-  return ContainerProvider;
-}(context.ContextProvider);
+  }
+}
 
 /**
  * Provider that exposes a managed child container for the host element's lifetime.
@@ -706,67 +681,65 @@ var ContainerProvider = /** @class */function (_super) {
  * }
  * ```
  */
-var SubContainerProvider = /** @class */function (_super) {
-  tslib.__extends(SubContainerProvider, _super);
+class SubContainerProvider extends context.ContextProvider {
+  parent = null;
+  destroyed = true;
   /**
    * @param host - The host element.
    * @param options - Provisioning options, including child entries, eager activations, and seeds.
    */
-  function SubContainerProvider(host, options) {
-    var _this = _super.call(this, host, {
+  constructor(host, options) {
+    super(host, {
       context: ContainerContext
-    }) || this;
-    _this.parent = null;
-    _this.destroyed = true;
-    _this.options = options.options;
-    _this.consumer = new context.ContextConsumer(host, {
+    });
+    this.options = options.options;
+    this.consumer = new context.ContextConsumer(host, {
       context: ContainerContext,
       subscribe: true,
-      callback: function (context) {
-        var previousParent = _this.parent;
-        _this.parent = context;
+      callback: context => {
+        const previousParent = this.parent;
+        this.parent = context;
         if (host.isConnected) {
-          if (_this.destroyed || !_this.value || previousParent !== context) {
-            _this.destroyContainer();
-            _this.createContainer();
+          if (this.destroyed || !this.value || previousParent !== context) {
+            this.destroyContainer();
+            this.createContainer();
           }
         }
       }
     });
-    return _this;
   }
-  SubContainerProvider.prototype.hostConnected = function () {
+  hostConnected() {
     if (this.parent && (this.destroyed || !this.value)) {
       this.destroyContainer();
       this.createContainer();
     }
-    _super.prototype.hostConnected.call(this);
-  };
-  SubContainerProvider.prototype.hostDisconnected = function () {
+    super.hostConnected();
+  }
+  hostDisconnected() {
     this.destroyContainer();
-  };
+  }
   /**
    * Replaces the currently provided child container with a new one derived
    * from the latest parent context.
    */
-  SubContainerProvider.prototype.createContainer = function () {
-    var container = core.createContainer(tslib.__assign(tslib.__assign({}, this.options), {
+  createContainer() {
+    const container = core.createContainer({
+      ...this.options,
       parent: this.parent
-    }));
+    });
     this.destroyed = false;
     this.value = container;
-  };
+  }
   /**
    * Destroys the currently provided child container.
    */
-  SubContainerProvider.prototype.destroyContainer = function () {
+  destroyContainer() {
     if (this.value && !this.destroyed) {
       this.value.unbindAll();
       this.destroyed = true;
     }
-  };
-  return SubContainerProvider;
-}(context.ContextProvider);
+  }
+}
 
 /**
  * Decorator that provides an IoC container to child components.
@@ -809,22 +782,22 @@ var SubContainerProvider = /** @class */function (_super) {
  * ```
  */
 function containerProvide(options) {
-  return function (protoOrTarget, nameOrContext) {
+  return (protoOrTarget, nameOrContext) => {
     if (typeof nameOrContext === "object") {
       // Standard decorators:
       nameOrContext.addInitializer(function () {
         protoOrTarget.set.call(this, new ContainerProvider(this, options));
       });
     } else {
-      var controller_1;
-      protoOrTarget.constructor.addInitializer(function (element) {
-        controller_1 = new ContainerProvider(element, options);
+      let controller;
+      protoOrTarget.constructor.addInitializer(element => {
+        controller = new ContainerProvider(element, options);
       });
       return {
-        get: function () {
-          return controller_1;
+        get() {
+          return controller;
         },
-        set: function () {},
+        set() {},
         configurable: true,
         enumerable: true
       };
@@ -861,22 +834,22 @@ function containerProvide(options) {
  * ```
  */
 function subContainerProvide(options) {
-  return function (protoOrTarget, nameOrContext) {
+  return (protoOrTarget, nameOrContext) => {
     if (typeof nameOrContext === "object") {
       // Standard decorators:
       nameOrContext.addInitializer(function () {
         protoOrTarget.set.call(this, new SubContainerProvider(this, options));
       });
     } else {
-      var provider_1;
-      protoOrTarget.constructor.addInitializer(function (element) {
-        provider_1 = new SubContainerProvider(element, options);
+      let provider;
+      protoOrTarget.constructor.addInitializer(element => {
+        provider = new SubContainerProvider(element, options);
       });
       return {
-        get: function () {
-          return provider_1;
+        get() {
+          return provider;
         },
-        set: function () {},
+        set() {},
         configurable: true,
         enumerable: true
       };