@ethlete/core 4.13.0 → 4.14.0

package/fesm2022/ethlete-core.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, HostBinding, InjectionToken, assertInInjectionContext, DestroyRef, ElementRef, TemplateRef, Injectable, isSignal, signal, QueryList, Injector, runInInjectionContext, effect, afterNextRender, untracked, NgZone, isDevMode, computed, Directive, model, EventEmitter, booleanAttribute, numberAttribute, Output, ViewContainerRef, Pipe, AfterRenderPhase, input } from '@angular/core';
+import { inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, HostBinding, InjectionToken, assertInInjectionContext, DestroyRef, ElementRef, TemplateRef, Injectable, isSignal, signal, QueryList, Injector, effect, untracked, runInInjectionContext, afterNextRender, NgZone, isDevMode, computed, Directive, model, EventEmitter, booleanAttribute, numberAttribute, Output, ViewContainerRef, Pipe, AfterRenderPhase, input } from '@angular/core';
 import { DomSanitizer, Meta, Title } from '@angular/platform-browser';
 import { Subject, BehaviorSubject, takeUntil, switchMap, of, tap, map, startWith, Observable, combineLatest, timer, distinctUntilChanged, shareReplay, filter, take, fromEvent, pairwise, debounceTime, finalize, merge, skip, takeWhile } from 'rxjs';
 import { END, HOME, PAGE_DOWN, PAGE_UP, UP_ARROW, DOWN_ARROW } from '@angular/cdk/keycodes';
@@ -2303,51 +2303,7 @@ const buildElementSignal = (el) => {
         previousElement: previousElements?.[0] ?? null,
     }))), { initialValue: { currentElement: null, previousElement: null, previousElements: [], currentElements: [] } });
 };
-const buildSignalEffects = (config) => {
-    const injector = inject(Injector);
-    const { map, eachItemFn, cleanupFn } = config;
-    const effectRefMap = {};
-    const has = (token) => token in effectRefMap;
-    const push = (tokenString, signal) => {
-        if (has(tokenString))
-            return;
-        const tokenArray = tokenString.split(' ').filter((token) => !!token);
-        for (const token of tokenArray) {
-            runInInjectionContext(injector, () => {
-                const ref = effect(() => {
-                    const value = signal();
-                    eachItemFn({ key: token, value });
-                });
-                effectRefMap[token] = ref;
-            });
-        }
-    };
-    const pushMany = (map) => {
-        for (const [tokenString, signal] of Object.entries(map)) {
-            push(tokenString, signal);
-        }
-    };
-    const remove = (...tokens) => {
-        for (const tokenString of tokens) {
-            effectRefMap[tokenString]?.destroy();
-            cleanupFn({ key: tokenString, value: map[tokenString]?.() });
-            delete effectRefMap[tokenString];
-        }
-    };
-    const removeMany = (tokens) => {
-        for (const token of tokens) {
-            remove(token);
-        }
-    };
-    pushMany(map);
-    return { remove, removeMany, has, push, pushMany };
-};
-const signalIsRendered = () => {
-    const isRendered = signal(false);
-    afterNextRender(() => isRendered.set(true));
-    return isRendered.asReadonly();
-};
-const signalClasses = (el, classMap) => {
+const buildSignalEffects = (el, config) => {
     const elements = buildElementSignal(el);
     const injector = inject(Injector);
     effect(() => {
@@ -2355,24 +2311,22 @@ const signalClasses = (el, classMap) => {
         for (const previousEl of previousElements) {
             if (currentElements.includes(previousEl))
                 continue;
-            const tokens = Object.keys(classMap)
+            const tokens = Object.keys(config.tokenMap)
                 .map((key) => key.split(' '))
                 .flat();
             if (!tokens.length)
                 continue;
-            previousEl.classList.remove(...tokens);
+            config.cleanupFn(previousEl, tokens);
         }
         for (const currentEl of currentElements) {
             if (previousElements.includes(currentEl))
                 continue;
-            for (const [tokens, condition] of Object.entries(classMap)) {
+            for (const [tokens, condition] of Object.entries(config.tokenMap)) {
                 untracked(() => {
-                    if (!condition())
-                        return;
                     const tokenArray = tokens.split(' ');
                     if (!tokenArray.length)
                         return;
-                    currentEl.classList.add(...tokenArray);
+                    config.updateFn(currentEl, tokenArray, condition());
                 });
             }
         }
@@ -2389,12 +2343,7 @@ const signalClasses = (el, classMap) => {
                     const tokenArray = tokens.split(' ');
                     if (!tokenArray.length)
                         continue;
-                    if (!signal()) {
-                        el.classList.remove(...tokenArray);
-                    }
-                    else {
-                        el.classList.add(...tokenArray);
-                    }
+                    config.updateFn(el, tokenArray, signal());
                 }
             });
         });
@@ -2411,7 +2360,7 @@ const signalClasses = (el, classMap) => {
             const tokenArray = tokens.split(' ');
             if (!tokenArray.length)
                 continue;
-            el.classList.remove(...tokenArray);
+            config.cleanupFn(el, tokenArray);
         }
     };
     const removeMany = (tokens) => {
@@ -2419,52 +2368,70 @@ const signalClasses = (el, classMap) => {
             remove(token);
         }
     };
-    pushMany(classMap);
+    pushMany(config.tokenMap);
     return { remove, removeMany, has, push, pushMany };
 };
+const signalIsRendered = () => {
+    const isRendered = signal(false);
+    afterNextRender(() => isRendered.set(true));
+    return isRendered.asReadonly();
+};
+const signalClasses = (el, classMap) => {
+    return buildSignalEffects(el, {
+        tokenMap: classMap,
+        cleanupFn: (el, tokens) => el.classList.remove(...tokens),
+        updateFn: (el, tokens, condition) => {
+            if (!condition) {
+                el.classList.remove(...tokens);
+            }
+            else {
+                el.classList.add(...tokens);
+            }
+        },
+    });
+};
 const signalHostClasses = (classMap) => signalClasses(inject(ElementRef), classMap);
 const ALWAYS_TRUE_ATTRIBUTE_KEYS = ['disabled', 'readonly', 'required', 'checked', 'selected', 'hidden', 'inert'];
 const signalAttributes = (el, attributeMap) => {
-    const elements = buildElementSignal(el);
-    return buildSignalEffects({
-        map: attributeMap,
-        eachItemFn: ({ key, value }) => {
-            const valueString = `${value}`;
-            if (ALWAYS_TRUE_ATTRIBUTE_KEYS.includes(key)) {
-                if (value) {
-                    elements().currentElement?.setAttribute(key, '');
-                }
-                else {
-                    elements().currentElement?.removeAttribute(key);
+    return buildSignalEffects(el, {
+        tokenMap: attributeMap,
+        cleanupFn: (el, tokens) => tokens.forEach((token) => el.removeAttribute(token)),
+        updateFn: (el, tokens, condition) => {
+            for (const token of tokens) {
+                if (ALWAYS_TRUE_ATTRIBUTE_KEYS.includes(token)) {
+                    if (condition) {
+                        el.setAttribute(token, '');
+                    }
+                    else {
+                        el.removeAttribute(token);
+                    }
+                    continue;
                 }
-            }
-            else {
-                if (value === null || value === undefined) {
-                    elements().currentElement?.removeAttribute(key);
+                if (condition === null || condition === undefined) {
+                    el.removeAttribute(token);
                 }
                 else {
-                    elements().currentElement?.setAttribute(key, valueString);
+                    el.setAttribute(token, `${condition}`);
                 }
             }
         },
-        cleanupFn: ({ key }) => elements().currentElement?.removeAttribute(key),
     });
 };
 const signalHostAttributes = (attributeMap) => signalAttributes(inject(ElementRef), attributeMap);
 const signalStyles = (el, styleMap) => {
-    const elements = buildElementSignal(el);
-    return buildSignalEffects({
-        map: styleMap,
-        eachItemFn: ({ key, value }) => {
-            if (value === null || value === undefined) {
-                elements().currentElement?.style.removeProperty(key);
-            }
-            else {
-                const valueString = `${value}`;
-                elements().currentElement?.style.setProperty(key, valueString);
+    return buildSignalEffects(el, {
+        tokenMap: styleMap,
+        cleanupFn: (el, tokens) => tokens.forEach((token) => el.style.removeProperty(token)),
+        updateFn: (el, tokens, condition) => {
+            for (const token of tokens) {
+                if (condition === null || condition === undefined) {
+                    el.style.removeProperty(token);
+                }
+                else {
+                    el.style.setProperty(token, `${condition}`);
+                }
             }
         },
-        cleanupFn: ({ key }) => elements().currentElement?.style.removeProperty(key),
     });
 };
 const signalHostStyles = (styleMap) => signalStyles(inject(ElementRef), styleMap);
@@ -2642,6 +2609,7 @@ const signalElementIntersection = (el, options) => {
         }
         if (els.currentElements.length && !!enabled) {
             const rootEl = untracked(() => root().currentElement);
+            const rootBounds = rootEl?.getBoundingClientRect();
             // check sync for intersections since the intersection observer async and we probably want to know the initial state
             const entries = els.currentElements
                 .map((el) => {
@@ -2660,12 +2628,13 @@ const signalElementIntersection = (el, options) => {
                 const blockIntersectionRatio = visibility.blockIntersection / 100;
                 const isIntersecting = inlineIntersectionRatio > 0 && blockIntersectionRatio > 0;
                 const intersectionRatio = Math.min(inlineIntersectionRatio, blockIntersectionRatio);
+                const elBounds = el.getBoundingClientRect();
                 const intersectionEntry = {
-                    boundingClientRect: el.getBoundingClientRect(),
+                    boundingClientRect: elBounds,
                     intersectionRatio,
-                    intersectionRect: el.getBoundingClientRect(),
+                    intersectionRect: elBounds,
                     isIntersecting,
-                    rootBounds: root().currentElement?.getBoundingClientRect() ?? null,
+                    rootBounds: rootBounds ?? null,
                     target: el,
                     time: performance.now(),
                 };