@lushly-dev/fast-element 3.0.1-preview.1 → 3.0.1-preview.2

package/dist/di/di.api.json

@@ -1,7 +1,7 @@
 {
   "metadata": {
     "toolPackage": "@microsoft/api-extractor",
-    "toolVersion": "7.58.1",
+    "toolVersion": "7.60.1",
     "schemaVersion": 1011,
     "oldestForwardsCompatibleVersion": 1001,
     "tsdocConfig": {
@@ -191,7 +191,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!all:function(1)",
-          "docComment": "/**\n * A decorator and DI resolver that will resolve an array of all dependencies registered with the specified key.\n *\n * @param key - The key to resolve all dependencies for.\n *\n * @param searchAncestors - [optional] Indicates whether to search ancestor containers.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A decorator and DI resolver that will resolve an array of all dependencies\n * registered with the specified key.\n *\n * @param key - The key to resolve all dependencies for.\n *\n * @param searchAncestors - [optional] Indicates whether to search ancestor containers.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -480,7 +480,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!Container#getResolver:member(1)",
-              "docComment": "/**\n * Gets a resolver for the specified key.\n *\n * @param key - The key to get the resolver for.\n *\n * @param autoRegister - Indicates whether or not to try to auto-register a dependency for the key if one is not explicitly registered.\n */\n",
+              "docComment": "/**\n * Gets a resolver for the specified key.\n *\n * @param key - The key to get the resolver for.\n *\n * @param autoRegister - Indicates whether or not to try to auto-register a dependency for\n * the key if one is not explicitly registered.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1005,7 +1005,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@lushly-dev/fast-element!ContainerConfiguration#asyncRegistrationLocator:member",
-              "docComment": "/**\n * When an asynchronous get request is made to the container, if no resolver is found for the key, this function is called to provide a registration.\n */\n",
+              "docComment": "/**\n * When an asynchronous get request is made to the container, if no\n * resolver is found for the key, this function is called to provide\n * a registration.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1125,7 +1125,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@lushly-dev/fast-element!ContainerConfiguration#responsibleForOwnerRequests:member",
-              "docComment": "/**\n * Indicates whether this container should resolve dependencies that are directly made by its owner. The default is \"false\" which results in the parent container being used.\n */\n",
+              "docComment": "/**\n * Indicates whether this container should resolve dependencies that are directly made\n * by its owner. The default is \"false\" which results in the parent container being used.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1614,7 +1614,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!DOMContainer#handleContextRequests:member(1)",
-              "docComment": "/**\n * Instructs this particular Container to handle W3C Community Context requests that propagate to its associated DOM node.\n *\n * @param enable - true to enable context requests handling; false otherwise.\n *\n * @beta\n */\n",
+              "docComment": "/**\n * Instructs this particular Container to handle W3C Community Context requests\n * that propagate to its associated DOM node.\n *\n * @param enable - true to enable context requests handling; false otherwise.\n *\n * @beta\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1821,7 +1821,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!Factory#constructAsync:member(1)",
-              "docComment": "/**\n * Constructs an instance of the factory's object, allowing for async resolution of dependencies.\n *\n * @param container - The container the object is being constructor for.\n *\n * @param dynamicDependencies - Dynamic dependencies supplied to the constructor.\n */\n",
+              "docComment": "/**\n * Constructs an instance of the factory's object, allowing for\n * async resolution of dependencies.\n *\n * @param container - The container the object is being constructor for.\n *\n * @param dynamicDependencies - Dynamic dependencies supplied to the constructor.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1902,7 +1902,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!Factory#registerTransformer:member(1)",
-              "docComment": "/**\n * Registers a transformer function to alter the object after instantiation but before returning the final constructed instance.\n *\n * @param transformer - The transformer function.\n */\n",
+              "docComment": "/**\n * Registers a transformer function to alter the object after instantiation but before\n * returning the final constructed instance.\n *\n * @param transformer - The transformer function.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -2065,7 +2065,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!inject:function(1)",
-          "docComment": "/**\n * A decorator that specifies what to inject into its target.\n *\n * @remarks\n *\n * The decorator can be used to decorate a class, listing all of the classes dependencies. Or it can be used to decorate a constructor paramter, indicating what to inject for that parameter. Or it can be used for a web component property, indicating what that property should resolve to.\n *\n * @param dependencies - The dependencies to inject.\n *\n * @returns The decorator to be applied to the target class.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A decorator that specifies what to inject into its target.\n *\n * @remarks\n *\n * The decorator can be used to decorate a class, listing all of the classes dependencies.\n * Or it can be used to decorate a constructor paramter, indicating what to inject for that\n * parameter.\n * Or it can be used for a web component property, indicating what that property should resolve to.\n *\n * @param dependencies - The dependencies to inject.\n *\n * @returns The decorator to be applied to the target class.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2120,7 +2120,7 @@
         {
           "kind": "TypeAlias",
           "canonicalReference": "@lushly-dev/fast-element!Injectable:type",
-          "docComment": "/**\n * A class that declares constructor injected dependencies through a static \"inject\" field array of keys.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A class that declares constructor injected dependencies through\n * a static \"inject\" field array of keys.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2223,7 +2223,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@lushly-dev/fast-element!InterfaceConfiguration#respectConnection:member",
-              "docComment": "/**\n * When true, the dependency will be re-resolved when FASTElement connection changes. If the resolved value changes due to connection change, an observable notification will be emitted for the property, with the previous and next values provided to any subscriber.\n */\n",
+              "docComment": "/**\n * When true, the dependency will be re-resolved when FASTElement connection changes.\n * If the resolved value changes due to connection change, an observable notification\n * will be emitted for the property, with the previous and next values provided to any subscriber.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -2307,7 +2307,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!lazy:function(1)",
-          "docComment": "/**\n * A decorator that lazily injects a dependency depending on whether the `Key` is present at the time of function call.\n *\n * @param key - The key to lazily resolve. see {@link DI.createContext} on interactions with interfaces\n *\n * @example\n *\n * You need to make your argument a function that returns the type, for example\n * ```ts\n * class Foo {\n *   constructor( @lazy('random') public random: () => number )\n * }\n * const foo = container.get(Foo); // instanceof Foo\n * foo.random(); // throws\n * ```\n *\n * would throw an exception because you haven't registered `'random'` before calling the method.\n *\n * @example\n *\n * This, would give you a new 'Math.random()' number each time.\n * ```ts\n * class Foo {\n *   constructor( @lazy('random') public random: () => random )\n * }\n * container.register(Registration.callback('random', Math.random ));\n * container.get(Foo).random(); // some random number\n * container.get(Foo).random(); // another random number\n * ```\n *\n * `@lazy` does not manage the lifecycle of the underlying key. If you want a singleton, you have to register as a `singleton`, `transient` would also behave as you would expect, providing you a new instance each time.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A decorator that lazily injects a dependency depending on whether the `Key` is present at the time of function call.\n *\n * @param key - The key to lazily resolve.\n * see {@link DI.createContext} on interactions with interfaces\n *\n * @example\n *\n * You need to make your argument a function that returns the type, for example\n * ```ts\n * class Foo {\n *   constructor( @lazy('random') public random: () => number )\n * }\n * const foo = container.get(Foo); // instanceof Foo\n * foo.random(); // throws\n * ```\n *\n * would throw an exception because you haven't registered `'random'` before calling the method.\n *\n * @example\n *\n * This, would give you a new 'Math.random()' number each time.\n * ```ts\n * class Foo {\n *   constructor( @lazy('random') public random: () => random )\n * }\n * container.register(Registration.callback('random', Math.random ));\n * container.get(Foo).random(); // some random number\n * container.get(Foo).random(); // another random number\n * ```\n *\n * `@lazy` does not manage the lifecycle of the underlying key. If you want a singleton, you have to register as a\n * `singleton`, `transient` would also behave as you would expect, providing you a new instance each time.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2348,7 +2348,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!newInstanceForScope:function(1)",
-          "docComment": "/**\n * A decorator that indicates that a new instance should be injected scoped to the container that requested the instance.\n *\n * @remarks\n *\n * This creates a resolver with an instance strategy pointing to the new instance, effectively making this a singleton, scoped to the container or DOM's subtree.\n *\n * @param key - The dependency key for the new instance.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A decorator that indicates that a new instance should be injected scoped to the\n * container that requested the instance.\n *\n * @remarks\n *\n * This creates a resolver with an instance strategy pointing to the new instance, effectively\n * making this a singleton, scoped to the container or DOM's subtree.\n *\n * @param key - The dependency key for the new instance.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2430,7 +2430,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!optional:function(1)",
-          "docComment": "/**\n * A decorator that allows you to optionally inject a dependency depending on whether the [[`Key`]] is present, for example:\n *\n * @param key - The key to optionally resolve. see {@link DI.createContext} on interactions with interfaces\n *\n * @example\n * ```ts\n * class Foo {\n *   constructor( @inject('mystring') public str: string = 'somestring' )\n * }\n * container.get(Foo); // throws\n * ```\n *\n * would fail\n *\n * @example\n * ```ts\n * class Foo {\n *   constructor( @optional('mystring') public str: string = 'somestring' )\n * }\n * container.get(Foo).str // somestring\n * ```\n *\n * if you use it without a default it will inject `undefined`, so remember to mark your input type as possibly `undefined`!\n *\n * @public\n */\n",
+          "docComment": "/**\n * A decorator that allows you to optionally inject a dependency depending on whether the [[`Key`]] is present, for example:\n *\n * @param key - The key to optionally resolve.\n * see {@link DI.createContext} on interactions with interfaces\n *\n * @example\n * ```ts\n * class Foo {\n *   constructor( @inject('mystring') public str: string = 'somestring' )\n * }\n * container.get(Foo); // throws\n * ```\n *\n * would fail\n *\n * @example\n * ```ts\n * class Foo {\n *   constructor( @optional('mystring') public str: string = 'somestring' )\n * }\n * container.get(Foo).str // somestring\n * ```\n *\n * if you use it without a default it will inject `undefined`, so remember to mark your input type as\n * possibly `undefined`!\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2581,7 +2581,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@lushly-dev/fast-element!Registration:interface",
-          "docComment": "/**\n * Implemented by objects that wish to register dependencies in the container by creating resolvers.\n *\n * @public\n */\n",
+          "docComment": "/**\n * Implemented by objects that wish to register dependencies in the container\n * by creating resolvers.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2671,7 +2671,7 @@
         {
           "kind": "Variable",
           "canonicalReference": "@lushly-dev/fast-element!Registration:var",
-          "docComment": "/**\n * You can use the resulting Registration of any of the factory methods to register with the container.\n *\n * @example\n * ```\n * class Foo {}\n * const container = DI.createContainer();\n * container.register(Registration.instance(Foo, new Foo()));\n * container.get(Foo);\n * ```\n *\n * @public\n */\n",
+          "docComment": "/**\n * You can use the resulting Registration of any of the factory methods\n * to register with the container.\n *\n * @example\n * ```\n * class Foo {}\n * const container = DI.createContainer();\n * container.register(Registration.instance(Foo, new Foo()));\n * container.get(Foo);\n * ```\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -2903,7 +2903,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!Registry#register:member(1)",
-              "docComment": "/**\n * Registers dependencies in the specified container.\n *\n * @remarks\n *\n * If this registry doubles as a Registration, it should return a Resolver for the registered dependency.\n *\n * @param container - The container to register dependencies in.\n *\n * @param params - Parameters that affect the registration process.\n */\n",
+              "docComment": "/**\n * Registers dependencies in the specified container.\n *\n * @remarks\n *\n * If this registry doubles as a Registration, it should return a Resolver\n * for the registered dependency.\n *\n * @param container - The container to register dependencies in.\n *\n * @param params - Parameters that affect the registration process.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -2973,7 +2973,7 @@
         {
           "kind": "TypeAlias",
           "canonicalReference": "@lushly-dev/fast-element!ResolveCallback:type",
-          "docComment": "/**\n * Represents a custom callback for resolving a request from the container. The handler is the container that is invoking the callback. The requestor is the original container that made the request. The handler and the requestor may not be the same if the request has bubbled up to a parent container in the DI hierarchy. The resolver is the instance of the resolver that stores the callback. This is provided in case the callback needs a place or key against which to store state across resolutions.\n *\n * @public\n */\n",
+          "docComment": "/**\n * Represents a custom callback for resolving a request from the container.\n * The handler is the container that is invoking the callback. The requestor\n * is the original container that made the request. The handler and the requestor\n * may not be the same if the request has bubbled up to a parent container in the DI hierarchy.\n * The resolver is the instance of the resolver that stores the callback. This is provided in case\n * the callback needs a place or key against which to store state across resolutions.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3140,7 +3140,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@lushly-dev/fast-element!Resolver:interface",
-          "docComment": "/**\n * Internally, the DI system maps \"keys\" to \"resolvers\". A resolver controls how a dependency is resolved. Resolvers for transient, singleton, etc. are provided out of the box, but you can also implement Resolver yourself and supply custom logic for resolution.\n *\n * @public\n */\n",
+          "docComment": "/**\n * Internally, the DI system maps \"keys\" to \"resolvers\". A resolver controls\n * how a dependency is resolved. Resolvers for transient, singleton, etc. are\n * provided out of the box, but you can also implement Resolver yourself and supply\n * custom logic for resolution.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3205,7 +3205,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@lushly-dev/fast-element!ResolverBuilder:class",
-          "docComment": "/**\n * A utility class used that constructs and registers resolvers for a dependency injection container. Supports a standard set of object lifetimes.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A utility class used that constructs and registers resolvers for a dependency\n * injection container. Supports a standard set of object lifetimes.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3338,7 +3338,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@lushly-dev/fast-element!ResolverBuilder#cachedCallback:member(1)",
-              "docComment": "/**\n * Creates a resolver that invokes a callback function the first time that a dependency resolution is requested. The returned value is then cached and provided for all subsequent requests.\n *\n * @param value - The callback to call during the first resolution.\n *\n * @returns The resolver.\n */\n",
+              "docComment": "/**\n * Creates a resolver that invokes a callback function the first time that a dependency\n * resolution is requested. The returned value is then cached and provided for all\n * subsequent requests.\n *\n * @param value - The callback to call during the first resolution.\n *\n * @returns The resolver.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -3396,7 +3396,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@lushly-dev/fast-element!ResolverBuilder#callback:member(1)",
-              "docComment": "/**\n * Creates a resolver that invokes a callback function for every dependency resolution request, allowing custom logic to return the dependency.\n *\n * @param value - The callback to call during resolution.\n *\n * @returns The resolver.\n */\n",
+              "docComment": "/**\n * Creates a resolver that invokes a callback function for every dependency resolution\n * request, allowing custom logic to return the dependency.\n *\n * @param value - The callback to call during resolution.\n *\n * @returns The resolver.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -4137,7 +4137,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!ServiceLocator#getAsync:member(1)",
-              "docComment": "/**\n * Gets a dependency by key, allowing for asynchronously resolved dependencies.\n *\n * @param key - The key to lookup.\n */\n",
+              "docComment": "/**\n * Gets a dependency by key, allowing for asynchronously\n * resolved dependencies.\n *\n * @param key - The key to lookup.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -4218,7 +4218,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!ServiceLocator#getAsync:member(2)",
-              "docComment": "/**\n * Gets a dependency by key, allowing for asynchronously resolved dependencies.\n *\n * @param key - The key to lookup.\n */\n",
+              "docComment": "/**\n * Gets a dependency by key, allowing for asynchronously\n * resolved dependencies.\n *\n * @param key - The key to lookup.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -4300,7 +4300,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!ServiceLocator#getAsync:member(3)",
-              "docComment": "/**\n * Gets a dependency by key, allowing for asynchronously resolved dependencies.\n *\n * @param key - The key to lookup.\n */\n",
+              "docComment": "/**\n * Gets a dependency by key, allowing for asynchronously\n * resolved dependencies.\n *\n * @param key - The key to lookup.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -4386,7 +4386,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@lushly-dev/fast-element!ServiceLocator#has:member(1)",
-              "docComment": "/**\n * Determines whether the locator has the ability to provide an implementation for the requested key.\n *\n * @param key - The dependency key to lookup.\n *\n * @param searchAncestors - Indicates whether to search the entire hierarchy of service locators.\n */\n",
+              "docComment": "/**\n * Determines whether the locator has the ability to provide an implementation\n * for the requested key.\n *\n * @param key - The dependency key to lookup.\n *\n * @param searchAncestors - Indicates whether to search the entire hierarchy of service locators.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -4514,7 +4514,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!singleton:function(1)",
-          "docComment": "/**\n * Registers the decorated class as a singleton dependency; the class will only be created once. Each consecutive time the dependency is resolved, the same instance will be returned.\n *\n * @example\n * ```ts\n * @singleton()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
+          "docComment": "/**\n * Registers the decorated class as a singleton dependency; the class will only be created once. Each\n * consecutive time the dependency is resolved, the same instance will be returned.\n *\n * @example\n * ```ts\n * @singleton()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4642,7 +4642,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!singleton:function(3)",
-          "docComment": "/**\n * Registers the `target` class as a singleton dependency; the class will only be created once. Each consecutive time the dependency is resolved, the same instance will be returned.\n *\n * @param target - The class / constructor function to register as a singleton.\n *\n * @example\n * ```ts\n * @singleton()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
+          "docComment": "/**\n * Registers the `target` class as a singleton dependency; the class will only be created once. Each\n * consecutive time the dependency is resolved, the same instance will be returned.\n *\n * @param target - The class / constructor function to register as a singleton.\n *\n * @example\n * ```ts\n * @singleton()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4736,7 +4736,7 @@
         {
           "kind": "TypeAlias",
           "canonicalReference": "@lushly-dev/fast-element!Transformer_2:type",
-          "docComment": "/**\n * Transforms an object after it is created but before it is returned to the requestor.\n *\n * @public\n */\n",
+          "docComment": "/**\n * Transforms an object after it is created but before it is returned\n * to the requestor.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4793,7 +4793,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!transient:function(1)",
-          "docComment": "/**\n * Registers the decorated class as a transient dependency; each time the dependency is resolved a new instance will be created.\n *\n * @example\n * ```ts\n * @transient()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
+          "docComment": "/**\n * Registers the decorated class as a transient dependency; each time the dependency is resolved\n * a new instance will be created.\n *\n * @example\n * ```ts\n * @transient()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -4848,7 +4848,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@lushly-dev/fast-element!transient:function(2)",
-          "docComment": "/**\n * Registers the `target` class as a transient dependency; each time the dependency is resolved a new instance will be created.\n *\n * @param target - The class / constructor function to register as transient.\n *\n * @example\n * ```ts\n * @transient()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
+          "docComment": "/**\n * Registers the `target` class as a transient dependency; each time the dependency is resolved\n * a new instance will be created.\n *\n * @param target - The class / constructor function to register as transient.\n *\n * @example\n * ```ts\n * @transient()\n * class Foo { }\n * ```\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",

package/dist/dts/declarative/debug.d.ts

@@ -1,4 +1,4 @@
 export declare const debugMessages: {
-    2000: string;
-    2001: string;
+    [2000]: string;
+    [2001]: string;
 };

package/dist/dts/declarative/utilities.d.ts

@@ -169,6 +169,8 @@ export type ComparisonOperator = (typeof ComparisonOperator)[keyof typeof Compar
  * @public
  */
 export declare const Operator: {
+    readonly AND: "&&";
+    readonly OR: "||";
     readonly ACCESS: "access";
     readonly EQUALS: "==";
     readonly GREATER_THAN: ">";
@@ -177,8 +179,6 @@ export declare const Operator: {
     readonly LESS_THAN_OR_EQUALS: "<=";
     readonly NOT: "!";
     readonly NOT_EQUALS: "!=";
-    readonly AND: "&&";
-    readonly OR: "||";
 };
 /**
  * Declarative expression operator token.

package/dist/dts/hydration/target-builder.d.ts

@@ -15,7 +15,7 @@ export declare class HydrationTargetElementError extends Error {
      * string for structural errors that do not correspond to a single
      * binding factory.
      */
-    readonly expected?: (HydrationMismatchExpectation | string) | undefined;
+    readonly expected?: HydrationMismatchExpectation | string | undefined;
     /**
      * Structured description of the server-rendered DOM that was
      * encountered at the mismatch point.
@@ -45,7 +45,7 @@ export declare class HydrationTargetElementError extends Error {
      * string for structural errors that do not correspond to a single
      * binding factory.
      */
-    expected?: (HydrationMismatchExpectation | string) | undefined, 
+    expected?: HydrationMismatchExpectation | string | undefined, 
     /**
      * Structured description of the server-rendered DOM that was
      * encountered at the mismatch point.

package/dist/dts/templating/hydration-view.d.ts

@@ -92,7 +92,7 @@ export declare class HydrationView<TSource = any, TParent = any> extends Default
     context: ExecutionContext<any>;
     source: TSource | null;
     isBound: boolean;
-    get hydrationStage(): "unhydrated" | "hydrating" | "hydrated";
+    get hydrationStage(): "hydrated" | "hydrating" | "unhydrated";
     get targets(): ViewBehaviorTargets;
     get bindingViewBoundaries(): ViewBehaviorBoundaries;
     readonly sourceLifetime: SourceLifetime;

package/dist/dts/testing/fakes.d.ts

@@ -1,3 +1,4 @@
+import { noop } from "../interfaces.js";
 import { ExecutionContext } from "../observation/observable.js";
 import type { ViewBehavior, ViewBehaviorTargets } from "../templating/html-directive.js";
 export declare const Fake: Readonly<{
@@ -8,7 +9,7 @@ export declare const Fake: Readonly<{
         onUnbind(object: any): void;
         source: TSource;
         targets: ViewBehaviorTargets;
-        toJSON: () => undefined;
+        toJSON: typeof noop;
         bind(source: TSource, context?: ExecutionContext<TParent>): void;
         unbind(): void;
     };

package/dist/dts/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.1"
+      "packageVersion": "7.60.1"
     }
   ]
 }

package/dist/esm/binding/two-way.js

@@ -34,8 +34,7 @@ class TwoWayObserver {
     bind(controller) {
         var _a;
         if (!this.changeEvent) {
-            this.changeEvent =
-                (_a = this.dataBinding.options.changeEvent) !== null && _a !== void 0 ? _a : twoWaySettings.determineChangeEvent(this.directive, this.target);
+            this.changeEvent = (_a = this.dataBinding.options.changeEvent) !== null && _a !== void 0 ? _a : twoWaySettings.determineChangeEvent(this.directive, this.target);
         }
         if (this.isNotBound) {
             this.target.addEventListener(this.changeEvent, this);

package/dist/esm/command/behaviors/undo-behavior.js

@@ -50,7 +50,8 @@ import { CommandRegistry } from "../registry.js";
  * @internal
  */
 function isEditableTarget(event) {
-    var _a, _b;
+    var _a;
+    var _b;
     // composedPath()[0] sees through shadow roots, where event.target is retargeted
     const target = ((_b = (_a = event.composedPath) === null || _a === void 0 ? void 0 : _a.call(event)[0]) !== null && _b !== void 0 ? _b : event.target);
     if (!target || typeof target.tagName !== "string") {

package/dist/esm/command/registry.js

@@ -160,11 +160,12 @@ class CommandRegistryImpl {
      * @public
      */
     unregister(id, expected) {
-        var _a, _b, _c;
+        var _a, _b;
+        var _c;
         if (expected !== void 0 && this.commands.get(id) !== expected) {
             // A stale removal of a shadowed registration.
             const stack = this.shadowed.get(id);
-            const index = (_a = stack === null || stack === void 0 ? void 0 : stack.indexOf(expected)) !== null && _a !== void 0 ? _a : -1;
+            const index = (_c = stack === null || stack === void 0 ? void 0 : stack.indexOf(expected)) !== null && _c !== void 0 ? _c : -1;
             if (stack !== void 0 && index !== -1) {
                 stack.splice(index, 1);
                 if (stack.length === 0)
@@ -172,9 +173,9 @@ class CommandRegistryImpl {
             }
             return;
         }
-        const fallback = expected !== void 0 ? (_b = this.shadowed.get(id)) === null || _b === void 0 ? void 0 : _b.pop() : void 0;
+        const fallback = expected !== void 0 ? (_a = this.shadowed.get(id)) === null || _a === void 0 ? void 0 : _a.pop() : void 0;
         if (fallback !== void 0) {
-            if (((_c = this.shadowed.get(id)) === null || _c === void 0 ? void 0 : _c.length) === 0)
+            if (((_b = this.shadowed.get(id)) === null || _b === void 0 ? void 0 : _b.length) === 0)
                 this.shadowed.delete(id);
             this.commands.set(id, fallback);
             this.notify([id], []);
@@ -249,7 +250,8 @@ class CommandRegistryImpl {
      * @internal
      */
     run(id, args, options) {
-        var _a, _b;
+        var _a;
+        var _b;
         const cmd = this.commands.get(id);
         if (!cmd) {
             return Promise.resolve(failure({
@@ -343,7 +345,8 @@ class CommandRegistryImpl {
             },
         }))
             .then(result => {
-            var _a, _b;
+            var _a;
+            var _b;
             this.emitTelemetry("command.executed", {
                 id,
                 duration: ((_b = (_a = globalThis.performance) === null || _a === void 0 ? void 0 : _a.now()) !== null && _b !== void 0 ? _b : Date.now()) - start,

package/dist/esm/command/validation.js

@@ -412,14 +412,11 @@ export function registerValidationCommands() {
                 // Build plan array with fix suggestions
                 const plan = issues
                     .filter(i => i.fix)
-                    .map((issue, idx) => {
-                    var _a;
-                    return ({
-                        step: idx + 1,
-                        action: issue.fix,
-                        confidence: (_a = issue.fixConfidence) !== null && _a !== void 0 ? _a : 0.8,
-                    });
-                });
+                    .map((issue, idx) => { var _a; return ({
+                    step: idx + 1,
+                    action: issue.fix,
+                    confidence: (_a = issue.fixConfidence) !== null && _a !== void 0 ? _a : 0.8,
+                }); });
                 if (hasErrors) {
                     return failure({
                         code: "LINT_ERRORS",

package/dist/esm/components/element-controller.js

@@ -72,14 +72,16 @@ export class ElementController {
      * The context the expression is evaluated against.
      */
     get context() {
-        var _a, _b;
+        var _a;
+        var _b;
         return (_b = (_a = this.view) === null || _a === void 0 ? void 0 : _a.context) !== null && _b !== void 0 ? _b : ExecutionContext.default;
     }
     /**
      * Indicates whether the controller is bound.
      */
     get isBound() {
-        var _a, _b;
+        var _a;
+        var _b;
         return (_b = (_a = this.view) === null || _a === void 0 ? void 0 : _a.isBound) !== null && _b !== void 0 ? _b : false;
     }
     /**
@@ -105,8 +107,7 @@ export class ElementController {
             }
             else if (definition.template) {
                 // 3. Default to the static definition.
-                this._template =
-                    (_a = definition.template) !== null && _a !== void 0 ? _a : null;
+                this._template = (_a = definition.template) !== null && _a !== void 0 ? _a : null;
             }
         }
         return this._template;

package/dist/esm/components/hydration-tracker.js

@@ -53,7 +53,8 @@ export class HydrationTracker {
      * Registers an element as pending hydration.
      */
     add(element) {
-        var _a, _b;
+        var _a;
+        var _b;
         this.completed = false;
         if (!this.started) {
             this.started = true;

package/dist/esm/declarative/attribute-map.js

@@ -65,7 +65,8 @@ export class AttributeMap {
         this.config = config;
     }
     defineProperties() {
-        var _a, _b;
+        var _a;
+        var _b;
         const propertyNames = this.schema.getRootProperties();
         const existingAccessorNames = new Set(Observable.getAccessors(this.classPrototype).map(a => a.name));
         const strategy = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a["attribute-name-strategy"]) !== null && _b !== void 0 ? _b : "camelCase";

package/dist/esm/di/di.js

@@ -800,7 +800,8 @@ export class ResolverImpl {
         }
     }
     getFactory(container) {
-        var _a, _b, _c;
+        var _a, _b;
+        var _c;
         switch (this.strategy) {
             case ResolverStrategy.singleton:
             case ResolverStrategy.transient:

package/dist/esm/metadata.js

@@ -34,19 +34,13 @@ export const Metadata = Object.freeze({
      * @param Type - The type to get the metadata for.
      * @returns The metadata array or a frozen empty array if no metadata is found.
      */
-    getDesignParamTypes: (Type) => {
-        var _a;
-        return ((_a = Reflect.getOwnMetadata(designParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray);
-    },
+    getDesignParamTypes: (Type) => { var _a; return ((_a = Reflect.getOwnMetadata(designParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray); },
     /**
      * Gets the "annotation:paramtypes" metadata for the specified type.
      * @param Type - The type to get the metadata for.
      * @returns The metadata array or a frozen empty array if no metadata is found.
      */
-    getAnnotationParamTypes: (Type) => {
-        var _a;
-        return ((_a = Reflect.getOwnMetadata(annotationParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray);
-    },
+    getAnnotationParamTypes: (Type) => { var _a; return ((_a = Reflect.getOwnMetadata(annotationParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray); },
     /**
      * Gets the "annotation:paramtypes" metadata for the specified type. If none is found,
      * an empty, mutable metadata array is created and added.

package/dist/esm/observation/notifier.js

@@ -138,12 +138,10 @@ export class PropertyChangeNotifier {
         var _a, _b;
         let subscribers;
         if (propertyToWatch) {
-            subscribers =
-                (_a = this.subscribers[propertyToWatch]) !== null && _a !== void 0 ? _a : (this.subscribers[propertyToWatch] = new SubscriberSet(this.subject));
+            subscribers = (_a = this.subscribers[propertyToWatch]) !== null && _a !== void 0 ? _a : (this.subscribers[propertyToWatch] = new SubscriberSet(this.subject));
         }
         else {
-            subscribers =
-                (_b = this.subjectSubscribers) !== null && _b !== void 0 ? _b : (this.subjectSubscribers = new SubscriberSet(this.subject));
+            subscribers = (_b = this.subjectSubscribers) !== null && _b !== void 0 ? _b : (this.subjectSubscribers = new SubscriberSet(this.subject));
         }
         subscribers.subscribe(subscriber);
     }