ng-primitives 0.0.7 → 0.2.0

package/esm2022/interactions/hover/hover.directive.mjs

@@ -1,5 +1,6 @@
 import { DOCUMENT, isPlatformBrowser } from '@angular/common';
 import { Directive, HostListener, Injectable, PLATFORM_ID, booleanAttribute, inject, input, output, signal, } from '@angular/core';
+import { injectDisabled } from 'ng-primitives/internal';
 import { NgpHoverToken } from './hover.token';
 import * as i0 from "@angular/core";
 /**
@@ -42,10 +43,10 @@ class GlobalPointerEvents {
             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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: GlobalPointerEvents, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: GlobalPointerEvents, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GlobalPointerEvents, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: GlobalPointerEvents, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -70,6 +71,10 @@ export class NgpHover {
             alias: 'ngpHoverDisabled',
             transform: booleanAttribute,
         });
+        /**
+         * Access the disabled state from any parent.
+         */
+        this.isDisabled = injectDisabled(this.disabled);
         /**
          * Store the current hover state.
          */
@@ -89,7 +94,7 @@ export class NgpHover {
         /**
          * Emit an event when the hover state changes.
          */
-        this.hoverChange = output({ alias: 'ngpHoverChange' });
+        this.hoverChange = output({ alias: 'ngpHover' });
     }
     ngOnChanges(changes) {
         if ('disabled' in changes) {
@@ -106,7 +111,7 @@ export class NgpHover {
      * @param pointerType
      */
     onHoverStart(event, pointerType) {
-        if (this.disabled() ||
+        if (this.isDisabled() ||
             pointerType === 'touch' ||
             this.hovered() ||
             !event.currentTarget?.contains(event.target)) {
@@ -135,7 +140,7 @@ export class NgpHover {
         this.onHoverStart(event, event.pointerType);
     }
     onPointerLeave(event) {
-        if (!this.disabled() && event.currentTarget?.contains(event.target)) {
+        if (!this.isDisabled() && event.currentTarget?.contains(event.target)) {
             this.onHoverEnd(event.pointerType);
         }
     }
@@ -149,14 +154,14 @@ export class NgpHover {
         this.ignoreEmulatedMouseEvents = false;
     }
     onMouseLeave(event) {
-        if (!this.disabled() && event.currentTarget?.contains(event.target)) {
+        if (!this.isDisabled() && 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 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpHover, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpHover, isStandalone: true, selector: "[ngpHover]", inputs: { disabled: { classPropertyName: "disabled", publicName: "ngpHoverDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { hoverStart: "ngpHoverStart", hoverEnd: "ngpHoverEnd", hoverChange: "ngpHover" }, 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: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpHover, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
@@ -183,4 +188,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
                 type: HostListener,
                 args: ['mouseleave', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hover.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/interactions/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   * @param event\n   * @param pointerType\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   * @param pointerType\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hover.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/interactions/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 { injectDisabled } from 'ng-primitives/internal';\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   * Access the disabled state from any parent.\n   */\n  private readonly isDisabled = injectDisabled(this.disabled);\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: 'ngpHover' });\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   * @param event\n   * @param pointerType\n   */\n  private onHoverStart(event: Event, pointerType: string): void {\n    if (\n      this.isDisabled() ||\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   * @param pointerType\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.isDisabled() && (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.isDisabled() && (event.currentTarget as Element)?.contains(event.target as Element)) {\n      this.onHoverEnd('mouse');\n    }\n  }\n}\n"]}

package/esm2022/interactions/index.mjs

@@ -11,4 +11,8 @@ export { NgpFocus } from './focus/focus.directive';
 export { NgpFocusToken } from './focus/focus.token';
 export { NgpFocusVisible } from './focus-visible/focus-visible.directive';
 export { NgpFocusVisibleToken } from './focus-visible/focus-visible.token';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2ludGVyYWN0aW9ucy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsV0FBVyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDakUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDMUUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0scUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCDCqSAyMDI0IEFuZ3VsYXIgUHJpbWl0aXZlcy5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9uZy1wcmltaXRpdmVzL25nLXByaW1pdGl2ZXNcbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBDQyBCWS1ORCA0LjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuXG5leHBvcnQgeyBOZ3BIb3ZlciB9IGZyb20gJy4vaG92ZXIvaG92ZXIuZGlyZWN0aXZlJztcbmV4cG9ydCB7IE5ncEhvdmVyVG9rZW4sIGluamVjdEhvdmVyIH0gZnJvbSAnLi9ob3Zlci9ob3Zlci50b2tlbic7XG5leHBvcnQgeyBOZ3BGb2N1cyB9IGZyb20gJy4vZm9jdXMvZm9jdXMuZGlyZWN0aXZlJztcbmV4cG9ydCB7IE5ncEZvY3VzVG9rZW4gfSBmcm9tICcuL2ZvY3VzL2ZvY3VzLnRva2VuJztcbmV4cG9ydCB7IE5ncEZvY3VzVmlzaWJsZSB9IGZyb20gJy4vZm9jdXMtdmlzaWJsZS9mb2N1cy12aXNpYmxlLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBOZ3BGb2N1c1Zpc2libGVUb2tlbiB9IGZyb20gJy4vZm9jdXMtdmlzaWJsZS9mb2N1cy12aXNpYmxlLnRva2VuJztcbiJdfQ==
+export { NgpPress } from './press/press.directive';
+export { NgpPressToken } from './press/press.token';
+export { NgpMove } from './move/move.directive';
+export { NgpMoveToken } from './move/move.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2ludGVyYWN0aW9ucy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsV0FBVyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDakUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDMUUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDM0UsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgwqkgMjAyNCBBbmd1bGFyIFByaW1pdGl2ZXMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vbmctcHJpbWl0aXZlcy9uZy1wcmltaXRpdmVzXG4gKlxuICogVGhpcyBzb3VyY2UgY29kZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQ0MgQlktTkQgNC4wIGxpY2Vuc2UgZm91bmQgaW4gdGhlXG4gKiBMSUNFTlNFIGZpbGUgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgc291cmNlIHRyZWUuXG4gKi9cblxuZXhwb3J0IHsgTmdwSG92ZXIgfSBmcm9tICcuL2hvdmVyL2hvdmVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBOZ3BIb3ZlclRva2VuLCBpbmplY3RIb3ZlciB9IGZyb20gJy4vaG92ZXIvaG92ZXIudG9rZW4nO1xuZXhwb3J0IHsgTmdwRm9jdXMgfSBmcm9tICcuL2ZvY3VzL2ZvY3VzLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBOZ3BGb2N1c1Rva2VuIH0gZnJvbSAnLi9mb2N1cy9mb2N1cy50b2tlbic7XG5leHBvcnQgeyBOZ3BGb2N1c1Zpc2libGUgfSBmcm9tICcuL2ZvY3VzLXZpc2libGUvZm9jdXMtdmlzaWJsZS5kaXJlY3RpdmUnO1xuZXhwb3J0IHsgTmdwRm9jdXNWaXNpYmxlVG9rZW4gfSBmcm9tICcuL2ZvY3VzLXZpc2libGUvZm9jdXMtdmlzaWJsZS50b2tlbic7XG5leHBvcnQgeyBOZ3BQcmVzcyB9IGZyb20gJy4vcHJlc3MvcHJlc3MuZGlyZWN0aXZlJztcbmV4cG9ydCB7IE5ncFByZXNzVG9rZW4gfSBmcm9tICcuL3ByZXNzL3ByZXNzLnRva2VuJztcbmV4cG9ydCB7IE5ncE1vdmUgfSBmcm9tICcuL21vdmUvbW92ZS5kaXJlY3RpdmUnO1xuZXhwb3J0IHsgTmdwTW92ZVRva2VuIH0gZnJvbSAnLi9tb3ZlL21vdmUudG9rZW4nO1xuIl19

package/esm2022/interactions/move/move.directive.mjs

@@ -0,0 +1,216 @@
+import { booleanAttribute, Directive, HostListener, input, output, signal } from '@angular/core';
+import { injectDisabled } from 'ng-primitives/internal';
+import { injectDisposables } from 'ng-primitives/utils';
+import { NgpMoveToken } from './move.token';
+import * as i0 from "@angular/core";
+/**
+ * Inspired by react-aria useMove hook:
+ * https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/interactions/src/useMove.ts
+ */
+export class NgpMove {
+    constructor() {
+        /**
+         * Access the disposable helper.
+         */
+        this.disposables = injectDisposables();
+        /**
+         * Whether movement is disabled.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpMoveDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Access the disabled state from any parent.
+         */
+        this.isDisabled = injectDisabled(this.disabled);
+        /**
+         * Emit when the move event begins.
+         */
+        this.start = output({
+            alias: 'ngpMoveStart',
+        });
+        /**
+         * Emit when the element is moved.
+         */
+        this.move = output({
+            alias: 'ngpMove',
+        });
+        /**
+         * Emit when the move event ends.
+         */
+        this.end = output({
+            alias: 'ngpMoveEnd',
+        });
+        /**
+         * Whether the element is currently being moved.
+         */
+        this.isMoving = signal(false);
+        /**
+         * Store the last x position of the element.
+         */
+        this.x = null;
+        /**
+         * Store the last y position of the element.
+         */
+        this.y = null;
+        /**
+         * Store the id of the last pointer.
+         */
+        this.pointerId = null;
+        /**
+         * Store the disposable event listeners.
+         */
+        this.disposableListeners = [];
+    }
+    /**
+     * Handle a move start.
+     */
+    onMoveStart(event, pointerType) {
+        this.start.emit({
+            pointerType,
+            shiftKey: event.shiftKey,
+            ctrlKey: event.ctrlKey,
+            metaKey: event.metaKey,
+            altKey: event.altKey,
+        });
+        this.isMoving.set(true);
+    }
+    /**
+     * Handle a move event.
+     */
+    onMove(event, pointerType, deltaX, deltaY) {
+        if (deltaX === 0 && deltaY === 0) {
+            return;
+        }
+        this.move.emit({
+            deltaX,
+            deltaY,
+            pointerType,
+            shiftKey: event.shiftKey,
+            ctrlKey: event.ctrlKey,
+            metaKey: event.metaKey,
+            altKey: event.altKey,
+        });
+    }
+    /**
+     * Handle a move end.
+     */
+    onMoveEnd(event, pointerType) {
+        this.end.emit({
+            pointerType,
+            shiftKey: event.shiftKey,
+            ctrlKey: event.ctrlKey,
+            metaKey: event.metaKey,
+            altKey: event.altKey,
+        });
+        this.isMoving.set(false);
+    }
+    /**
+     * Handle the pointer down event.
+     */
+    onPointerDown(event) {
+        // ignore right-click or additional pointers
+        if (event.button !== 0 || this.pointerId !== null || this.isDisabled()) {
+            return;
+        }
+        // prevent the default behavior
+        event.preventDefault();
+        event.stopPropagation();
+        this.onMoveStart(event, event.pointerType);
+        // store the pointer id and initial position
+        this.pointerId = event.pointerId;
+        this.x = event.pageX;
+        this.y = event.pageY;
+        // add global event listeners
+        const pointerMove = this.disposables.addEventListener(window, 'pointermove', this.onPointerMove.bind(this), false);
+        const pointerUp = this.disposables.addEventListener(window, 'pointerup', this.onPointerUp.bind(this), false);
+        const pointerCancel = this.disposables.addEventListener(window, 'pointercancel', this.onPointerUp.bind(this), false);
+        // store the disposable event listeners
+        this.disposableListeners = [pointerMove, pointerUp, pointerCancel];
+    }
+    /**
+     * Handle the pointer up event.
+     */
+    onPointerUp(event) {
+        if (this.pointerId !== event.pointerId) {
+            return;
+        }
+        const pointerType = (event.pointerType ?? 'mouse');
+        this.onMoveEnd(event, pointerType);
+        this.pointerId = null;
+        this.disposableListeners.forEach(dispose => dispose());
+    }
+    /**
+     * Handle the pointer move event.
+     */
+    onPointerMove(event) {
+        if (this.pointerId !== event.pointerId) {
+            return;
+        }
+        // Problems with PointerEvent#movementX/movementY:
+        // 1. it is always 0 on macOS Safari.
+        // 2. On Chrome Android, it's scaled by devicePixelRatio, but not on Chrome macOS
+        this.onMove(event, event.pointerType, event.pageX - (this.x ?? 0), event.pageY - (this.y ?? 0));
+        this.x = event.pageX;
+        this.y = event.pageY;
+    }
+    triggerKeyboardMove(event, deltaX, deltaY) {
+        if (this.isDisabled()) {
+            return;
+        }
+        this.onMoveStart(event, 'keyboard');
+        this.onMove(event, 'keyboard', deltaX, deltaY);
+        this.onMoveEnd(event, 'keyboard');
+    }
+    onArrowUp(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.triggerKeyboardMove(event, 0, -1);
+    }
+    onArrowDown(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.triggerKeyboardMove(event, 0, 1);
+    }
+    onArrowLeft(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.triggerKeyboardMove(event, -1, 0);
+    }
+    onArrowRight(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.triggerKeyboardMove(event, 1, 0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpMove, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpMove, isStandalone: true, selector: "[ngpMove]", inputs: { disabled: { classPropertyName: "disabled", publicName: "ngpMoveDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { start: "ngpMoveStart", move: "ngpMove", end: "ngpMoveEnd" }, host: { listeners: { "pointerdown": "onPointerDown($event)", "keydown.ArrowUp": "onArrowUp($event)", "keydown.ArrowDown": "onArrowDown($event)", "keydown.ArrowLeft": "onArrowLeft($event)", "keydown.ArrowRight": "onArrowRight($event)" }, properties: { "attr.data-move": "isMoving()" } }, providers: [{ provide: NgpMoveToken, useExisting: NgpMove }], exportAs: ["ngpMove"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpMove, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpMove]',
+                    exportAs: 'ngpMove',
+                    providers: [{ provide: NgpMoveToken, useExisting: NgpMove }],
+                    host: {
+                        '[attr.data-move]': 'isMoving()',
+                    },
+                }]
+        }], propDecorators: { onPointerDown: [{
+                type: HostListener,
+                args: ['pointerdown', ['$event']]
+            }], onArrowUp: [{
+                type: HostListener,
+                args: ['keydown.ArrowUp', ['$event']]
+            }], onArrowDown: [{
+                type: HostListener,
+                args: ['keydown.ArrowDown', ['$event']]
+            }], onArrowLeft: [{
+                type: HostListener,
+                args: ['keydown.ArrowLeft', ['$event']]
+            }], onArrowRight: [{
+                type: HostListener,
+                args: ['keydown.ArrowRight', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"move.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/interactions/src/move/move.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 } from '@angular/cdk/coercion';\nimport { booleanAttribute, Directive, HostListener, input, output, signal } from '@angular/core';\nimport { injectDisabled } from 'ng-primitives/internal';\nimport { injectDisposables } from 'ng-primitives/utils';\nimport { NgpMoveToken } from './move.token';\n\n/**\n * Inspired by react-aria useMove hook:\n * https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/interactions/src/useMove.ts\n */\n\n@Directive({\n  standalone: true,\n  selector: '[ngpMove]',\n  exportAs: 'ngpMove',\n  providers: [{ provide: NgpMoveToken, useExisting: NgpMove }],\n  host: {\n    '[attr.data-move]': 'isMoving()',\n  },\n})\nexport class NgpMove {\n  /**\n   * Access the disposable helper.\n   */\n  private readonly disposables = injectDisposables();\n\n  /**\n   * Whether movement is disabled.\n   */\n  readonly disabled = input<boolean, BooleanInput>(false, {\n    alias: 'ngpMoveDisabled',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Access the disabled state from any parent.\n   */\n  private readonly isDisabled = injectDisabled(this.disabled);\n\n  /**\n   * Emit when the move event begins.\n   */\n  readonly start = output<NgpMoveStartEvent>({\n    alias: 'ngpMoveStart',\n  });\n\n  /**\n   * Emit when the element is moved.\n   */\n  readonly move = output<NgpMoveEvent>({\n    alias: 'ngpMove',\n  });\n\n  /**\n   * Emit when the move event ends.\n   */\n  readonly end = output<NgpMoveEndEvent>({\n    alias: 'ngpMoveEnd',\n  });\n\n  /**\n   * Whether the element is currently being moved.\n   */\n  private isMoving = signal<boolean>(false);\n\n  /**\n   * Store the last x position of the element.\n   */\n  private x: number | null = null;\n\n  /**\n   * Store the last y position of the element.\n   */\n  private y: number | null = null;\n\n  /**\n   * Store the id of the last pointer.\n   */\n  private pointerId: number | null = null;\n\n  /**\n   * Store the disposable event listeners.\n   */\n  private disposableListeners: (() => void)[] = [];\n\n  /**\n   * Handle a move start.\n   */\n  private onMoveStart(event: PointerEvent | KeyboardEvent, pointerType: PointerType): void {\n    this.start.emit({\n      pointerType,\n      shiftKey: event.shiftKey,\n      ctrlKey: event.ctrlKey,\n      metaKey: event.metaKey,\n      altKey: event.altKey,\n    });\n    this.isMoving.set(true);\n  }\n\n  /**\n   * Handle a move event.\n   */\n  private onMove(\n    event: PointerEvent | KeyboardEvent,\n    pointerType: PointerType,\n    deltaX: number,\n    deltaY: number,\n  ): void {\n    if (deltaX === 0 && deltaY === 0) {\n      return;\n    }\n\n    this.move.emit({\n      deltaX,\n      deltaY,\n      pointerType,\n      shiftKey: event.shiftKey,\n      ctrlKey: event.ctrlKey,\n      metaKey: event.metaKey,\n      altKey: event.altKey,\n    });\n  }\n\n  /**\n   * Handle a move end.\n   */\n  private onMoveEnd(event: PointerEvent | KeyboardEvent, pointerType: PointerType): void {\n    this.end.emit({\n      pointerType,\n      shiftKey: event.shiftKey,\n      ctrlKey: event.ctrlKey,\n      metaKey: event.metaKey,\n      altKey: event.altKey,\n    });\n    this.isMoving.set(false);\n  }\n\n  /**\n   * Handle the pointer down event.\n   */\n  @HostListener('pointerdown', ['$event'])\n  protected onPointerDown(event: PointerEvent): void {\n    // ignore right-click or additional pointers\n    if (event.button !== 0 || this.pointerId !== null || this.isDisabled()) {\n      return;\n    }\n\n    // prevent the default behavior\n    event.preventDefault();\n    event.stopPropagation();\n\n    this.onMoveStart(event, event.pointerType as PointerType);\n\n    // store the pointer id and initial position\n    this.pointerId = event.pointerId;\n    this.x = event.pageX;\n    this.y = event.pageY;\n\n    // add global event listeners\n    const pointerMove = this.disposables.addEventListener(\n      window,\n      'pointermove',\n      this.onPointerMove.bind(this) as EventListener,\n      false,\n    );\n\n    const pointerUp = this.disposables.addEventListener(\n      window,\n      'pointerup',\n      this.onPointerUp.bind(this) as EventListener,\n      false,\n    );\n\n    const pointerCancel = this.disposables.addEventListener(\n      window,\n      'pointercancel',\n      this.onPointerUp.bind(this) as EventListener,\n      false,\n    );\n\n    // store the disposable event listeners\n    this.disposableListeners = [pointerMove, pointerUp, pointerCancel];\n  }\n\n  /**\n   * Handle the pointer up event.\n   */\n  protected onPointerUp(event: PointerEvent): void {\n    if (this.pointerId !== event.pointerId) {\n      return;\n    }\n\n    const pointerType = (event.pointerType ?? 'mouse') as PointerType;\n    this.onMoveEnd(event, pointerType);\n    this.pointerId = null;\n    this.disposableListeners.forEach(dispose => dispose());\n  }\n\n  /**\n   * Handle the pointer move event.\n   */\n  protected onPointerMove(event: PointerEvent): void {\n    if (this.pointerId !== event.pointerId) {\n      return;\n    }\n\n    // Problems with PointerEvent#movementX/movementY:\n    // 1. it is always 0 on macOS Safari.\n    // 2. On Chrome Android, it's scaled by devicePixelRatio, but not on Chrome macOS\n    this.onMove(\n      event,\n      event.pointerType as PointerType,\n      event.pageX - (this.x ?? 0),\n      event.pageY - (this.y ?? 0),\n    );\n    this.x = event.pageX;\n    this.y = event.pageY;\n  }\n\n  private triggerKeyboardMove(event: KeyboardEvent, deltaX: number, deltaY: number): void {\n    if (this.isDisabled()) {\n      return;\n    }\n\n    this.onMoveStart(event, 'keyboard');\n    this.onMove(event, 'keyboard', deltaX, deltaY);\n    this.onMoveEnd(event, 'keyboard');\n  }\n\n  @HostListener('keydown.ArrowUp', ['$event'])\n  protected onArrowUp(event: KeyboardEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.triggerKeyboardMove(event, 0, -1);\n  }\n\n  @HostListener('keydown.ArrowDown', ['$event'])\n  protected onArrowDown(event: KeyboardEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.triggerKeyboardMove(event, 0, 1);\n  }\n\n  @HostListener('keydown.ArrowLeft', ['$event'])\n  protected onArrowLeft(event: KeyboardEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.triggerKeyboardMove(event, -1, 0);\n  }\n\n  @HostListener('keydown.ArrowRight', ['$event'])\n  protected onArrowRight(event: KeyboardEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.triggerKeyboardMove(event, 1, 0);\n  }\n}\n\ninterface NgpMoveBaseEvent {\n  /**\n   * Whether the event was triggered by a mouse or keyboard event.\n   */\n  pointerType: PointerType;\n  /**\n   * Whether the shift key was pressed during the event.\n   */\n  shiftKey: boolean;\n  /**\n   * Whether the control key was pressed during the event.\n   */\n  ctrlKey: boolean;\n  /**\n   * Whether the meta key was pressed during the event.\n   */\n  metaKey: boolean;\n  /**\n   * Whether the alt key was pressed during the event.\n   */\n  altKey: boolean;\n}\n\nexport type NgpMoveStartEvent = NgpMoveBaseEvent;\nexport type NgpMoveEndEvent = NgpMoveBaseEvent;\n\nexport interface NgpMoveEvent extends NgpMoveBaseEvent {\n  /**\n   * The amount of pixels moved in the x-axis.\n   */\n  deltaX: number;\n  /**\n   * The amount of pixels moved in the y-axis.\n   */\n  deltaY: number;\n}\n\nexport type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';\n"]}

package/esm2022/interactions/move/move.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 NgpMoveToken = new InjectionToken('NgpMoveToken');
+/**
+ * Inject the Move directive instance
+ */
+export function injectMove() {
+    return inject(NgpMoveToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW92ZS50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nLXByaW1pdGl2ZXMvaW50ZXJhY3Rpb25zL3NyYy9tb3ZlL21vdmUudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLElBQUksY0FBYyxDQUFVLGNBQWMsQ0FBQyxDQUFDO0FBRXhFOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFVBQVU7SUFDeEIsT0FBTyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7QUFDOUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIENDIEJZLU5EIDQuMCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICovXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7IE5ncE1vdmUgfSBmcm9tICcuL21vdmUuZGlyZWN0aXZlJztcblxuZXhwb3J0IGNvbnN0IE5ncE1vdmVUb2tlbiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3BNb3ZlPignTmdwTW92ZVRva2VuJyk7XG5cbi8qKlxuICogSW5qZWN0IHRoZSBNb3ZlIGRpcmVjdGl2ZSBpbnN0YW5jZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0TW92ZSgpOiBOZ3BNb3ZlIHtcbiAgcmV0dXJuIGluamVjdChOZ3BNb3ZlVG9rZW4pO1xufVxuIl19

package/esm2022/interactions/press/press.directive.mjs

@@ -0,0 +1,118 @@
+import { Directive, ElementRef, HostListener, booleanAttribute, inject, input, output, signal, } from '@angular/core';
+import { injectDisabled } from 'ng-primitives/internal';
+import { injectDisposables } from 'ng-primitives/utils';
+import { NgpPressToken } from './press.token';
+import * as i0 from "@angular/core";
+/**
+ * This was inpsired by Headless UI's active-press hook:
+ * https://github.com/tailwindlabs/headlessui/blob/main/packages/%40headlessui-react/src/hooks/use-active-press.tsx
+ */
+export class NgpPress {
+    constructor() {
+        /**
+         * Access the HTML Element.
+         */
+        this.element = inject(ElementRef);
+        /**
+         * Access the disposables.
+         */
+        this.disposables = injectDisposables();
+        /**
+         * Whether listening for press events is disabled.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpPressDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Access the disabled state from any parent.
+         */
+        this.isDisabled = injectDisabled(this.disabled);
+        /**
+         * Emit when the press begins.
+         */
+        this.pressStart = output({
+            alias: 'ngpPressStart',
+        });
+        /**
+         * Emit when the press ends.
+         */
+        this.pressEnd = output({
+            alias: 'ngpPressEnd',
+        });
+        /**
+         * Emit when the press changes.
+         */
+        this.pressChange = output({
+            alias: 'ngpPress',
+        });
+        /**
+         * The press state.
+         */
+        this.pressed = signal(false);
+        /**
+         * Store the list of disposables.
+         */
+        this.disposableListeners = [];
+    }
+    /**
+     * Reset the press state.
+     */
+    reset() {
+        // if we are not pressing, then do nothing
+        if (!this.pressed()) {
+            return;
+        }
+        // clear any existing disposables
+        this.disposableListeners.forEach(dispose => dispose());
+        this.pressed.set(false);
+        this.pressEnd.emit();
+        this.pressChange.emit(false);
+    }
+    onPointerDown() {
+        if (this.isDisabled()) {
+            return;
+        }
+        // clear any existing disposables
+        this.disposableListeners.forEach(dispose => dispose());
+        // update the press state
+        this.pressed.set(true);
+        this.pressStart.emit();
+        this.pressChange.emit(true);
+        // setup global event listeners to catch events on elements outside the directive
+        const ownerDocument = this.element.nativeElement.ownerDocument ?? document;
+        // if the pointer up event happens on any elements, then we are no longer pressing on this element
+        const pointerUp = this.disposables.addEventListener(ownerDocument, 'pointerup', this.reset.bind(this), false);
+        // Instead of relying on the `pointerleave` event, which is not consistently called on iOS Safari,
+        // we use the `pointermove` event to determine if we are still "pressing".
+        // By checking if the target is still within the element, we can determine if the press is ongoing.
+        const pointerMove = this.disposables.addEventListener(ownerDocument, 'pointermove', this.onPointerMove.bind(this), false);
+        // if the pointer is cancelled, then we are no longer pressing on this element
+        const pointerCancel = this.disposables.addEventListener(ownerDocument, 'pointercancel', this.reset.bind(this), false);
+        this.disposableListeners = [pointerUp, pointerMove, pointerCancel];
+    }
+    onPointerMove(event) {
+        if (this.element.nativeElement !== event.target &&
+            !this.element.nativeElement.contains(event.target)) {
+            this.reset();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpPress, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpPress, isStandalone: true, selector: "[ngpPress]", inputs: { disabled: { classPropertyName: "disabled", publicName: "ngpPressDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { pressStart: "ngpPressStart", pressEnd: "ngpPressEnd", pressChange: "ngpPress" }, host: { listeners: { "pointerdown": "onPointerDown()" }, properties: { "attr.data-press": "pressed()" } }, providers: [{ provide: NgpPressToken, useExisting: NgpPress }], exportAs: ["ngpPress"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpPress, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpPress]',
+                    exportAs: 'ngpPress',
+                    providers: [{ provide: NgpPressToken, useExisting: NgpPress }],
+                    host: {
+                        '[attr.data-press]': 'pressed()',
+                    },
+                }]
+        }], propDecorators: { onPointerDown: [{
+                type: HostListener,
+                args: ['pointerdown']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"press.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/interactions/src/press/press.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 } from '@angular/cdk/coercion';\nimport {\n  Directive,\n  ElementRef,\n  HostListener,\n  booleanAttribute,\n  inject,\n  input,\n  output,\n  signal,\n} from '@angular/core';\nimport { injectDisabled } from 'ng-primitives/internal';\nimport { injectDisposables } from 'ng-primitives/utils';\nimport { NgpPressToken } from './press.token';\n\n/**\n * This was inpsired by Headless UI's active-press hook:\n * https://github.com/tailwindlabs/headlessui/blob/main/packages/%40headlessui-react/src/hooks/use-active-press.tsx\n */\n\n@Directive({\n  standalone: true,\n  selector: '[ngpPress]',\n  exportAs: 'ngpPress',\n  providers: [{ provide: NgpPressToken, useExisting: NgpPress }],\n  host: {\n    '[attr.data-press]': 'pressed()',\n  },\n})\nexport class NgpPress {\n  /**\n   * Access the HTML Element.\n   */\n  private readonly element = inject<ElementRef<HTMLElement>>(ElementRef);\n\n  /**\n   * Access the disposables.\n   */\n  private readonly disposables = injectDisposables();\n\n  /**\n   * Whether listening for press events is disabled.\n   */\n  readonly disabled = input<boolean, BooleanInput>(false, {\n    alias: 'ngpPressDisabled',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Access the disabled state from any parent.\n   */\n  private readonly isDisabled = injectDisabled(this.disabled);\n\n  /**\n   * Emit when the press begins.\n   */\n  readonly pressStart = output<void>({\n    alias: 'ngpPressStart',\n  });\n\n  /**\n   * Emit when the press ends.\n   */\n  readonly pressEnd = output<void>({\n    alias: 'ngpPressEnd',\n  });\n\n  /**\n   * Emit when the press changes.\n   */\n  readonly pressChange = output<boolean>({\n    alias: 'ngpPress',\n  });\n\n  /**\n   * The press state.\n   */\n  protected readonly pressed = signal(false);\n\n  /**\n   * Reset the press state.\n   */\n  private reset(): void {\n    // if we are not pressing, then do nothing\n    if (!this.pressed()) {\n      return;\n    }\n\n    // clear any existing disposables\n    this.disposableListeners.forEach(dispose => dispose());\n    this.pressed.set(false);\n    this.pressEnd.emit();\n    this.pressChange.emit(false);\n  }\n\n  /**\n   * Store the list of disposables.\n   */\n  private disposableListeners: (() => void)[] = [];\n\n  @HostListener('pointerdown')\n  protected onPointerDown(): void {\n    if (this.isDisabled()) {\n      return;\n    }\n\n    // clear any existing disposables\n    this.disposableListeners.forEach(dispose => dispose());\n\n    // update the press state\n    this.pressed.set(true);\n    this.pressStart.emit();\n    this.pressChange.emit(true);\n\n    // setup global event listeners to catch events on elements outside the directive\n    const ownerDocument = this.element.nativeElement.ownerDocument ?? document;\n\n    // if the pointer up event happens on any elements, then we are no longer pressing on this element\n    const pointerUp = this.disposables.addEventListener(\n      ownerDocument,\n      'pointerup',\n      this.reset.bind(this),\n      false,\n    );\n\n    // Instead of relying on the `pointerleave` event, which is not consistently called on iOS Safari,\n    // we use the `pointermove` event to determine if we are still \"pressing\".\n    // By checking if the target is still within the element, we can determine if the press is ongoing.\n    const pointerMove = this.disposables.addEventListener(\n      ownerDocument,\n      'pointermove',\n      this.onPointerMove.bind(this) as EventListener,\n      false,\n    );\n\n    // if the pointer is cancelled, then we are no longer pressing on this element\n    const pointerCancel = this.disposables.addEventListener(\n      ownerDocument,\n      'pointercancel',\n      this.reset.bind(this),\n      false,\n    );\n\n    this.disposableListeners = [pointerUp, pointerMove, pointerCancel];\n  }\n\n  private onPointerMove(event: PointerEvent): void {\n    if (\n      this.element.nativeElement !== event.target &&\n      !this.element.nativeElement.contains(event.target as Node)\n    ) {\n      this.reset();\n    }\n  }\n}\n"]}

package/esm2022/interactions/press/press.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 NgpPressToken = new InjectionToken('NgpPressToken');
+/**
+ * Inject the Press directive instance
+ */
+export function injectPress() {
+    return inject(NgpPressToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlc3MudG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2ludGVyYWN0aW9ucy9zcmMvcHJlc3MvcHJlc3MudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLElBQUksY0FBYyxDQUFXLGVBQWUsQ0FBQyxDQUFDO0FBRTNFOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFdBQVc7SUFDekIsT0FBTyxNQUFNLENBQUMsYUFBYSxDQUFDLENBQUM7QUFDL0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIENDIEJZLU5EIDQuMCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICovXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7IE5ncFByZXNzIH0gZnJvbSAnLi9wcmVzcy5kaXJlY3RpdmUnO1xuXG5leHBvcnQgY29uc3QgTmdwUHJlc3NUb2tlbiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3BQcmVzcz4oJ05ncFByZXNzVG9rZW4nKTtcblxuLyoqXG4gKiBJbmplY3QgdGhlIFByZXNzIGRpcmVjdGl2ZSBpbnN0YW5jZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0UHJlc3MoKTogTmdwUHJlc3Mge1xuICByZXR1cm4gaW5qZWN0KE5ncFByZXNzVG9rZW4pO1xufVxuIl19

package/esm2022/internal/disabled/disabled.mjs

@@ -0,0 +1,19 @@
+/**
+ * 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 { inject, InjectionToken, signal } from '@angular/core';
+export const NgpDisabledToken = new InjectionToken('NgpDisabledToken');
+/**
+ * Determine if we are in a disabled context.
+ * @param disabled The disabled signal for the local context.
+ * @returns The disabled signal.
+ */
+export function injectDisabled(disabled = signal(false)) {
+    const provider = inject(NgpDisabledToken, { optional: true });
+    return provider ? provider.disabled : disabled;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzYWJsZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2ludGVybmFsL3NyYy9kaXNhYmxlZC9kaXNhYmxlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUUsTUFBTSxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFFdkUsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQWdCLGtCQUFrQixDQUFDLENBQUM7QUFTdEY7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxjQUFjLENBQzVCLFdBQTRCLE1BQU0sQ0FBVSxLQUFLLENBQUM7SUFFbEQsTUFBTSxRQUFRLEdBQUcsTUFBTSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFFOUQsT0FBTyxRQUFRLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztBQUNqRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgwqkgMjAyNCBBbmd1bGFyIFByaW1pdGl2ZXMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vbmctcHJpbWl0aXZlcy9uZy1wcmltaXRpdmVzXG4gKlxuICogVGhpcyBzb3VyY2UgY29kZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQ0MgQlktTkQgNC4wIGxpY2Vuc2UgZm91bmQgaW4gdGhlXG4gKiBMSUNFTlNFIGZpbGUgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgc291cmNlIHRyZWUuXG4gKi9cbmltcG9ydCB7IGluamVjdCwgSW5qZWN0aW9uVG9rZW4sIHNpZ25hbCwgU2lnbmFsIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBOZ3BEaXNhYmxlZFRva2VuID0gbmV3IEluamVjdGlvblRva2VuPE5ncENhbkRpc2FibGU+KCdOZ3BEaXNhYmxlZFRva2VuJyk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmdwQ2FuRGlzYWJsZSB7XG4gIC8qKlxuICAgKiBXaGV0aGVyIHRoZSBlbGVtZW50IGlzIGRpc2FibGVkLlxuICAgKi9cbiAgcmVhZG9ubHkgZGlzYWJsZWQ6IFNpZ25hbDxib29sZWFuPjtcbn1cblxuLyoqXG4gKiBEZXRlcm1pbmUgaWYgd2UgYXJlIGluIGEgZGlzYWJsZWQgY29udGV4dC5cbiAqIEBwYXJhbSBkaXNhYmxlZCBUaGUgZGlzYWJsZWQgc2lnbmFsIGZvciB0aGUgbG9jYWwgY29udGV4dC5cbiAqIEByZXR1cm5zIFRoZSBkaXNhYmxlZCBzaWduYWwuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3REaXNhYmxlZChcbiAgZGlzYWJsZWQ6IFNpZ25hbDxib29sZWFuPiA9IHNpZ25hbDxib29sZWFuPihmYWxzZSksXG4pOiBTaWduYWw8Ym9vbGVhbj4ge1xuICBjb25zdCBwcm92aWRlciA9IGluamVjdChOZ3BEaXNhYmxlZFRva2VuLCB7IG9wdGlvbmFsOiB0cnVlIH0pO1xuXG4gIHJldHVybiBwcm92aWRlciA/IHByb3ZpZGVyLmRpc2FibGVkIDogZGlzYWJsZWQ7XG59XG4iXX0=

package/esm2022/internal/index.mjs

@@ -0,0 +1,11 @@
+/**
+ * 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 * from './disabled/disabled';
+export * from './orientation/orientation';
+export * from './style-injector/style-injector';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2ludGVybmFsL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIENDIEJZLU5EIDQuMCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZGlzYWJsZWQvZGlzYWJsZWQnO1xuZXhwb3J0ICogZnJvbSAnLi9vcmllbnRhdGlvbi9vcmllbnRhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3N0eWxlLWluamVjdG9yL3N0eWxlLWluamVjdG9yJztcbiJdfQ==

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

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