@genesislcap/foundation-utils 14.73.0 → 14.74.0

package/dist/custom-elements.json

@@ -2193,6 +2193,23 @@
                 }
               },
               "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "#_blockLifecycleDueToTokenChange",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "lifecycleType",
+                  "type": {
+                    "text": "Lifecycletype"
+                  }
+                }
+              ]
             }
           ],
           "parameters": [

package/dist/dts/mixins/lifecycle/lifecycle.d.ts

@@ -11,6 +11,7 @@ export type ConstructableLifecycleHandler = Constructable<FASTElement & HTMLElem
 export type FoundationLayoutContainer = {
     dragging: boolean;
     hasFirstLoaded: boolean;
+    lifecycleUpdateToken: string | undefined;
     _key: 'foundation-layout';
 };
 /**
@@ -29,6 +30,7 @@ export type DOMContainer = {
     _key: 'dom';
 };
 type Container = FoundationLayoutContainer | LayoutCacheContainer | DOMContainer;
+type Lifecycletype = 'connect' | 'disconnect' | 'reconnect';
 /**
  * @beta
  * Mixin class to expose `shouldRunConnect` and `shouldRunDisconnect`
@@ -43,6 +45,31 @@ export declare const LifecycleMixin: <T extends ConstructableLifecycleHandler>(B
     new (...args: any[]): {
         /** @internal **/
         "__#1@#_container": Container;
+        /**
+         * If the token changes we suggest blocking the lifecycle methods
+         * @internal
+         **/
+        "__#1@#_latestTokenCode": string;
+        /**
+         * Track first loaded to allow us to always run the connect lifecycle on the first load
+         * @internal
+         **/
+        "__#1@#_hasFirstLoaded": boolean;
+        /**
+         * When you request to delete an item from the layout it will be removed from the DOM,
+         * but the lifecycle might be blocked due to the same mechanism that we block the other
+         * items.
+         * This would block cleanup of the item, so we need to force a disconnection after a timeout
+         * if this item hasn't reconnected within `CLEANUP_TIMEOUT_MS`.
+         * @internal
+         **/
+        "__#1@#_cleanupTimeout": NodeJS.Timeout;
+        /**
+         * Used to force lifecycle to run even if the token has changed, such as in instances where
+         * we are forcing a disconnection due to this item being remove from the layout.
+         * @internal
+         **/
+        "__#1@#_shouldForceLifecycle": boolean;
         /**
          * @privateRemarks
          * Rather than using the basic implementation of cloning we run a copy constructor (deepClone)
@@ -70,6 +97,7 @@ export declare const LifecycleMixin: <T extends ConstructableLifecycleHandler>(B
          * For now its just the same logic as shouldRunDisconnect
          */
         readonly shouldRunConnect: boolean;
+        "__#1@#_blockLifecycleDueToTokenChange"(lifecycleType: Lifecycletype): boolean;
         /**
          * @internal
          * Recursive function to try and find containing layout object

package/dist/dts/mixins/lifecycle/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/mixins/lifecycle/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,CAAC;AAErF;;;;GAIG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,mBAAmB,CAAC;CAC3B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,yBAAyB,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,KAAK,SAAS,GAAG,yBAAyB,GAAG,oBAAoB,GAAG,YAAY,CAAC;AAEjF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;kBAKF,GAAG,EAAE;QAH1B,iBAAiB;4BACJ,SAAS;QAMtB;;;;;WAKG;yBACuB,OAAO,GAAG,IAAI;QAUxC;;;;;;WAMG;qBACU,IAAI;QAMjB;;;WAGG;;QAYH;;;;;WAKG;;QAKH;;;;;;WAMG;4CAC0B,OAAO,GAAG,SAAS;6BA4B3B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAM1B,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,mBAAmB,eAAkC,CAAC"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/mixins/lifecycle/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,CAAC;AAErF;;;;GAIG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,IAAI,EAAE,mBAAmB,CAAC;CAC3B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,yBAAyB,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,KAAK,SAAS,GAAG,yBAAyB,GAAG,oBAAoB,GAAG,YAAY,CAAC;AAEjF,KAAK,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,CAAC;AAK5D;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;kBA+BF,GAAG,EAAE;QA7B1B,iBAAiB;4BACJ,SAAS;QAEtB;;;YAGI;kCACe,MAAM;QACzB;;;YAGI;iCACc,OAAO;QACzB;;;;;;;YAOI;iCACc,OAAO,OAAO;QAChC;;;;YAII;uCACoB,OAAO;QAM/B;;;;;WAKG;yBACuB,OAAO,GAAG,IAAI;QAUxC;;;;;;WAMG;qBACU,IAAI;QAMjB;;;WAGG;;QAmBH;;;;;WAKG;;+DAwB6C,aAAa,GAAG,OAAO;QA2BvE;;;;;;WAMG;4CAC0B,OAAO,GAAG,SAAS;6BA4B3B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAM1B,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,mBAAmB,eAAkC,CAAC"}

package/dist/esm/mixins/lifecycle/lifecycle.js

@@ -1,4 +1,6 @@
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+/** @internal **/
+const CLEANUP_TIMEOUT_MS = 10000;
 /**
  * @beta
  * Mixin class to expose `shouldRunConnect` and `shouldRunDisconnect`
@@ -9,12 +11,37 @@ import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
  * #_ syntax is used for a javascript private method/variable
  * we can't use private/protected from typescript in an anonymous class like this
  */
-export const LifecycleMixin = (Base) => { var _instances, __container, __tryFindContainingLayout, _a; return _a = class extends Base {
+export const LifecycleMixin = (Base) => { var _instances, __container, __latestTokenCode, __hasFirstLoaded, __cleanupTimeout, __shouldForceLifecycle, __blockLifecycleDueToTokenChange, __tryFindContainingLayout, _a; return _a = class extends Base {
         constructor(...args) {
             super(args);
             _instances.add(this);
             /** @internal **/
             __container.set(this, { _key: 'dom' });
+            /**
+             * If the token changes we suggest blocking the lifecycle methods
+             * @internal
+             **/
+            __latestTokenCode.set(this, '');
+            /**
+             * Track first loaded to allow us to always run the connect lifecycle on the first load
+             * @internal
+             **/
+            __hasFirstLoaded.set(this, false);
+            /**
+             * When you request to delete an item from the layout it will be removed from the DOM,
+             * but the lifecycle might be blocked due to the same mechanism that we block the other
+             * items.
+             * This would block cleanup of the item, so we need to force a disconnection after a timeout
+             * if this item hasn't reconnected within `CLEANUP_TIMEOUT_MS`.
+             * @internal
+             **/
+            __cleanupTimeout.set(this, void 0);
+            /**
+             * Used to force lifecycle to run even if the token has changed, such as in instances where
+             * we are forcing a disconnection due to this item being remove from the layout.
+             * @internal
+             **/
+            __shouldForceLifecycle.set(this, false);
         }
         /**
          * @privateRemarks
@@ -48,6 +75,9 @@ export const LifecycleMixin = (Base) => { var _instances, __container, __tryFind
          * @returns - boolean controlling whether to run all disconnectedCallback lifecycle functionality
          */
         get shouldRunDisconnect() {
+            if (__classPrivateFieldGet(this, __shouldForceLifecycle, "f")) {
+                return true;
+            }
             if (__classPrivateFieldGet(this, __container, "f")._key === 'dom') {
                 return true;
             }
@@ -55,7 +85,9 @@ export const LifecycleMixin = (Base) => { var _instances, __container, __tryFind
                 return false;
             }
             // _key === 'foundation-layout'
-            return !(__classPrivateFieldGet(this, __container, "f").dragging || !__classPrivateFieldGet(this, __container, "f").hasFirstLoaded);
+            return !(__classPrivateFieldGet(this, __container, "f").dragging ||
+                !__classPrivateFieldGet(this, __container, "f").hasFirstLoaded ||
+                __classPrivateFieldGet(this, _instances, "m", __blockLifecycleDueToTokenChange).call(this, 'disconnect'));
         }
         /**
          * @beta
@@ -64,7 +96,24 @@ export const LifecycleMixin = (Base) => { var _instances, __container, __tryFind
          * For now its just the same logic as shouldRunDisconnect
          */
         get shouldRunConnect() {
-            return this.shouldRunDisconnect;
+            if (__classPrivateFieldGet(this, __shouldForceLifecycle, "f")) {
+                return true;
+            }
+            if (__classPrivateFieldGet(this, __container, "f")._key === 'dom') {
+                return true;
+            }
+            if (__classPrivateFieldGet(this, __container, "f")._key === 'foundation-layout-cache') {
+                return false;
+            }
+            // _key === 'foundation-layout'
+            let connectionType = 'reconnect';
+            if (__classPrivateFieldGet(this, __hasFirstLoaded, "f") === false) {
+                __classPrivateFieldSet(this, __hasFirstLoaded, true, "f");
+                connectionType = 'connect';
+            }
+            return !(__classPrivateFieldGet(this, __container, "f").dragging ||
+                !__classPrivateFieldGet(this, __container, "f").hasFirstLoaded ||
+                __classPrivateFieldGet(this, _instances, "m", __blockLifecycleDueToTokenChange).call(this, connectionType));
         }
         connectedCallback() {
             super.connectedCallback();
@@ -74,7 +123,36 @@ export const LifecycleMixin = (Base) => { var _instances, __container, __tryFind
         }
     },
     __container = new WeakMap(),
+    __latestTokenCode = new WeakMap(),
+    __hasFirstLoaded = new WeakMap(),
+    __cleanupTimeout = new WeakMap(),
+    __shouldForceLifecycle = new WeakMap(),
     _instances = new WeakSet(),
+    __blockLifecycleDueToTokenChange = function __blockLifecycleDueToTokenChange(lifecycleType) {
+        var _a, _b;
+        if (__classPrivateFieldGet(this, __container, "f")._key !== 'foundation-layout') {
+            throw new Error('LifecycleMixin: should not be checking a token change if container not in the layout');
+        }
+        const tokensDifferent = __classPrivateFieldGet(this, __latestTokenCode, "f") !== __classPrivateFieldGet(this, __container, "f").lifecycleUpdateToken;
+        let result = false;
+        if (lifecycleType === 'connect') {
+            // We always want to allow a first connection in the layout
+            __classPrivateFieldSet(this, __latestTokenCode, (_a = __classPrivateFieldGet(this, __container, "f").lifecycleUpdateToken) !== null && _a !== void 0 ? _a : '', "f");
+        }
+        else if (lifecycleType === 'disconnect') {
+            result = tokensDifferent;
+            __classPrivateFieldSet(this, __cleanupTimeout, setTimeout(() => {
+                __classPrivateFieldSet(this, __shouldForceLifecycle, true, "f");
+                this.disconnectedCallback();
+            }, CLEANUP_TIMEOUT_MS), "f");
+        }
+        else if (lifecycleType === 'reconnect') {
+            result = tokensDifferent;
+            __classPrivateFieldSet(this, __latestTokenCode, (_b = __classPrivateFieldGet(this, __container, "f").lifecycleUpdateToken) !== null && _b !== void 0 ? _b : '', "f");
+            clearTimeout(__classPrivateFieldGet(this, __cleanupTimeout, "f"));
+        }
+        return result;
+    },
     __tryFindContainingLayout = function __tryFindContainingLayout(e) {
         /**
          * This is a special case where the element is part of the layout cache

package/dist/foundation-utils.api.json

@@ -4483,7 +4483,16 @@
             },
             {
               "kind": "Content",
-              "text": ";\n        cloneNode(deep?: boolean): "
+              "text": ";\n        \"__#1@#_latestTokenCode\": string;\n        \"__#1@#_hasFirstLoaded\": boolean;\n        \"__#1@#_cleanupTimeout\": "
+            },
+            {
+              "kind": "Reference",
+              "text": "NodeJS.Timeout",
+              "canonicalReference": "!\"\\\"timers\\\"\".__global.NodeJS.Timeout:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n        \"__#1@#_shouldForceLifecycle\": boolean;\n        cloneNode(deep?: boolean): "
             },
             {
               "kind": "Reference",
@@ -4501,7 +4510,16 @@
             },
             {
               "kind": "Content",
-              "text": ";\n        readonly shouldRunDisconnect: boolean;\n        readonly shouldRunConnect: boolean;\n        \"__#1@#_tryFindContainingLayout\"(e: "
+              "text": ";\n        readonly shouldRunDisconnect: boolean;\n        readonly shouldRunConnect: boolean;\n        \"__#1@#_blockLifecycleDueToTokenChange\"(lifecycleType: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Lifecycletype",
+              "canonicalReference": "@genesislcap/foundation-utils!~Lifecycletype:type"
+            },
+            {
+              "kind": "Content",
+              "text": "): boolean;\n        \"__#1@#_tryFindContainingLayout\"(e: "
             },
             {
               "kind": "Reference",
@@ -7372,7 +7390,7 @@
           "name": "LifecycleMixin",
           "variableTypeTokenRange": {
             "startIndex": 1,
-            "endIndex": 646
+            "endIndex": 650
           }
         },
         {

package/dist/foundation-utils.d.ts

@@ -374,6 +374,7 @@ export declare function formatTimestamp(timestamp: number, withTime: boolean): s
 export declare type FoundationLayoutContainer = {
     dragging: boolean;
     hasFirstLoaded: boolean;
+    lifecycleUpdateToken: string | undefined;
     _key: 'foundation-layout';
 };
 
@@ -535,6 +536,31 @@ export declare const LifecycleMixin: <T extends ConstructableLifecycleHandler>(B
     new (...args: any[]): {
         /** @internal **/
         "__#1@#_container": Container;
+        /**
+         * If the token changes we suggest blocking the lifecycle methods
+         * @internal
+         **/
+        "__#1@#_latestTokenCode": string;
+        /**
+         * Track first loaded to allow us to always run the connect lifecycle on the first load
+         * @internal
+         **/
+        "__#1@#_hasFirstLoaded": boolean;
+        /**
+         * When you request to delete an item from the layout it will be removed from the DOM,
+         * but the lifecycle might be blocked due to the same mechanism that we block the other
+         * items.
+         * This would block cleanup of the item, so we need to force a disconnection after a timeout
+         * if this item hasn't reconnected within `CLEANUP_TIMEOUT_MS`.
+         * @internal
+         **/
+        "__#1@#_cleanupTimeout": NodeJS.Timeout;
+        /**
+         * Used to force lifecycle to run even if the token has changed, such as in instances where
+         * we are forcing a disconnection due to this item being remove from the layout.
+         * @internal
+         **/
+        "__#1@#_shouldForceLifecycle": boolean;
         /**
          * @privateRemarks
          * Rather than using the basic implementation of cloning we run a copy constructor (deepClone)
@@ -562,6 +588,7 @@ export declare const LifecycleMixin: <T extends ConstructableLifecycleHandler>(B
          * For now its just the same logic as shouldRunDisconnect
          */
         readonly shouldRunConnect: boolean;
+        "__#1@#_blockLifecycleDueToTokenChange"(lifecycleType: Lifecycletype): boolean;
         /**
          * @internal
          * Recursive function to try and find containing layout object
@@ -885,6 +912,8 @@ export declare const LifecycleMixin: <T extends ConstructableLifecycleHandler>(B
     };
 } & T;
 
+declare type Lifecycletype = 'connect' | 'disconnect' | 'reconnect';
+
 /**
  * Creates an observer that facilitates the subscription and publication of events.
  * @public

package/docs/api/foundation-utils.lifecyclemixin.md

@@ -15,10 +15,15 @@ Mixin class to expose `shouldRunConnect` and `shouldRunDisconnect`
 LifecycleMixin: <T extends ConstructableLifecycleHandler>(Base: T) => {
     new (...args: any[]): {
         "__#1@#_container": Container;
+        "__#1@#_latestTokenCode": string;
+        "__#1@#_hasFirstLoaded": boolean;
+        "__#1@#_cleanupTimeout": NodeJS.Timeout;
+        "__#1@#_shouldForceLifecycle": boolean;
         cloneNode(deep?: boolean): Node;
         deepClone(): Node;
         readonly shouldRunDisconnect: boolean;
         readonly shouldRunConnect: boolean;
+        "__#1@#_blockLifecycleDueToTokenChange"(lifecycleType: Lifecycletype): boolean;
         "__#1@#_tryFindContainingLayout"(e: Element): Container;
         connectedCallback(): void;
         readonly $fastController: import("@microsoft/fast-element").Controller;

package/docs/api-report.md

@@ -235,6 +235,7 @@ export function formatTimestamp(timestamp: number, withTime: boolean): string;
 export type FoundationLayoutContainer = {
     dragging: boolean;
     hasFirstLoaded: boolean;
+    lifecycleUpdateToken: string | undefined;
     _key: 'foundation-layout';
 };
 
@@ -311,10 +312,15 @@ export const layoutCacheDocument: unique symbol;
 export const LifecycleMixin: <T extends ConstructableLifecycleHandler>(Base: T) => {
     new (...args: any[]): {
         "__#1@#_container": Container;
+        "__#1@#_latestTokenCode": string;
+        "__#1@#_hasFirstLoaded": boolean;
+        "__#1@#_cleanupTimeout": NodeJS.Timeout;
+        "__#1@#_shouldForceLifecycle": boolean;
         cloneNode(deep?: boolean): Node;
         deepClone(): Node;
         readonly shouldRunDisconnect: boolean;
         readonly shouldRunConnect: boolean;
+        "__#1@#_blockLifecycleDueToTokenChange"(lifecycleType: Lifecycletype): boolean;
         "__#1@#_tryFindContainingLayout"(e: Element): Container;
         connectedCallback(): void;
         readonly $fastController: Controller;
@@ -1112,7 +1118,8 @@ export function whenElse<TSource = any, TReturn = any>(binding: Binding<TSource,
 //
 // src/mappers/dto/serverRow.ts:20:5 - (ae-forgotten-export) The symbol "UppercaseOperation" needs to be exported by the entry point index.d.ts
 // src/mappers/dto/serverRow.ts:31:5 - (ae-forgotten-export) The symbol "LowercaseOperation" needs to be exported by the entry point index.d.ts
-// src/mixins/lifecycle/lifecycle.ts:51:5 - (ae-forgotten-export) The symbol "Container" needs to be exported by the entry point index.d.ts
+// src/mixins/lifecycle/lifecycle.ts:57:5 - (ae-forgotten-export) The symbol "Container" needs to be exported by the entry point index.d.ts
+// src/mixins/lifecycle/lifecycle.ts:147:5 - (ae-forgotten-export) The symbol "Lifecycletype" needs to be exported by the entry point index.d.ts
 
 // (No @packageDocumentation comment for this package)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-utils",
   "description": "Genesis Foundation Utils",
-  "version": "14.73.0",
+  "version": "14.74.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -41,5 +41,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "29876c67e7127ee076ccb33c01e23abe1607d45a"
+  "gitHead": "744f54392e6e9f73c0cddd55300925aa594020d2"
 }