# Angular Directive Patterns

## Table of Contents

- [DOM Manipulation](#dom-manipulation)
- [Form Directives](#form-directives)
- [Intersection Observer](#intersection-observer)
- [Resize Observer](#resize-observer)
- [Drag and Drop](#drag-and-drop)
- [Permission Directive](#permission-directive)

## DOM Manipulation

### Auto-Focus Directive

```typescript
@Directive({
  selector: "[appAutoFocus]",
})
export class AutoFocus {
  private el = inject(ElementRef<HTMLElement>);

  enabled = input(true, { alias: "appAutoFocus", transform: booleanAttribute });
  delay = input(0);

  constructor() {
    afterNextRender(() => {
      if (this.enabled()) {
        setTimeout(() => {
          this.el.nativeElement.focus();
        }, this.delay());
      }
    });
  }
}

// Usage: <input appAutoFocus />
// Usage: <input [appAutoFocus]="shouldFocus()" [delay]="100" />
```

### Text Selection Directive

```typescript
@Directive({
  selector: "[appSelectAll]",
  host: {
    "(focus)": "onFocus()",
    "(click)": "onClick($event)",
  },
})
export class SelectAll {
  private el = inject(ElementRef<HTMLInputElement>);

  onFocus() {
    // Delay to ensure value is set
    setTimeout(() => this.el.nativeElement.select(), 0);
  }

  onClick(event: MouseEvent) {
    // Select all on first click if not already focused
    if (document.activeElement !== this.el.nativeElement) {
      this.el.nativeElement.select();
    }
  }
}

// Usage: <input appSelectAll value="Select me on focus" />
```

### Copy to Clipboard

```typescript
@Directive({
  selector: "[appCopyToClipboard]",
  host: {
    "(click)": "copy()",
    "[style.cursor]": '"pointer"',
  },
})
export class CopyToClipboard {
  text = input.required<string>({ alias: "appCopyToClipboard" });

  copied = output<void>();
  error = output<Error>();

  async copy() {
    try {
      await navigator.clipboard.writeText(this.text());
      this.copied.emit();
    } catch (err) {
      this.error.emit(err as Error);
    }
  }
}

// Usage:
// <button [appCopyToClipboard]="textToCopy" (copied)="showToast('Copied!')">
//   Copy
// </button>
```

## Form Directives

### Trim Input

```typescript
@Directive({
  selector: "input[appTrim], textarea[appTrim]",
  host: {
    "(blur)": "onBlur()",
  },
})
export class Trim {
  private el = inject(ElementRef<HTMLInputElement | HTMLTextAreaElement>);
  private ngControl = inject(NgControl, { optional: true, self: true });

  onBlur() {
    const value = this.el.nativeElement.value;
    const trimmed = value.trim();

    if (value !== trimmed) {
      this.el.nativeElement.value = trimmed;
      this.ngControl?.control?.setValue(trimmed);
    }
  }
}

// Usage: <input appTrim formControlName="name" />
```

### Input Mask

```typescript
@Directive({
  selector: "[appMask]",
  host: {
    "(input)": "onInput($event)",
    "(keydown)": "onKeydown($event)",
  },
})
export class Mask {
  private el = inject(ElementRef<HTMLInputElement>);

  // Mask pattern: 9 = digit, A = letter, * = any
  mask = input.required<string>({ alias: "appMask" });

  onInput(event: InputEvent) {
    const input = this.el.nativeElement;
    const value = input.value;
    const masked = this.applyMask(value);

    if (value !== masked) {
      input.value = masked;
    }
  }

  onKeydown(event: KeyboardEvent) {
    // Allow navigation keys
    if (
      ["Backspace", "Delete", "ArrowLeft", "ArrowRight", "Tab"].includes(
        event.key,
      )
    ) {
      return;
    }

    const input = this.el.nativeElement;
    const position = input.selectionStart ?? 0;
    const maskChar = this.mask()[position];

    if (!maskChar) {
      event.preventDefault();
      return;
    }

    if (!this.isValidChar(event.key, maskChar)) {
      event.preventDefault();
    }
  }

  private applyMask(value: string): string {
    const mask = this.mask();
    let result = "";
    let valueIndex = 0;

    for (let i = 0; i < mask.length && valueIndex < value.length; i++) {
      const maskChar = mask[i];
      const inputChar = value[valueIndex];

      if (maskChar === "9" || maskChar === "A" || maskChar === "*") {
        if (this.isValidChar(inputChar, maskChar)) {
          result += inputChar;
          valueIndex++;
        } else {
          valueIndex++;
          i--;
        }
      } else {
        result += maskChar;
        if (inputChar === maskChar) {
          valueIndex++;
        }
      }
    }

    return result;
  }

  private isValidChar(char: string, maskChar: string): boolean {
    switch (maskChar) {
      case "9":
        return /\d/.test(char);
      case "A":
        return /[a-zA-Z]/.test(char);
      case "*":
        return /[a-zA-Z0-9]/.test(char);
      default:
        return char === maskChar;
    }
  }
}

// Usage: <input appMask="(999) 999-9999" placeholder="(555) 123-4567" />
```

### Character Counter

```typescript
@Directive({
  selector: "[appCharCount]",
})
export class CharCount {
  private el = inject(ElementRef<HTMLInputElement | HTMLTextAreaElement>);

  maxLength = input.required<number>({ alias: "appCharCount" });

  currentLength = signal(0);
  remaining = computed(() => this.maxLength() - this.currentLength());
  isOverLimit = computed(() => this.remaining() < 0);

  constructor() {
    effect(() => {
      this.currentLength.set(this.el.nativeElement.value.length);
    });

    // Listen for input changes
    afterNextRender(() => {
      this.el.nativeElement.addEventListener("input", () => {
        this.currentLength.set(this.el.nativeElement.value.length);
      });
    });
  }
}

// Usage with template:
// <textarea appCharCount="500" #counter="appCharCount"></textarea>
// <span>{{ counter.remaining() }} characters remaining</span>
```

## Intersection Observer

### Lazy Load Directive

```typescript
@Directive({
  selector: "[appLazyLoad]",
})
export class LazyLoad implements OnDestroy {
  private el = inject(ElementRef<HTMLElement>);
  private observer: IntersectionObserver | null = null;

  src = input.required<string>({ alias: "appLazyLoad" });
  placeholder = input("/assets/placeholder.png");

  loaded = output<void>();

  constructor() {
    afterNextRender(() => {
      this.setupObserver();
    });
  }

  private setupObserver() {
    this.observer = new IntersectionObserver(
      (entries) => {
        entries.forEach((entry) => {
          if (entry.isIntersecting) {
            this.loadImage();
            this.observer?.disconnect();
          }
        });
      },
      { rootMargin: "50px" },
    );

    this.observer.observe(this.el.nativeElement);

    // Set placeholder
    if (this.el.nativeElement instanceof HTMLImageElement) {
      this.el.nativeElement.src = this.placeholder();
    }
  }

  private loadImage() {
    const element = this.el.nativeElement;

    if (element instanceof HTMLImageElement) {
      element.src = this.src();
      element.onload = () => this.loaded.emit();
    } else {
      element.style.backgroundImage = `url(${this.src()})`;
      this.loaded.emit();
    }
  }

  ngOnDestroy() {
    this.observer?.disconnect();
  }
}

// Usage: <img [appLazyLoad]="imageUrl" alt="Lazy loaded image" />
```

### Infinite Scroll

```typescript
@Directive({
  selector: "[appInfiniteScroll]",
})
export class InfiniteScroll implements OnDestroy {
  private el = inject(ElementRef<HTMLElement>);
  private observer: IntersectionObserver | null = null;

  threshold = input(0.1);
  disabled = input(false);

  scrolled = output<void>();

  constructor() {
    afterNextRender(() => {
      this.setupObserver();
    });

    effect(() => {
      if (this.disabled()) {
        this.observer?.disconnect();
      } else {
        this.setupObserver();
      }
    });
  }

  private setupObserver() {
    this.observer?.disconnect();

    this.observer = new IntersectionObserver(
      (entries) => {
        if (entries[0].isIntersecting && !this.disabled()) {
          this.scrolled.emit();
        }
      },
      { threshold: this.threshold() },
    );

    this.observer.observe(this.el.nativeElement);
  }

  ngOnDestroy() {
    this.observer?.disconnect();
  }
}

// Usage:
// <div class="list">
//   @for (item of items(); track item.id) {
//     <div>{{ item.name }}</div>
//   }
//   <div appInfiniteScroll (scrolled)="loadMore()" [disabled]="isLoading()">
//     Loading...
//   </div>
// </div>
```

## Resize Observer

```typescript
@Directive({
  selector: "[appResize]",
})
export class Resize implements OnDestroy {
  private el = inject(ElementRef<HTMLElement>);
  private observer: ResizeObserver | null = null;

  width = signal(0);
  height = signal(0);

  resized = output<{ width: number; height: number }>();

  constructor() {
    afterNextRender(() => {
      this.observer = new ResizeObserver((entries) => {
        const entry = entries[0];
        const { width, height } = entry.contentRect;

        this.width.set(width);
        this.height.set(height);
        this.resized.emit({ width, height });
      });

      this.observer.observe(this.el.nativeElement);
    });
  }

  ngOnDestroy() {
    this.observer?.disconnect();
  }
}

// Usage:
// <div appResize #resize="appResize">
//   Size: {{ resize.width() }}x{{ resize.height() }}
// </div>
```

## Drag and Drop

```typescript
@Directive({
  selector: "[appDraggable]",
  host: {
    draggable: "true",
    "[class.dragging]": "isDragging()",
    "(dragstart)": "onDragStart($event)",
    "(dragend)": "onDragEnd($event)",
  },
})
export class Draggable {
  data = input<any>(null, { alias: "appDraggable" });
  effectAllowed = input<DataTransfer["effectAllowed"]>("move");

  isDragging = signal(false);

  dragStart = output<DragEvent>();
  dragEnd = output<DragEvent>();

  onDragStart(event: DragEvent) {
    this.isDragging.set(true);

    if (event.dataTransfer) {
      event.dataTransfer.effectAllowed = this.effectAllowed();
      event.dataTransfer.setData(
        "application/json",
        JSON.stringify(this.data()),
      );
    }

    this.dragStart.emit(event);
  }

  onDragEnd(event: DragEvent) {
    this.isDragging.set(false);
    this.dragEnd.emit(event);
  }
}

@Directive({
  selector: "[appDropZone]",
  host: {
    "[class.drag-over]": "isDragOver()",
    "(dragover)": "onDragOver($event)",
    "(dragleave)": "onDragLeave($event)",
    "(drop)": "onDrop($event)",
  },
})
export class DropZone {
  isDragOver = signal(false);

  dropped = output<any>();

  onDragOver(event: DragEvent) {
    event.preventDefault();
    this.isDragOver.set(true);
  }

  onDragLeave(event: DragEvent) {
    this.isDragOver.set(false);
  }

  onDrop(event: DragEvent) {
    event.preventDefault();
    this.isDragOver.set(false);

    const data = event.dataTransfer?.getData("application/json");
    if (data) {
      this.dropped.emit(JSON.parse(data));
    }
  }
}

// Usage:
// <div [appDraggable]="item">Drag me</div>
// <div appDropZone (dropped)="onItemDropped($event)">Drop here</div>
```

## Permission Directive

```typescript
@Directive({
  selector: "[appHasPermission]",
})
export class HasPermission {
  private templateRef = inject(TemplateRef<any>);
  private viewContainer = inject(ViewContainerRef);
  private authService = inject(Auth);
  private hasView = false;

  permission = input.required<string | string[]>({ alias: "appHasPermission" });
  mode = input<"any" | "all">("any");

  constructor() {
    effect(() => {
      const hasPermission = this.checkPermission();

      if (hasPermission && !this.hasView) {
        this.viewContainer.createEmbeddedView(this.templateRef);
        this.hasView = true;
      } else if (!hasPermission && this.hasView) {
        this.viewContainer.clear();
        this.hasView = false;
      }
    });
  }

  private checkPermission(): boolean {
    const required = this.permission();
    const permissions = Array.isArray(required) ? required : [required];
    const userPermissions = this.authService.permissions();

    if (this.mode() === "all") {
      return permissions.every((p) => userPermissions.includes(p));
    }

    return permissions.some((p) => userPermissions.includes(p));
  }
}

// Usage:
// <button *appHasPermission="'admin'">Admin Only</button>
// <div *appHasPermission="['edit', 'delete']; mode: 'all'">Edit & Delete</div>
```

## Export Directive Reference

```typescript
@Directive({
  selector: "[appToggle]",
  exportAs: "appToggle",
})
export class Toggle {
  isOpen = signal(false);

  toggle() {
    this.isOpen.update((v) => !v);
  }

  open() {
    this.isOpen.set(true);
  }

  close() {
    this.isOpen.set(false);
  }
}

// Usage:
// <div appToggle #toggle="appToggle">
//   <button (click)="toggle.toggle()">Toggle</button>
//   @if (toggle.isOpen()) {
//     <div>Content</div>
//   }
// </div>
```