ng-primitives 0.0.5

package/esm2022/tooltip/tooltip-trigger/tooltip-trigger.directive.mjs

@@ -0,0 +1,190 @@
+import { DomPortalOutlet, TemplatePortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, Injector, ViewContainerRef, booleanAttribute, computed, effect, inject, input, model, numberAttribute, signal, } from '@angular/core';
+import { autoUpdate, computePosition, flip, offset, shift, } from '@floating-ui/dom';
+import { injectDisposables } from 'ng-primitives/utils';
+import { injectTooltipConfig } from '../config/tooltip.config';
+import { NgpTooltipTriggerToken, provideTooltipTrigger } from './tooltip-trigger.token';
+import * as i0 from "@angular/core";
+export class NgpTooltipTrigger {
+    constructor() {
+        /**
+         * Access the trigger element
+         */
+        this.trigger = inject((ElementRef));
+        /**
+         * Access the view container ref.
+         */
+        this.viewContainerRef = inject(ViewContainerRef);
+        /**
+         * Access the injector.
+         */
+        this.injector = inject(Injector);
+        /**
+         * Access the global tooltip configuration.
+         */
+        this.config = injectTooltipConfig();
+        /**
+         * Access the disposable utilities
+         */
+        this.disposables = injectDisposables();
+        /**
+         * Access the tooltip template ref.
+         */
+        this.tooltip = input.required({
+            alias: 'ngpTooltipTrigger',
+        });
+        /**
+         * The open state of the tooltip.
+         * @default false
+         */
+        this.open = model(false, {
+            alias: 'ngpTooltipTriggerOpen',
+        });
+        /**
+         * Define if the trigger should be disabled.
+         * @default false
+         */
+        this.disabled = input(false, {
+            alias: 'ngpTooltipTriggerDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Define the placement of the tooltip relative to the trigger.
+         * @default 'top'
+         */
+        this.placement = input(this.config.placement, {
+            alias: 'ngpTooltipTriggerPlacement',
+        });
+        /**
+         * Define the offset of the tooltip relative to the trigger.
+         * @default 0
+         */
+        this.offset = input(this.config.offset, {
+            alias: 'ngpTooltipTriggerOffset',
+            transform: numberAttribute,
+        });
+        /**
+         * Define the delay before the tooltip is displayed.
+         * @default 0
+         */
+        this.showDelay = input(this.config.showDelay, {
+            alias: 'ngpTooltipTriggerShowDelay',
+            transform: numberAttribute,
+        });
+        /**
+         * Define the delay before the tooltip is hidden.
+         * @default 0
+         */
+        this.hideDelay = input(this.config.hideDelay, {
+            alias: 'ngpTooltipTriggerHideDelay',
+            transform: numberAttribute,
+        });
+        /**
+         * Define whether the tooltip should flip when there is not enough space for the tooltip.
+         * @default true
+         */
+        this.flip = input(this.config.flip, {
+            alias: 'ngpTooltipTriggerFlip',
+            transform: booleanAttribute,
+        });
+        /**
+         * Define the container in which the tooltip should be attached.
+         * @default document.body
+         */
+        this.container = input(this.config.container, {
+            alias: 'ngpTooltipTriggerContainer',
+        });
+        /**
+         * Store the tooltip view ref.
+         */
+        this.viewRef = null;
+        /**
+         * Derive the tooltip middleware from the provided configuration.
+         */
+        this.middleware = computed(() => {
+            const middleware = [offset(this.offset()), shift()];
+            if (this.flip()) {
+                middleware.push(flip());
+            }
+            return middleware;
+        });
+        /**
+         * Store the computed position of the tooltip.
+         * @internal
+         */
+        this.position = signal({
+            x: 0,
+            y: 0,
+        });
+        /**
+         * Store the state of the tooltip.
+         * @internal
+         */
+        this.state = signal('closed');
+        // any time the open state changes then show or hide the tooltip
+        effect(() => (this.open() ? this.show() : this.hide()), { allowSignalWrites: true });
+    }
+    ngOnDestroy() {
+        this.destroyTooltip();
+    }
+    show() {
+        // if the trigger is disabled or the tooltip is already open then do not show the tooltip
+        if (this.disabled() || this.state() === 'open' || this.state() === 'opening') {
+            return;
+        }
+        this.state.set('opening');
+        this.disposables.setTimeout(() => this.createTooltip(), this.showDelay());
+    }
+    hide() {
+        // if the trigger is disabled or the tooltip is already closed then do not hide the tooltip
+        if (this.disabled() || this.state() === 'closed' || this.state() === 'closing') {
+            return;
+        }
+        this.state.set('closing');
+        this.disposables.setTimeout(() => this.destroyTooltip(), this.hideDelay());
+    }
+    createTooltip() {
+        const portal = new TemplatePortal(this.tooltip(), this.viewContainerRef, undefined, this.injector);
+        const domOutlet = new DomPortalOutlet(this.container(), undefined, undefined, Injector.create({
+            parent: this.injector,
+            providers: [provideTooltipTrigger(this)],
+        }));
+        this.viewRef = domOutlet.attach(portal);
+        this.viewRef.detectChanges();
+        const outletElement = this.viewRef.rootNodes[0];
+        this.dispose = autoUpdate(this.trigger.nativeElement, outletElement, async () => {
+            const position = await computePosition(this.trigger.nativeElement, outletElement, {
+                placement: this.placement(),
+                middleware: this.middleware(),
+            });
+            this.position.set({ x: position.x, y: position.y });
+        });
+        this.state.set('open');
+    }
+    destroyTooltip() {
+        this.viewRef?.destroy();
+        this.viewRef = null;
+        this.dispose?.();
+        this.state.set('closed');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpTooltipTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpTooltipTrigger, isStandalone: true, selector: "[ngpTooltipTrigger]", inputs: { tooltip: { classPropertyName: "tooltip", publicName: "ngpTooltipTrigger", isSignal: true, isRequired: true, transformFunction: null }, open: { classPropertyName: "open", publicName: "ngpTooltipTriggerOpen", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "ngpTooltipTriggerDisabled", isSignal: true, isRequired: false, transformFunction: null }, placement: { classPropertyName: "placement", publicName: "ngpTooltipTriggerPlacement", isSignal: true, isRequired: false, transformFunction: null }, offset: { classPropertyName: "offset", publicName: "ngpTooltipTriggerOffset", isSignal: true, isRequired: false, transformFunction: null }, showDelay: { classPropertyName: "showDelay", publicName: "ngpTooltipTriggerShowDelay", isSignal: true, isRequired: false, transformFunction: null }, hideDelay: { classPropertyName: "hideDelay", publicName: "ngpTooltipTriggerHideDelay", isSignal: true, isRequired: false, transformFunction: null }, flip: { classPropertyName: "flip", publicName: "ngpTooltipTriggerFlip", isSignal: true, isRequired: false, transformFunction: null }, container: { classPropertyName: "container", publicName: "ngpTooltipTriggerContainer", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { open: "ngpTooltipTriggerOpenChange" }, host: { listeners: { "mouseenter": "open.set(true)", "mouseleave": "open.set(false)", "focus": "open.set(true)", "blur": "open.set(false)" }, properties: { "attr.data-state": "state()", "attr.data-disabled": "disabled()" } }, providers: [{ provide: NgpTooltipTriggerToken, useExisting: NgpTooltipTrigger }], exportAs: ["ngpTooltipTrigger"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpTooltipTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpTooltipTrigger]',
+                    exportAs: 'ngpTooltipTrigger',
+                    providers: [{ provide: NgpTooltipTriggerToken, useExisting: NgpTooltipTrigger }],
+                    host: {
+                        '[attr.data-state]': 'state()',
+                        '[attr.data-disabled]': 'disabled()',
+                        '(mouseenter)': 'open.set(true)',
+                        '(mouseleave)': 'open.set(false)',
+                        '(focus)': 'open.set(true)',
+                        '(blur)': 'open.set(false)',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip-trigger.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/tooltip/src/tooltip-trigger/tooltip-trigger.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 { BooleanInput, NumberInput } from '@angular/cdk/coercion';\nimport { DomPortalOutlet, TemplatePortal } from '@angular/cdk/portal';\nimport {\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  Injector,\n  OnDestroy,\n  TemplateRef,\n  ViewContainerRef,\n  booleanAttribute,\n  computed,\n  effect,\n  inject,\n  input,\n  model,\n  numberAttribute,\n  signal,\n} from '@angular/core';\nimport {\n  Middleware,\n  Placement,\n  autoUpdate,\n  computePosition,\n  flip,\n  offset,\n  shift,\n} from '@floating-ui/dom';\nimport { injectDisposables } from 'ng-primitives/utils';\nimport { injectTooltipConfig } from '../config/tooltip.config';\nimport { NgpTooltipTriggerToken, provideTooltipTrigger } from './tooltip-trigger.token';\n\n@Directive({\n  standalone: true,\n  selector: '[ngpTooltipTrigger]',\n  exportAs: 'ngpTooltipTrigger',\n  providers: [{ provide: NgpTooltipTriggerToken, useExisting: NgpTooltipTrigger }],\n  host: {\n    '[attr.data-state]': 'state()',\n    '[attr.data-disabled]': 'disabled()',\n    '(mouseenter)': 'open.set(true)',\n    '(mouseleave)': 'open.set(false)',\n    '(focus)': 'open.set(true)',\n    '(blur)': 'open.set(false)',\n  },\n})\nexport class NgpTooltipTrigger implements OnDestroy {\n  /**\n   * Access the trigger element\n   */\n  private readonly trigger = inject(ElementRef<HTMLElement>);\n\n  /**\n   * Access the view container ref.\n   */\n  private readonly viewContainerRef = inject(ViewContainerRef);\n\n  /**\n   * Access the injector.\n   */\n  private readonly injector = inject(Injector);\n\n  /**\n   * Access the global tooltip configuration.\n   */\n  private readonly config = injectTooltipConfig();\n\n  /**\n   * Access the disposable utilities\n   */\n  private readonly disposables = injectDisposables();\n\n  /**\n   * Access the tooltip template ref.\n   */\n  readonly tooltip = input.required<TemplateRef<void>>({\n    alias: 'ngpTooltipTrigger',\n  });\n\n  /**\n   * The open state of the tooltip.\n   * @default false\n   */\n  readonly open = model<boolean>(false, {\n    alias: 'ngpTooltipTriggerOpen',\n  });\n\n  /**\n   * Define if the trigger should be disabled.\n   * @default false\n   */\n  readonly disabled = input<boolean, BooleanInput>(false, {\n    alias: 'ngpTooltipTriggerDisabled',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Define the placement of the tooltip relative to the trigger.\n   * @default 'top'\n   */\n  readonly placement = input<Placement>(this.config.placement, {\n    alias: 'ngpTooltipTriggerPlacement',\n  });\n\n  /**\n   * Define the offset of the tooltip relative to the trigger.\n   * @default 0\n   */\n  readonly offset = input<number, NumberInput>(this.config.offset, {\n    alias: 'ngpTooltipTriggerOffset',\n    transform: numberAttribute,\n  });\n\n  /**\n   * Define the delay before the tooltip is displayed.\n   * @default 0\n   */\n  readonly showDelay = input<number, NumberInput>(this.config.showDelay, {\n    alias: 'ngpTooltipTriggerShowDelay',\n    transform: numberAttribute,\n  });\n\n  /**\n   * Define the delay before the tooltip is hidden.\n   * @default 0\n   */\n  readonly hideDelay = input<number, NumberInput>(this.config.hideDelay, {\n    alias: 'ngpTooltipTriggerHideDelay',\n    transform: numberAttribute,\n  });\n\n  /**\n   * Define whether the tooltip should flip when there is not enough space for the tooltip.\n   * @default true\n   */\n  readonly flip = input<boolean, BooleanInput>(this.config.flip, {\n    alias: 'ngpTooltipTriggerFlip',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Define the container in which the tooltip should be attached.\n   * @default document.body\n   */\n  readonly container = input<HTMLElement>(this.config.container, {\n    alias: 'ngpTooltipTriggerContainer',\n  });\n\n  /**\n   * Store the tooltip view ref.\n   */\n  private viewRef: EmbeddedViewRef<void> | null = null;\n\n  /**\n   * Derive the tooltip middleware from the provided configuration.\n   */\n  private readonly middleware = computed(() => {\n    const middleware: Middleware[] = [offset(this.offset()), shift()];\n\n    if (this.flip()) {\n      middleware.push(flip());\n    }\n\n    return middleware;\n  });\n\n  /**\n   * Store the computed position of the tooltip.\n   * @internal\n   */\n  readonly position = signal<{ x: number; y: number }>({\n    x: 0,\n    y: 0,\n  });\n\n  /**\n   * Store the state of the tooltip.\n   * @internal\n   */\n  readonly state = signal<TooltipState>('closed');\n\n  /**\n   * The dispose function to stop computing the position of the tooltip.\n   */\n  private dispose?: () => void;\n\n  constructor() {\n    // any time the open state changes then show or hide the tooltip\n    effect(() => (this.open() ? this.show() : this.hide()), { allowSignalWrites: true });\n  }\n\n  ngOnDestroy(): void {\n    this.destroyTooltip();\n  }\n\n  private show(): void {\n    // if the trigger is disabled or the tooltip is already open then do not show the tooltip\n    if (this.disabled() || this.state() === 'open' || this.state() === 'opening') {\n      return;\n    }\n\n    this.state.set('opening');\n    this.disposables.setTimeout(() => this.createTooltip(), this.showDelay());\n  }\n\n  private hide(): void {\n    // if the trigger is disabled or the tooltip is already closed then do not hide the tooltip\n    if (this.disabled() || this.state() === 'closed' || this.state() === 'closing') {\n      return;\n    }\n\n    this.state.set('closing');\n    this.disposables.setTimeout(() => this.destroyTooltip(), this.hideDelay());\n  }\n\n  private createTooltip(): void {\n    const portal = new TemplatePortal(\n      this.tooltip(),\n      this.viewContainerRef,\n      undefined,\n      this.injector,\n    );\n\n    const domOutlet = new DomPortalOutlet(\n      this.container(),\n      undefined,\n      undefined,\n      Injector.create({\n        parent: this.injector,\n        providers: [provideTooltipTrigger(this)],\n      }),\n    );\n\n    this.viewRef = domOutlet.attach(portal);\n    this.viewRef.detectChanges();\n\n    const outletElement = this.viewRef.rootNodes[0];\n\n    this.dispose = autoUpdate(this.trigger.nativeElement, outletElement, async () => {\n      const position = await computePosition(this.trigger.nativeElement, outletElement, {\n        placement: this.placement(),\n        middleware: this.middleware(),\n      });\n\n      this.position.set({ x: position.x, y: position.y });\n    });\n\n    this.state.set('open');\n  }\n\n  private destroyTooltip(): void {\n    this.viewRef?.destroy();\n    this.viewRef = null;\n    this.dispose?.();\n    this.state.set('closed');\n  }\n}\n\nexport type TooltipState = 'closed' | 'opening' | 'open' | 'closing';\n"]}

package/esm2022/tooltip/tooltip-trigger/tooltip-trigger.token.mjs

@@ -0,0 +1,23 @@
+/**
+ * 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 NgpTooltipTriggerToken = new InjectionToken('NgpTooltipTriggerToken');
+/**
+ * Inject the TooltipTrigger directive instance
+ */
+export function injectTooltipTrigger() {
+    return inject(NgpTooltipTriggerToken);
+}
+/**
+ * Provides the TooltipTrigger directive instance
+ * @param trigger
+ */
+export function provideTooltipTrigger(trigger) {
+    return { provide: NgpTooltipTriggerToken, useValue: trigger };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC10cmlnZ2VyLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctcHJpbWl0aXZlcy90b29sdGlwL3NyYy90b29sdGlwLXRyaWdnZXIvdG9vbHRpcC10cmlnZ2VyLnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUNILE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR3ZELE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLElBQUksY0FBYyxDQUN0RCx3QkFBd0IsQ0FDekIsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQjtJQUNsQyxPQUFPLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0FBQ3hDLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsT0FBMEI7SUFDOUQsT0FBTyxFQUFFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFDaEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIENDIEJZLU5EIDQuMCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICovXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7IE5ncFRvb2x0aXBUcmlnZ2VyIH0gZnJvbSAnLi90b29sdGlwLXRyaWdnZXIuZGlyZWN0aXZlJztcblxuZXhwb3J0IGNvbnN0IE5ncFRvb2x0aXBUcmlnZ2VyVG9rZW4gPSBuZXcgSW5qZWN0aW9uVG9rZW48TmdwVG9vbHRpcFRyaWdnZXI+KFxuICAnTmdwVG9vbHRpcFRyaWdnZXJUb2tlbicsXG4pO1xuXG4vKipcbiAqIEluamVjdCB0aGUgVG9vbHRpcFRyaWdnZXIgZGlyZWN0aXZlIGluc3RhbmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RUb29sdGlwVHJpZ2dlcigpOiBOZ3BUb29sdGlwVHJpZ2dlciB7XG4gIHJldHVybiBpbmplY3QoTmdwVG9vbHRpcFRyaWdnZXJUb2tlbik7XG59XG5cbi8qKlxuICogUHJvdmlkZXMgdGhlIFRvb2x0aXBUcmlnZ2VyIGRpcmVjdGl2ZSBpbnN0YW5jZVxuICogQHBhcmFtIHRyaWdnZXJcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVUb29sdGlwVHJpZ2dlcih0cmlnZ2VyOiBOZ3BUb29sdGlwVHJpZ2dlcikge1xuICByZXR1cm4geyBwcm92aWRlOiBOZ3BUb29sdGlwVHJpZ2dlclRva2VuLCB1c2VWYWx1ZTogdHJpZ2dlciB9O1xufVxuIl19

package/esm2022/utils/helpers/disposables.mjs

@@ -0,0 +1,72 @@
+/**
+ * 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 { DestroyRef, inject } from '@angular/core';
+/**
+ * Disposable functions are a way to manage timers, intervals, and event listeners
+ * that should be cleared when a component is destroyed.
+ *
+ * This is heavily inspired by Headless UI disposables:
+ * https://github.com/tailwindlabs/headlessui/blob/main/packages/%40headlessui-react/src/utils/disposables.ts
+ */
+export function injectDisposables() {
+    const destroyRef = inject(DestroyRef);
+    return {
+        /**
+         * Set a timeout that will be cleared when the component is destroyed.
+         * @param callback The callback to execute
+         * @param delay The delay before the callback is executed
+         * @returns A function to clear the timeout
+         */
+        setTimeout: (callback, delay) => {
+            const id = setTimeout(callback, delay);
+            const cleanup = () => clearTimeout(id);
+            destroyRef.onDestroy(cleanup);
+            return cleanup;
+        },
+        /**
+         * Set an interval that will be cleared when the component is destroyed.
+         * @param callback The callback to execute
+         * @param delay The delay before the callback is executed
+         * @param target
+         * @param type
+         * @param listener
+         * @param options
+         * @returns A function to clear the interval
+         */
+        addEventListener: (target, type, listener, options) => {
+            target.addEventListener(type, listener, options);
+            const cleanup = () => target.removeEventListener(type, listener, options);
+            destroyRef.onDestroy(cleanup);
+            return cleanup;
+        },
+        /**
+         * Set an interval that will be cleared when the component is destroyed.
+         * @param callback The callback to execute
+         * @param delay The delay before the callback is executed
+         * @returns A function to clear the interval
+         */
+        setInterval: (callback, delay) => {
+            const id = setInterval(callback, delay);
+            const cleanup = () => clearInterval(id);
+            destroyRef.onDestroy(cleanup);
+            return cleanup;
+        },
+        /**
+         * Set a requestAnimationFrame that will be cleared when the component is destroyed.
+         * @param callback The callback to execute
+         * @returns A function to clear the requestAnimationFrame
+         */
+        requestAnimationFrame: (callback) => {
+            const id = requestAnimationFrame(callback);
+            const cleanup = () => cancelAnimationFrame(id);
+            destroyRef.onDestroy(cleanup);
+            return cleanup;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/helpers/focus-manager.mjs

@@ -0,0 +1,28 @@
+import { coerceElement } from '@angular/cdk/coercion';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FocusManager {
+    focus(element, origin = 'program') {
+        element = coerceElement(element);
+        switch (origin) {
+            case 'keyboard':
+                // trigger the focus-visible state for keyboard users
+                element.contentEditable = 'true';
+                element.focus({ preventScroll: true });
+                element.contentEditable = 'false';
+                break;
+            default:
+                element.focus();
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FocusManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FocusManager, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FocusManager, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/helpers/unique-id.mjs

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+/**
+ * Store a map of unique ids for elements so that there are no collisions.
+ */
+const uniqueIdMap = new Map();
+/**
+ * Generate a unique id for an element
+ * @param prefix - The prefix to use for the id
+ * @returns The generated id
+ */
+export function uniqueId(prefix) {
+    const id = uniqueIdMap.get(prefix) ?? 0;
+    uniqueIdMap.set(prefix, id + 1);
+    return `${prefix}-${id}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlLWlkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctcHJpbWl0aXZlcy91dGlscy9zcmMvaGVscGVycy91bmlxdWUtaWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7O0dBRUc7QUFDSCxNQUFNLFdBQVcsR0FBRyxJQUFJLEdBQUcsRUFBa0IsQ0FBQztBQUU5Qzs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FBQyxNQUFjO0lBQ3JDLE1BQU0sRUFBRSxHQUFHLFdBQVcsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3hDLFdBQVcsQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNoQyxPQUFPLEdBQUcsTUFBTSxJQUFJLEVBQUUsRUFBRSxDQUFDO0FBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCDCqSAyMDI0IEFuZ3VsYXIgUHJpbWl0aXZlcy5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9uZy1wcmltaXRpdmVzL25nLXByaW1pdGl2ZXNcbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBDQyBCWS1ORCA0LjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuXG4vKipcbiAqIFN0b3JlIGEgbWFwIG9mIHVuaXF1ZSBpZHMgZm9yIGVsZW1lbnRzIHNvIHRoYXQgdGhlcmUgYXJlIG5vIGNvbGxpc2lvbnMuXG4gKi9cbmNvbnN0IHVuaXF1ZUlkTWFwID0gbmV3IE1hcDxzdHJpbmcsIG51bWJlcj4oKTtcblxuLyoqXG4gKiBHZW5lcmF0ZSBhIHVuaXF1ZSBpZCBmb3IgYW4gZWxlbWVudFxuICogQHBhcmFtIHByZWZpeCAtIFRoZSBwcmVmaXggdG8gdXNlIGZvciB0aGUgaWRcbiAqIEByZXR1cm5zIFRoZSBnZW5lcmF0ZWQgaWRcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVuaXF1ZUlkKHByZWZpeDogc3RyaW5nKTogc3RyaW5nIHtcbiAgY29uc3QgaWQgPSB1bmlxdWVJZE1hcC5nZXQocHJlZml4KSA/PyAwO1xuICB1bmlxdWVJZE1hcC5zZXQocHJlZml4LCBpZCArIDEpO1xuICByZXR1cm4gYCR7cHJlZml4fS0ke2lkfWA7XG59XG4iXX0=

package/esm2022/utils/hover/hover.directive.mjs

@@ -0,0 +1,183 @@
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { Directive, HostListener, Injectable, PLATFORM_ID, booleanAttribute, inject, input, output, signal, } from '@angular/core';
+import { NgpHoverToken } from './hover.token';
+import * as i0 from "@angular/core";
+/**
+ * We use a service here as this value is a singleton
+ * and allows us to register the dom events once.
+ */
+class GlobalPointerEvents {
+    constructor() {
+        /**
+         * Whether global mouse events should be ignored.
+         */
+        this.ignoreEmulatedMouseEvents = false;
+        /**
+         * Access the document.
+         */
+        this.document = inject(DOCUMENT);
+        /**
+         * Determine the platform id.
+         */
+        this.platformId = inject(PLATFORM_ID);
+        // we only want to setup events on the client
+        if (isPlatformBrowser(this.platformId)) {
+            this.setupGlobalTouchEvents();
+        }
+    }
+    setupGlobalTouchEvents() {
+        this.document.addEventListener('pointerup', this.handleGlobalPointerEvent.bind(this));
+        this.document.addEventListener('touchend', this.setGlobalIgnoreEmulatedMouseEvents.bind(this));
+    }
+    setGlobalIgnoreEmulatedMouseEvents() {
+        this.ignoreEmulatedMouseEvents = true;
+        // Clear globalIgnoreEmulatedMouseEvents after a short timeout. iOS fires onPointerEnter
+        // with pointerType="mouse" immediately after onPointerUp and before onFocus. On other
+        // devices that don't have this quirk, we don't want to ignore a mouse hover sometime in
+        // the distant future because a user previously touched the element.
+        setTimeout(() => (this.ignoreEmulatedMouseEvents = false), 50);
+    }
+    handleGlobalPointerEvent(event) {
+        if (event.pointerType === 'touch') {
+            this.setGlobalIgnoreEmulatedMouseEvents();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GlobalPointerEvents, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GlobalPointerEvents, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GlobalPointerEvents, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+/**
+ * A directive for normalizing hover events across the different browsers and devices.
+ *
+ * This is an Angular port of the useHover hook from
+ * react-aria: https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/interactions/src/useHover.ts
+ */
+export class NgpHover {
+    constructor() {
+        /**
+         * Access the global pointer events handler.
+         */
+        this.globalPointerEvents = inject(GlobalPointerEvents);
+        /**
+         * Whether hoving should be disabled.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpHoverDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Store the current hover state.
+         */
+        this.hovered = signal(false);
+        /**
+         * Whether this element should ignore emulated mouse events.
+         */
+        this.ignoreEmulatedMouseEvents = false;
+        /**
+         * Emit an event when hovering starts.
+         */
+        this.hoverStart = output({ alias: 'ngpHoverStart' });
+        /**
+         * Emit an event when hovering ends.
+         */
+        this.hoverEnd = output({ alias: 'ngpHoverEnd' });
+        /**
+         * Emit an event when the hover state changes.
+         */
+        this.hoverChange = output({ alias: 'ngpHoverChange' });
+    }
+    ngOnChanges(changes) {
+        if ('disabled' in changes) {
+            // if the component is suddenly disabled and is currently hovered
+            // switch to the unhovered state.
+            if (changes['disabled'].currentValue === true) {
+                this.onHoverEnd('mouse');
+            }
+        }
+    }
+    /**
+     * Trigger the hover start events.
+     */
+    onHoverStart(event, pointerType) {
+        if (this.disabled() ||
+            pointerType === 'touch' ||
+            this.hovered() ||
+            !event.currentTarget?.contains(event.target)) {
+            return;
+        }
+        this.hovered.set(true);
+        this.hoverStart.emit();
+        this.hoverChange.emit(true);
+    }
+    /**
+     * Trigger the hover end events.
+     */
+    onHoverEnd(pointerType) {
+        if (pointerType === 'touch' || !this.hovered()) {
+            return;
+        }
+        this.hovered.set(false);
+        this.hoverEnd.emit();
+        this.hoverChange.emit(false);
+    }
+    onPointerEnter(event) {
+        if (this.globalPointerEvents.ignoreEmulatedMouseEvents && event.pointerType === 'mouse') {
+            return;
+        }
+        this.onHoverStart(event, event.pointerType);
+    }
+    onPointerLeave(event) {
+        if (!this.disabled() && event.currentTarget?.contains(event.target)) {
+            this.onHoverEnd(event.pointerType);
+        }
+    }
+    onTouchStart() {
+        this.ignoreEmulatedMouseEvents = true;
+    }
+    onMouseEnter(event) {
+        if (!this.ignoreEmulatedMouseEvents && !this.globalPointerEvents.ignoreEmulatedMouseEvents) {
+            this.onHoverStart(event, 'mouse');
+        }
+        this.ignoreEmulatedMouseEvents = false;
+    }
+    onMouseLeave(event) {
+        if (!this.disabled() && event.currentTarget?.contains(event.target)) {
+            this.onHoverEnd('mouse');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpHover, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpHover, isStandalone: true, selector: "[ngpHover]", inputs: { disabled: { classPropertyName: "disabled", publicName: "ngpHoverDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { hoverStart: "ngpHoverStart", hoverEnd: "ngpHoverEnd", hoverChange: "ngpHoverChange" }, host: { listeners: { "pointerenter": "onPointerEnter($event)", "pointerleave": "onPointerLeave($event)", "touchstart": "onTouchStart()", "mouseenter": "onMouseEnter($event)", "mouseleave": "onMouseLeave($event)" }, properties: { "attr.data-hover": "hovered()" } }, providers: [{ provide: NgpHoverToken, useExisting: NgpHover }], exportAs: ["ngpHover"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpHover, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpHover]',
+                    exportAs: 'ngpHover',
+                    providers: [{ provide: NgpHoverToken, useExisting: NgpHover }],
+                    host: {
+                        '[attr.data-hover]': 'hovered()',
+                    },
+                }]
+        }], propDecorators: { onPointerEnter: [{
+                type: HostListener,
+                args: ['pointerenter', ['$event']]
+            }], onPointerLeave: [{
+                type: HostListener,
+                args: ['pointerleave', ['$event']]
+            }], onTouchStart: [{
+                type: HostListener,
+                args: ['touchstart']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter', ['$event']]
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hover.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/utils/src/hover/hover.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 type { BooleanInput } from '@angular/cdk/coercion';\nimport { DOCUMENT, isPlatformBrowser } from '@angular/common';\nimport {\n  Directive,\n  HostListener,\n  Injectable,\n  OnChanges,\n  PLATFORM_ID,\n  SimpleChanges,\n  booleanAttribute,\n  inject,\n  input,\n  output,\n  signal,\n} from '@angular/core';\nimport { NgpHoverToken } from './hover.token';\n\n/**\n * We use a service here as this value is a singleton\n * and allows us to register the dom events once.\n */\n@Injectable({\n  providedIn: 'root',\n})\nclass GlobalPointerEvents {\n  /**\n   * Whether global mouse events should be ignored.\n   */\n  ignoreEmulatedMouseEvents: boolean = false;\n\n  /**\n   * Access the document.\n   */\n  private readonly document = inject(DOCUMENT);\n\n  /**\n   * Determine the platform id.\n   */\n  private readonly platformId = inject(PLATFORM_ID);\n\n  constructor() {\n    // we only want to setup events on the client\n    if (isPlatformBrowser(this.platformId)) {\n      this.setupGlobalTouchEvents();\n    }\n  }\n\n  private setupGlobalTouchEvents(): void {\n    this.document.addEventListener('pointerup', this.handleGlobalPointerEvent.bind(this));\n    this.document.addEventListener('touchend', this.setGlobalIgnoreEmulatedMouseEvents.bind(this));\n  }\n\n  private setGlobalIgnoreEmulatedMouseEvents(): void {\n    this.ignoreEmulatedMouseEvents = true;\n    // Clear globalIgnoreEmulatedMouseEvents after a short timeout. iOS fires onPointerEnter\n    // with pointerType=\"mouse\" immediately after onPointerUp and before onFocus. On other\n    // devices that don't have this quirk, we don't want to ignore a mouse hover sometime in\n    // the distant future because a user previously touched the element.\n    setTimeout(() => (this.ignoreEmulatedMouseEvents = false), 50);\n  }\n\n  private handleGlobalPointerEvent(event: PointerEvent): void {\n    if (event.pointerType === 'touch') {\n      this.setGlobalIgnoreEmulatedMouseEvents();\n    }\n  }\n}\n\n/**\n * A directive for normalizing hover events across the different browsers and devices.\n *\n * This is an Angular port of the useHover hook from\n * react-aria: https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/interactions/src/useHover.ts\n */\n@Directive({\n  standalone: true,\n  selector: '[ngpHover]',\n  exportAs: 'ngpHover',\n  providers: [{ provide: NgpHoverToken, useExisting: NgpHover }],\n  host: {\n    '[attr.data-hover]': 'hovered()',\n  },\n})\nexport class NgpHover implements OnChanges {\n  /**\n   * Access the global pointer events handler.\n   */\n  private readonly globalPointerEvents = inject(GlobalPointerEvents);\n\n  /**\n   * Whether hoving should be disabled.\n   */\n  readonly disabled = input<boolean, BooleanInput>(false, {\n    alias: 'ngpHoverDisabled',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Store the current hover state.\n   */\n  protected hovered = signal<boolean>(false);\n\n  /**\n   * Whether this element should ignore emulated mouse events.\n   */\n  private ignoreEmulatedMouseEvents: boolean = false;\n\n  /**\n   * Emit an event when hovering starts.\n   */\n  readonly hoverStart = output<void>({ alias: 'ngpHoverStart' });\n\n  /**\n   * Emit an event when hovering ends.\n   */\n  readonly hoverEnd = output<void>({ alias: 'ngpHoverEnd' });\n\n  /**\n   * Emit an event when the hover state changes.\n   */\n  readonly hoverChange = output<boolean>({ alias: 'ngpHoverChange' });\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('disabled' in changes) {\n      // if the component is suddenly disabled and is currently hovered\n      // switch to the unhovered state.\n      if (changes['disabled'].currentValue === true) {\n        this.onHoverEnd('mouse');\n      }\n    }\n  }\n\n  /**\n   * Trigger the hover start events.\n   */\n  private onHoverStart(event: Event, pointerType: string): void {\n    if (\n      this.disabled() ||\n      pointerType === 'touch' ||\n      this.hovered() ||\n      !(event.currentTarget as Element)?.contains(event.target as Element)\n    ) {\n      return;\n    }\n\n    this.hovered.set(true);\n    this.hoverStart.emit();\n    this.hoverChange.emit(true);\n  }\n\n  /**\n   * Trigger the hover end events.\n   */\n  private onHoverEnd(pointerType: string): void {\n    if (pointerType === 'touch' || !this.hovered()) {\n      return;\n    }\n\n    this.hovered.set(false);\n    this.hoverEnd.emit();\n    this.hoverChange.emit(false);\n  }\n\n  @HostListener('pointerenter', ['$event'])\n  protected onPointerEnter(event: PointerEvent): void {\n    if (this.globalPointerEvents.ignoreEmulatedMouseEvents && event.pointerType === 'mouse') {\n      return;\n    }\n\n    this.onHoverStart(event, event.pointerType);\n  }\n\n  @HostListener('pointerleave', ['$event'])\n  protected onPointerLeave(event: PointerEvent): void {\n    if (!this.disabled() && (event.currentTarget as Element)?.contains(event.target as Element)) {\n      this.onHoverEnd(event.pointerType);\n    }\n  }\n\n  @HostListener('touchstart')\n  protected onTouchStart(): void {\n    this.ignoreEmulatedMouseEvents = true;\n  }\n\n  @HostListener('mouseenter', ['$event'])\n  protected onMouseEnter(event: MouseEvent): void {\n    if (!this.ignoreEmulatedMouseEvents && !this.globalPointerEvents.ignoreEmulatedMouseEvents) {\n      this.onHoverStart(event, 'mouse');\n    }\n\n    this.ignoreEmulatedMouseEvents = false;\n  }\n\n  @HostListener('mouseleave', ['$event'])\n  protected onMouseLeave(event: MouseEvent): void {\n    if (!this.disabled() && (event.currentTarget as Element)?.contains(event.target as Element)) {\n      this.onHoverEnd('mouse');\n    }\n  }\n}\n"]}

package/esm2022/utils/hover/hover.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 NgpHoverToken = new InjectionToken('NgpHoverToken');
+/**
+ * Inject the Hover directive instance
+ */
+export function injectHover() {
+    return inject(NgpHoverToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG92ZXIudG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL3V0aWxzL3NyYy9ob3Zlci9ob3Zlci50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUd2RCxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsSUFBSSxjQUFjLENBQVcsZUFBZSxDQUFDLENBQUM7QUFFM0U7O0dBRUc7QUFDSCxNQUFNLFVBQVUsV0FBVztJQUN6QixPQUFPLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgwqkgMjAyNCBBbmd1bGFyIFByaW1pdGl2ZXMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vbmctcHJpbWl0aXZlcy9uZy1wcmltaXRpdmVzXG4gKlxuICogVGhpcyBzb3VyY2UgY29kZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQ0MgQlktTkQgNC4wIGxpY2Vuc2UgZm91bmQgaW4gdGhlXG4gKiBMSUNFTlNFIGZpbGUgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgc291cmNlIHRyZWUuXG4gKi9cbmltcG9ydCB7IEluamVjdGlvblRva2VuLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgTmdwSG92ZXIgfSBmcm9tICcuL2hvdmVyLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBOZ3BIb3ZlclRva2VuID0gbmV3IEluamVjdGlvblRva2VuPE5ncEhvdmVyPignTmdwSG92ZXJUb2tlbicpO1xuXG4vKipcbiAqIEluamVjdCB0aGUgSG92ZXIgZGlyZWN0aXZlIGluc3RhbmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RIb3ZlcigpOiBOZ3BIb3ZlciB7XG4gIHJldHVybiBpbmplY3QoTmdwSG92ZXJUb2tlbik7XG59XG4iXX0=

package/esm2022/utils/index.mjs

@@ -0,0 +1,14 @@
+/**
+ * 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 { injectDisposables } from './helpers/disposables';
+export { FocusManager } from './helpers/focus-manager';
+export { uniqueId } from './helpers/unique-id';
+export { NgpHover } from './hover/hover.directive';
+export { NgpHoverToken } from './hover/hover.token';
+export { injectDimensions } from './ui/dimensions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL3V0aWxzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCDCqSAyMDI0IEFuZ3VsYXIgUHJpbWl0aXZlcy5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9uZy1wcmltaXRpdmVzL25nLXByaW1pdGl2ZXNcbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBDQyBCWS1ORCA0LjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuXG5leHBvcnQgeyBpbmplY3REaXNwb3NhYmxlcyB9IGZyb20gJy4vaGVscGVycy9kaXNwb3NhYmxlcyc7XG5leHBvcnQgeyBGb2N1c01hbmFnZXIgfSBmcm9tICcuL2hlbHBlcnMvZm9jdXMtbWFuYWdlcic7XG5leHBvcnQgeyB1bmlxdWVJZCB9IGZyb20gJy4vaGVscGVycy91bmlxdWUtaWQnO1xuZXhwb3J0IHsgTmdwSG92ZXIgfSBmcm9tICcuL2hvdmVyL2hvdmVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBOZ3BIb3ZlclRva2VuIH0gZnJvbSAnLi9ob3Zlci9ob3Zlci50b2tlbic7XG5leHBvcnQgeyBpbmplY3REaW1lbnNpb25zIH0gZnJvbSAnLi91aS9kaW1lbnNpb25zJztcbiJdfQ==

package/esm2022/utils/ng-primitives-utils.mjs

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