ng-primitives 0.0.7 → 0.2.0

package/esm2022/focus-trap/focus-trap/focus-trap.directive.mjs

@@ -0,0 +1,262 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InteractivityChecker } from '@angular/cdk/a11y';
+import { booleanAttribute, Directive, ElementRef, HostListener, inject, input, NgZone, } from '@angular/core';
+import { NgpFocusTrapToken } from './focus-trap.token';
+import * as i0 from "@angular/core";
+/**
+ * This implementation is based on the Radix UI FocusScope:
+ * https://github.com/radix-ui/primitives/blob/main/packages/react/focus-scope/src/FocusScope.tsx#L306
+ */
+class FocusTrap {
+    constructor() {
+        /**
+         * Whether the focus trap is active.
+         */
+        this.active = false;
+    }
+    /**
+     * Activates the focus trap.
+     */
+    activate() {
+        this.active = true;
+    }
+    /**
+     * Deactivates the focus trap.
+     */
+    deactivate() {
+        this.active = false;
+    }
+}
+class FocusTrapStack {
+    constructor() {
+        /**
+         * The stack of focus traps.
+         */
+        this.stack = [];
+    }
+    /**
+     * Adds a focus trap to the stack.
+     */
+    add(focusTrap) {
+        // deactivate the previous focus trap
+        this.stack.forEach(t => t.deactivate());
+        // add the new focus trap and activate it
+        this.stack.push(focusTrap);
+        focusTrap.activate();
+    }
+    /**
+     * Removes a focus trap from the stack.
+     */
+    remove(focusTrap) {
+        // remove the focus trap
+        const index = this.stack.indexOf(focusTrap);
+        if (index >= 0) {
+            this.stack.splice(index, 1);
+        }
+        // activate the previous focus trap
+        const previous = this.stack[this.stack.length - 1];
+        if (previous) {
+            previous.activate();
+        }
+    }
+}
+// create a global stack of focus traps
+const focusTrapStack = new FocusTrapStack();
+export class NgpFocusTrap {
+    constructor() {
+        /**
+         * Create a new focus trap.
+         */
+        this.focusTrap = new FocusTrap();
+        /**
+         * Access the interactivity checker.
+         */
+        this.interactivityChecker = inject(InteractivityChecker);
+        /**
+         * Get the focus trap container element.
+         */
+        this.elementRef = inject(ElementRef);
+        /**
+         * Access NgZone to run the focus trap events outside of Angular's zone.
+         */
+        this.ngZone = inject(NgZone);
+        /**
+         * Store the mutation observer.
+         */
+        this.mutationObserver = null;
+        /**
+         * Store the last focused element.
+         */
+        this.lastFocusedElement = null;
+        /**
+         * Whether the focus trap is disabled.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpFocusTrapDisabled',
+            transform: booleanAttribute,
+        });
+    }
+    ngOnInit() {
+        focusTrapStack.add(this.focusTrap);
+        this.mutationObserver = new MutationObserver(this.handleMutations.bind(this));
+        // setup event listeners
+        this.ngZone.runOutsideAngular(() => {
+            this.mutationObserver.observe(this.elementRef.nativeElement, {
+                childList: true,
+                subtree: true,
+            });
+            document.addEventListener('focusin', this.handleFocusIn.bind(this));
+            document.addEventListener('focusout', this.handleFocusOut.bind(this));
+        });
+        const previouslyFocusedElement = document.activeElement;
+        const hasFocusedCandidate = this.elementRef.nativeElement.contains(previouslyFocusedElement);
+        if (!hasFocusedCandidate) {
+            this.focusFirst();
+            // if the focus didn't change, focus the container
+            if (document.activeElement === previouslyFocusedElement) {
+                this.focus(this.elementRef.nativeElement);
+            }
+        }
+    }
+    ngOnDestroy() {
+        focusTrapStack.remove(this.focusTrap);
+        this.mutationObserver?.disconnect();
+    }
+    handleFocusIn(event) {
+        if (!this.focusTrap.active || this.disabled()) {
+            return;
+        }
+        const target = event.target;
+        if (this.elementRef.nativeElement.contains(target)) {
+            this.lastFocusedElement = target;
+        }
+        else {
+            this.focus(this.lastFocusedElement);
+        }
+    }
+    /**
+     * Handles the `focusout` event.
+     */
+    handleFocusOut(event) {
+        if (!this.focusTrap.active || this.disabled() || event.relatedTarget === null) {
+            return;
+        }
+        const relatedTarget = event.relatedTarget;
+        if (!this.elementRef.nativeElement.contains(relatedTarget)) {
+            this.focus(this.lastFocusedElement);
+        }
+    }
+    /**
+     * If the focused element gets removed from the DOM, browsers move focus back to the document.body.
+     * We move focus to the container to keep focus trapped correctly.
+     */
+    handleMutations(mutations) {
+        const focusedElement = document.activeElement;
+        if (focusedElement !== document.body) {
+            return;
+        }
+        for (const mutation of mutations) {
+            if (mutation.removedNodes.length > 0) {
+                this.focus(this.elementRef.nativeElement);
+            }
+        }
+    }
+    /**
+     * Handles the `keydown` event.
+     */
+    handleKeyDown(event) {
+        if (!this.focusTrap.active || this.disabled()) {
+            return;
+        }
+        const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;
+        const focusedElement = document.activeElement;
+        if (isTabKey && focusedElement) {
+            const container = event.currentTarget;
+            const [first, last] = this.getTabbableEdges(container);
+            const hasTabbableElementsInside = first && last;
+            // we can only wrap focus if we have tabbable edges
+            if (!hasTabbableElementsInside) {
+                if (focusedElement === container) {
+                    event.preventDefault();
+                }
+            }
+            else {
+                if (!event.shiftKey && focusedElement === last) {
+                    event.preventDefault();
+                    this.focus(first);
+                }
+                else if (event.shiftKey && focusedElement === first) {
+                    event.preventDefault();
+                    this.focus(last);
+                }
+            }
+        }
+    }
+    /**
+     * Returns the first and last tabbable elements inside a container.
+     */
+    getTabbableEdges(container) {
+        const candidates = this.getTabbableCandidates(container);
+        const first = this.findVisible(candidates);
+        const last = this.findVisible(candidates.reverse());
+        return [first, last];
+    }
+    /**
+     * Returns a list of potential focusable elements inside a container.
+     */
+    getTabbableCandidates(container) {
+        const nodes = [];
+        const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+            acceptNode: (node) => this.interactivityChecker.isFocusable(node)
+                ? NodeFilter.FILTER_ACCEPT
+                : NodeFilter.FILTER_SKIP,
+        });
+        while (walker.nextNode()) {
+            nodes.push(walker.currentNode);
+        }
+        return nodes;
+    }
+    /**
+     * Returns the first visible element in a list..
+     */
+    findVisible(elements) {
+        return elements.find(element => this.interactivityChecker.isVisible(element)) ?? null;
+    }
+    focus(element) {
+        element?.focus({ preventScroll: true });
+    }
+    focusFirst() {
+        const previouslyFocusedElement = document.activeElement;
+        for (const candidate of this.getTabbableCandidates(this.elementRef.nativeElement)) {
+            this.focus(candidate);
+            if (document.activeElement !== previouslyFocusedElement) {
+                return;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpFocusTrap, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpFocusTrap, isStandalone: true, selector: "[ngpFocusTrap]", inputs: { disabled: { classPropertyName: "disabled", publicName: "ngpFocusTrapDisabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "keydown": "handleKeyDown($event)" }, properties: { "attr.tabindex": "-1", "attr.data-focus-trap": "!disabled()" } }, providers: [{ provide: NgpFocusTrapToken, useExisting: NgpFocusTrap }], exportAs: ["ngpFocusTrap"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpFocusTrap, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpFocusTrap]',
+                    exportAs: 'ngpFocusTrap',
+                    providers: [{ provide: NgpFocusTrapToken, useExisting: NgpFocusTrap }],
+                    host: {
+                        '[attr.tabindex]': '-1',
+                        '[attr.data-focus-trap]': '!disabled()',
+                    },
+                }]
+        }], propDecorators: { handleKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focus-trap.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/focus-trap/src/focus-trap/focus-trap.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright © 2024 Angular Primitives.\n * https://github.com/ng-primitives/ng-primitives\n *\n * This source code is licensed under the CC BY-ND 4.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\nimport { InteractivityChecker } from '@angular/cdk/a11y';\nimport {\n  booleanAttribute,\n  Directive,\n  ElementRef,\n  HostListener,\n  inject,\n  input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n} from '@angular/core';\nimport { NgpFocusTrapToken } from './focus-trap.token';\n\n/**\n * This implementation is based on the Radix UI FocusScope:\n * https://github.com/radix-ui/primitives/blob/main/packages/react/focus-scope/src/FocusScope.tsx#L306\n */\n\nclass FocusTrap {\n  /**\n   * Whether the focus trap is active.\n   */\n  active: boolean = false;\n\n  /**\n   * Activates the focus trap.\n   */\n  activate(): void {\n    this.active = true;\n  }\n\n  /**\n   * Deactivates the focus trap.\n   */\n  deactivate(): void {\n    this.active = false;\n  }\n}\n\nclass FocusTrapStack {\n  /**\n   * The stack of focus traps.\n   */\n  private readonly stack: FocusTrap[] = [];\n\n  /**\n   * Adds a focus trap to the stack.\n   */\n  add(focusTrap: FocusTrap): void {\n    // deactivate the previous focus trap\n    this.stack.forEach(t => t.deactivate());\n\n    // add the new focus trap and activate it\n    this.stack.push(focusTrap);\n    focusTrap.activate();\n  }\n\n  /**\n   * Removes a focus trap from the stack.\n   */\n  remove(focusTrap: FocusTrap): void {\n    // remove the focus trap\n    const index = this.stack.indexOf(focusTrap);\n\n    if (index >= 0) {\n      this.stack.splice(index, 1);\n    }\n\n    // activate the previous focus trap\n    const previous = this.stack[this.stack.length - 1];\n\n    if (previous) {\n      previous.activate();\n    }\n  }\n}\n\n// create a global stack of focus traps\nconst focusTrapStack = new FocusTrapStack();\n\n@Directive({\n  standalone: true,\n  selector: '[ngpFocusTrap]',\n  exportAs: 'ngpFocusTrap',\n  providers: [{ provide: NgpFocusTrapToken, useExisting: NgpFocusTrap }],\n  host: {\n    '[attr.tabindex]': '-1',\n    '[attr.data-focus-trap]': '!disabled()',\n  },\n})\nexport class NgpFocusTrap implements OnInit, OnDestroy {\n  /**\n   * Create a new focus trap.\n   */\n  private readonly focusTrap = new FocusTrap();\n\n  /**\n   * Access the interactivity checker.\n   */\n  private readonly interactivityChecker = inject(InteractivityChecker);\n\n  /**\n   * Get the focus trap container element.\n   */\n  private readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n\n  /**\n   * Access NgZone to run the focus trap events outside of Angular's zone.\n   */\n  private readonly ngZone = inject(NgZone);\n\n  /**\n   * Store the mutation observer.\n   */\n  private mutationObserver: MutationObserver | null = null;\n\n  /**\n   * Store the last focused element.\n   */\n  private lastFocusedElement: HTMLElement | null = null;\n\n  /**\n   * Whether the focus trap is disabled.\n   */\n  readonly disabled = input(false, {\n    alias: 'ngpFocusTrapDisabled',\n    transform: booleanAttribute,\n  });\n\n  ngOnInit(): void {\n    focusTrapStack.add(this.focusTrap);\n\n    this.mutationObserver = new MutationObserver(this.handleMutations.bind(this));\n\n    // setup event listeners\n    this.ngZone.runOutsideAngular(() => {\n      this.mutationObserver!.observe(this.elementRef.nativeElement, {\n        childList: true,\n        subtree: true,\n      });\n      document.addEventListener('focusin', this.handleFocusIn.bind(this));\n      document.addEventListener('focusout', this.handleFocusOut.bind(this));\n    });\n\n    const previouslyFocusedElement = document.activeElement as HTMLElement | null;\n    const hasFocusedCandidate = this.elementRef.nativeElement.contains(previouslyFocusedElement);\n\n    if (!hasFocusedCandidate) {\n      this.focusFirst();\n\n      // if the focus didn't change, focus the container\n      if (document.activeElement === previouslyFocusedElement) {\n        this.focus(this.elementRef.nativeElement);\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    focusTrapStack.remove(this.focusTrap);\n    this.mutationObserver?.disconnect();\n  }\n\n  private handleFocusIn(event: FocusEvent): void {\n    if (!this.focusTrap.active || this.disabled()) {\n      return;\n    }\n\n    const target = event.target as HTMLElement | null;\n\n    if (this.elementRef.nativeElement.contains(target)) {\n      this.lastFocusedElement = target;\n    } else {\n      this.focus(this.lastFocusedElement);\n    }\n  }\n\n  /**\n   * Handles the `focusout` event.\n   */\n  private handleFocusOut(event: FocusEvent) {\n    if (!this.focusTrap.active || this.disabled() || event.relatedTarget === null) {\n      return;\n    }\n\n    const relatedTarget = event.relatedTarget as HTMLElement;\n\n    if (!this.elementRef.nativeElement.contains(relatedTarget)) {\n      this.focus(this.lastFocusedElement);\n    }\n  }\n\n  /**\n   * If the focused element gets removed from the DOM, browsers move focus back to the document.body.\n   * We move focus to the container to keep focus trapped correctly.\n   */\n  private handleMutations(mutations: MutationRecord[]): void {\n    const focusedElement = document.activeElement as HTMLElement | null;\n\n    if (focusedElement !== document.body) {\n      return;\n    }\n\n    for (const mutation of mutations) {\n      if (mutation.removedNodes.length > 0) {\n        this.focus(this.elementRef.nativeElement);\n      }\n    }\n  }\n\n  /**\n   * Handles the `keydown` event.\n   */\n  @HostListener('keydown', ['$event'])\n  protected handleKeyDown(event: KeyboardEvent): void {\n    if (!this.focusTrap.active || this.disabled()) {\n      return;\n    }\n\n    const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;\n    const focusedElement = document.activeElement as HTMLElement | null;\n\n    if (isTabKey && focusedElement) {\n      const container = event.currentTarget as HTMLElement;\n      const [first, last] = this.getTabbableEdges(container);\n      const hasTabbableElementsInside = first && last;\n\n      // we can only wrap focus if we have tabbable edges\n      if (!hasTabbableElementsInside) {\n        if (focusedElement === container) {\n          event.preventDefault();\n        }\n      } else {\n        if (!event.shiftKey && focusedElement === last) {\n          event.preventDefault();\n          this.focus(first);\n        } else if (event.shiftKey && focusedElement === first) {\n          event.preventDefault();\n          this.focus(last);\n        }\n      }\n    }\n  }\n\n  /**\n   * Returns the first and last tabbable elements inside a container.\n   */\n  private getTabbableEdges(container: HTMLElement) {\n    const candidates = this.getTabbableCandidates(container);\n    const first = this.findVisible(candidates);\n    const last = this.findVisible(candidates.reverse());\n    return [first, last] as const;\n  }\n\n  /**\n   * Returns a list of potential focusable elements inside a container.\n   */\n  private getTabbableCandidates(container: HTMLElement) {\n    const nodes: HTMLElement[] = [];\n    const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {\n      acceptNode: (node: HTMLElement) =>\n        this.interactivityChecker.isFocusable(node)\n          ? NodeFilter.FILTER_ACCEPT\n          : NodeFilter.FILTER_SKIP,\n    });\n    while (walker.nextNode()) {\n      nodes.push(walker.currentNode as HTMLElement);\n    }\n    return nodes;\n  }\n\n  /**\n   * Returns the first visible element in a list..\n   */\n  private findVisible(elements: HTMLElement[]) {\n    return elements.find(element => this.interactivityChecker.isVisible(element)) ?? null;\n  }\n\n  private focus(element?: HTMLElement | null) {\n    element?.focus({ preventScroll: true });\n  }\n\n  private focusFirst(): void {\n    const previouslyFocusedElement = document.activeElement;\n\n    for (const candidate of this.getTabbableCandidates(this.elementRef.nativeElement)) {\n      this.focus(candidate);\n\n      if (document.activeElement !== previouslyFocusedElement) {\n        return;\n      }\n    }\n  }\n}\n"]}

package/esm2022/focus-trap/focus-trap/focus-trap.token.mjs

@@ -0,0 +1,16 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InjectionToken, inject } from '@angular/core';
+export const NgpFocusTrapToken = new InjectionToken('NgpFocusTrapToken');
+/**
+ * Inject the FocusTrap directive instance
+ */
+export function injectFocusTrap() {
+    return inject(NgpFocusTrapToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMtdHJhcC50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nLXByaW1pdGl2ZXMvZm9jdXMtdHJhcC9zcmMvZm9jdXMtdHJhcC9mb2N1cy10cmFwLnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUNILE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR3ZELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLElBQUksY0FBYyxDQUFlLG1CQUFtQixDQUFDLENBQUM7QUFFdkY7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZUFBZTtJQUM3QixPQUFPLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBQ25DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCDCqSAyMDI0IEFuZ3VsYXIgUHJpbWl0aXZlcy5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9uZy1wcmltaXRpdmVzL25nLXByaW1pdGl2ZXNcbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBDQyBCWS1ORCA0LjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBOZ3BGb2N1c1RyYXAgfSBmcm9tICcuL2ZvY3VzLXRyYXAuZGlyZWN0aXZlJztcblxuZXhwb3J0IGNvbnN0IE5ncEZvY3VzVHJhcFRva2VuID0gbmV3IEluamVjdGlvblRva2VuPE5ncEZvY3VzVHJhcD4oJ05ncEZvY3VzVHJhcFRva2VuJyk7XG5cbi8qKlxuICogSW5qZWN0IHRoZSBGb2N1c1RyYXAgZGlyZWN0aXZlIGluc3RhbmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RGb2N1c1RyYXAoKTogTmdwRm9jdXNUcmFwIHtcbiAgcmV0dXJuIGluamVjdChOZ3BGb2N1c1RyYXBUb2tlbik7XG59XG4iXX0=

package/esm2022/focus-trap/index.mjs

@@ -0,0 +1,10 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export { NgpFocusTrap } from './focus-trap/focus-trap.directive';
+export { NgpFocusTrapToken } from './focus-trap/focus-trap.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2ZvY3VzLXRyYXAvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIENDIEJZLU5EIDQuMCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICovXG5cbmV4cG9ydCB7IE5ncEZvY3VzVHJhcCB9IGZyb20gJy4vZm9jdXMtdHJhcC9mb2N1cy10cmFwLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBOZ3BGb2N1c1RyYXBUb2tlbiB9IGZyb20gJy4vZm9jdXMtdHJhcC9mb2N1cy10cmFwLnRva2VuJztcbiJdfQ==

package/esm2022/focus-trap/ng-primitives-focus-trap.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctcHJpbWl0aXZlcy1mb2N1cy10cmFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctcHJpbWl0aXZlcy9mb2N1cy10cmFwL3NyYy9uZy1wcmltaXRpdmVzLWZvY3VzLXRyYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/form-field/description/description.directive.mjs

@@ -15,20 +15,20 @@ export class NgpDescription {
         /**
          * Access the form field that the description is associated with.
          */
-        this.formField = injectFormField('NgpDescription');
+        this.formField = injectFormField();
         /**
          * The id of the description. If not provided, a unique id will be generated.
          */
         this.id = input(uniqueId('ngp-description'));
         effect(onCleanup => {
-            this.formField.addDescription(this.id());
-            onCleanup(() => this.formField.removeDescription(this.id()));
+            this.formField?.addDescription(this.id());
+            onCleanup(() => this.formField?.removeDescription(this.id()));
         }, { allowSignalWrites: true });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpDescription, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpDescription, isStandalone: true, selector: "[ngpDescription]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.id": "id()", "attr.data-invalid": "formField.invalid()", "attr.data-valid": "formField.valid()", "attr.data-touched": "formField.touched()", "attr.data-pristine": "formField.pristine()", "attr.data-dirty": "formField.dirty()", "attr.data-pending": "formField.pending()", "attr.data-disabled": "formField.disabled()" } }, providers: [{ provide: NgpDescriptionToken, useExisting: NgpDescription }], exportAs: ["ngpDescription"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDescription, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpDescription, isStandalone: true, selector: "[ngpDescription]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.id": "id()", "attr.data-invalid": "formField?.invalid()", "attr.data-valid": "formField?.valid()", "attr.data-touched": "formField?.touched()", "attr.data-pristine": "formField?.pristine()", "attr.data-dirty": "formField?.dirty()", "attr.data-pending": "formField?.pending()", "attr.data-disabled": "formField?.disabled()" } }, providers: [{ provide: NgpDescriptionToken, useExisting: NgpDescription }], exportAs: ["ngpDescription"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpDescription, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDescription, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
@@ -37,14 +37,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
                     providers: [{ provide: NgpDescriptionToken, useExisting: NgpDescription }],
                     host: {
                         '[attr.id]': 'id()',
-                        '[attr.data-invalid]': 'formField.invalid()',
-                        '[attr.data-valid]': 'formField.valid()',
-                        '[attr.data-touched]': 'formField.touched()',
-                        '[attr.data-pristine]': 'formField.pristine()',
-                        '[attr.data-dirty]': 'formField.dirty()',
-                        '[attr.data-pending]': 'formField.pending()',
-                        '[attr.data-disabled]': 'formField.disabled()',
+                        '[attr.data-invalid]': 'formField?.invalid()',
+                        '[attr.data-valid]': 'formField?.valid()',
+                        '[attr.data-touched]': 'formField?.touched()',
+                        '[attr.data-pristine]': 'formField?.pristine()',
+                        '[attr.data-dirty]': 'formField?.dirty()',
+                        '[attr.data-pending]': 'formField?.pending()',
+                        '[attr.data-disabled]': 'formField?.disabled()',
                     },
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form-field/error/error.directive.mjs

@@ -5,8 +5,8 @@
  * This source code is licensed under the CC BY-ND 4.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { Directive, computed, input, } from '@angular/core';
-import { uniqueId } from 'ng-primitives/utils';
+import { Directive, computed, input } from '@angular/core';
+import { onBooleanChange, uniqueId } from 'ng-primitives/utils';
 import { injectFormField } from '../form-field/form-field.token';
 import { NgpErrorToken } from './error.token';
 import * as i0 from "@angular/core";
@@ -15,7 +15,7 @@ export class NgpError {
         /**
          * Access the form field that the description is associated with.
          */
-        this.formField = injectFormField('NgpError');
+        this.formField = injectFormField();
         /**
          * The id of the error message. If not provided, a unique id will be generated.
          */
@@ -27,34 +27,32 @@ export class NgpError {
             alias: 'ngpErrorValidator',
         });
         /**
-         * Determine whether the validator associated with this error is failing.
+         * Determine if there is an error message.
          */
-        this.state = computed(() => {
-            const errors = this.formField.errors();
+        this.hasError = computed(() => {
+            const errors = this.formField?.errors() ?? [];
             const validator = this.validator();
-            // if there is no validator, then we mark as invalid when the control is invalid.
-            if (!validator) {
-                return null;
-            }
-            return validator && errors.includes(validator) ? 'fail' : 'pass';
+            return validator ? errors?.includes(validator) : errors?.length > 0;
         });
-    }
-    ngOnInit() {
-        this.formField.addDescription(this.id());
+        /**
+         * Determine whether the validator associated with this error is failing.
+         */
+        this.state = computed(() => (this.hasError() ? 'fail' : 'pass'));
+        // add or remove the error message when the error state changes
+        onBooleanChange(this.hasError, () => this.formField?.addDescription(this.id()), () => this.formField?.removeDescription(this.id()));
     }
     ngOnChanges(changes) {
         if ('id' in changes) {
-            this.formField.removeDescription(changes['id'].previousValue);
-            this.formField.addDescription(changes['id'].currentValue);
+            this.formField?.removeDescription(changes['id'].previousValue);
         }
     }
     ngOnDestroy() {
-        this.formField.removeDescription(this.id());
+        this.formField?.removeDescription(this.id());
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpError, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpError, isStandalone: true, selector: "[ngpError]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, validator: { classPropertyName: "validator", publicName: "ngpErrorValidator", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.id": "id()", "attr.data-invalid": "formField.invalid()", "attr.data-valid": "formField.valid()", "attr.data-touched": "formField.touched()", "attr.data-pristine": "formField.pristine()", "attr.data-dirty": "formField.dirty()", "attr.data-pending": "formField.pending()", "attr.data-disabled": "formField.disabled()", "attr.data-validator": "state()" } }, providers: [{ provide: NgpErrorToken, useExisting: NgpError }], exportAs: ["ngpError"], usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpError, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpError, isStandalone: true, selector: "[ngpError]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, validator: { classPropertyName: "validator", publicName: "ngpErrorValidator", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.id": "id()", "attr.data-invalid": "formField?.invalid()", "attr.data-valid": "formField?.valid()", "attr.data-touched": "formField?.touched()", "attr.data-pristine": "formField?.pristine()", "attr.data-dirty": "formField?.dirty()", "attr.data-pending": "formField?.pending()", "attr.data-disabled": "formField?.disabled()", "attr.data-validator": "state()" } }, providers: [{ provide: NgpErrorToken, useExisting: NgpError }], exportAs: ["ngpError"], usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpError, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpError, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
@@ -63,15 +61,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
                     providers: [{ provide: NgpErrorToken, useExisting: NgpError }],
                     host: {
                         '[attr.id]': 'id()',
-                        '[attr.data-invalid]': 'formField.invalid()',
-                        '[attr.data-valid]': 'formField.valid()',
-                        '[attr.data-touched]': 'formField.touched()',
-                        '[attr.data-pristine]': 'formField.pristine()',
-                        '[attr.data-dirty]': 'formField.dirty()',
-                        '[attr.data-pending]': 'formField.pending()',
-                        '[attr.data-disabled]': 'formField.disabled()',
+                        '[attr.data-invalid]': 'formField?.invalid()',
+                        '[attr.data-valid]': 'formField?.valid()',
+                        '[attr.data-touched]': 'formField?.touched()',
+                        '[attr.data-pristine]': 'formField?.pristine()',
+                        '[attr.data-dirty]': 'formField?.dirty()',
+                        '[attr.data-pending]': 'formField?.pending()',
+                        '[attr.data-disabled]': 'formField?.disabled()',
                         '[attr.data-validator]': 'state()',
                     },
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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