@tony-ui-library/core 0.0.1

package/src/lib/modal/dialog.service.spec.ts

@@ -0,0 +1,52 @@
+import { Component } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { DialogModule } from '@angular/cdk/dialog';
+import { TonDialogService } from './dialog.service';
+
+@Component({
+  standalone: true,
+  template: `<div>Dialog Content</div>`,
+})
+class TestDialogComponent {}
+
+describe('TonDialogService', () => {
+  let service: TonDialogService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [DialogModule],
+    });
+    service = TestBed.inject(TonDialogService);
+  });
+
+  afterEach(() => {
+    service.closeAll();
+  });
+
+  it('should open a dialog', () => {
+    const ref = service.open(TestDialogComponent);
+    expect(ref).toBeTruthy();
+    ref.close();
+  });
+
+  it('should close a dialog', async () => {
+    const ref = service.open(TestDialogComponent);
+    let closed = false;
+    ref.closed.subscribe(() => (closed = true));
+    ref.close();
+    await new Promise(resolve => setTimeout(resolve, 50));
+    expect(closed).toBe(true);
+  });
+
+  it('should close all dialogs', () => {
+    service.open(TestDialogComponent);
+    service.open(TestDialogComponent);
+    service.closeAll();
+  });
+
+  it('should accept width config', () => {
+    const ref = service.open(TestDialogComponent, { width: '600px' });
+    expect(ref).toBeTruthy();
+    ref.close();
+  });
+});

package/src/lib/modal/dialog.service.ts

@@ -0,0 +1,61 @@
+import { Injectable, inject, InjectionToken } from '@angular/core';
+import { Dialog, DialogRef as CdkDialogRef } from '@angular/cdk/dialog';
+import type { ComponentType } from '@angular/cdk/overlay';
+import { TonDialogRef } from './dialog-ref';
+import { DEFAULT_DIALOG_CONFIG, type TonDialogConfig } from './dialog.types';
+
+export const TON_DIALOG_DATA = new InjectionToken<unknown>('TON_DIALOG_DATA');
+
+@Injectable({ providedIn: 'root' })
+export class TonDialogService {
+  private readonly cdkDialog = inject(Dialog);
+
+  open<T, R = unknown>(
+    component: ComponentType<T>,
+    config: TonDialogConfig = {}
+  ): TonDialogRef<R> {
+    const merged = { ...DEFAULT_DIALOG_CONFIG, ...config };
+
+    // CDK's disableClose controls both backdrop and ESC together.
+    // To support independent closeOnBackdrop / closeOnEsc, we disable both
+    // at the CDK level and handle them manually.
+    const disableClose = !merged.closeOnBackdrop || !merged.closeOnEsc;
+
+    const cdkRef: CdkDialogRef<R, T> = this.cdkDialog.open(component, {
+      width: merged.width,
+      maxWidth: merged.maxWidth,
+      disableClose,
+      hasBackdrop: true,
+      backdropClass: 'ton-dialog-backdrop',
+      panelClass: 'ton-dialog-panel',
+      ariaLabelledBy: merged.ariaLabelledBy,
+      ariaDescribedBy: merged.ariaDescribedBy,
+      data: merged.data,
+      providers: merged.data != null
+        ? [{ provide: TON_DIALOG_DATA, useValue: merged.data }]
+        : [],
+    });
+
+    // When CDK disableClose is true, manually handle backdrop/ESC based on config
+    if (disableClose) {
+      if (merged.closeOnBackdrop) {
+        const sub = cdkRef.backdropClick.subscribe(() => cdkRef.close());
+        cdkRef.closed.subscribe(() => sub.unsubscribe());
+      }
+      if (merged.closeOnEsc) {
+        const sub = cdkRef.keydownEvents.subscribe(event => {
+          if (event.key === 'Escape') {
+            cdkRef.close();
+          }
+        });
+        cdkRef.closed.subscribe(() => sub.unsubscribe());
+      }
+    }
+
+    return new TonDialogRef<R>(cdkRef);
+  }
+
+  closeAll(): void {
+    this.cdkDialog.closeAll();
+  }
+}

package/src/lib/modal/dialog.types.ts

@@ -0,0 +1,16 @@
+export interface TonDialogConfig {
+  width?: string;
+  maxWidth?: string;
+  closeOnBackdrop?: boolean;
+  closeOnEsc?: boolean;
+  data?: unknown;
+  ariaLabelledBy?: string;
+  ariaDescribedBy?: string;
+}
+
+export const DEFAULT_DIALOG_CONFIG: TonDialogConfig = {
+  width: '28rem',
+  maxWidth: '90vw',
+  closeOnBackdrop: true,
+  closeOnEsc: true,
+};

package/src/lib/modal/index.ts

@@ -0,0 +1,11 @@
+export { TonDialogService, TON_DIALOG_DATA } from './dialog.service';
+export { TonDialogRef } from './dialog-ref';
+export {
+  TonDialogHeaderDirective,
+  TonDialogTitleDirective,
+  TonDialogDescriptionDirective,
+  TonDialogContentDirective,
+  TonDialogFooterDirective,
+  TonDialogCloseDirective,
+} from './dialog.directives';
+export { type TonDialogConfig } from './dialog.types';

package/src/lib/navbar/index.ts

@@ -0,0 +1,7 @@
+export {
+  TonNavbarDirective,
+  TonNavbarBrandDirective,
+  TonNavbarContentDirective,
+  TonNavbarEndDirective,
+  type NavbarVariant,
+} from './navbar.directives';

package/src/lib/navbar/navbar.directives.spec.ts

@@ -0,0 +1,59 @@
+import { Component, signal } from '@angular/core';
+import { TestBed, type ComponentFixture } from '@angular/core/testing';
+import { TonNavbarDirective, TonNavbarBrandDirective, TonNavbarContentDirective, TonNavbarEndDirective, type NavbarVariant } from './navbar.directives';
+
+@Component({
+  standalone: true,
+  imports: [TonNavbarDirective, TonNavbarBrandDirective, TonNavbarContentDirective, TonNavbarEndDirective],
+  template: `
+    <nav tonNavbar [variant]="variant()" [sticky]="sticky()">
+      <div tonNavbarBrand>Logo</div>
+      <div tonNavbarContent>Links</div>
+      <div tonNavbarEnd>Actions</div>
+    </nav>
+  `,
+})
+class TestHostComponent {
+  variant = signal<NavbarVariant>('default');
+  sticky = signal(false);
+}
+
+describe('TonNavbarDirective', () => {
+  let fixture: ComponentFixture<TestHostComponent>;
+  let nav: HTMLElement;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({ imports: [TestHostComponent] }).compileComponents();
+    fixture = TestBed.createComponent(TestHostComponent);
+    fixture.detectChanges();
+    nav = fixture.nativeElement.querySelector('[tonNavbar]');
+  });
+
+  it('should apply default classes', () => {
+    expect(nav.className).toContain('bg-background');
+    expect(nav.className).toContain('flex');
+  });
+
+  it('should apply bordered variant', () => {
+    fixture.componentInstance.variant.set('bordered');
+    fixture.detectChanges();
+    expect(nav.className).toContain('border-b');
+  });
+
+  it('should apply sticky class', () => {
+    fixture.componentInstance.sticky.set(true);
+    fixture.detectChanges();
+    expect(nav.className).toContain('sticky');
+    expect(nav.className).toContain('top-0');
+  });
+
+  it('should render brand, content, end sections', () => {
+    expect(fixture.nativeElement.querySelector('[tonNavbarBrand]')).toBeTruthy();
+    expect(fixture.nativeElement.querySelector('[tonNavbarContent]')).toBeTruthy();
+    expect(fixture.nativeElement.querySelector('[tonNavbarEnd]')).toBeTruthy();
+  });
+
+  it('should have default aria-label "Main navigation"', () => {
+    expect(nav.getAttribute('aria-label')).toBe('Main navigation');
+  });
+});

package/src/lib/navbar/navbar.directives.ts

@@ -0,0 +1,57 @@
+import { Directive, computed, input } from '@angular/core';
+import { cn } from '../core/utils/cn';
+
+export type NavbarVariant = 'default' | 'bordered' | 'floating';
+
+@Directive({
+  selector: '[tonNavbar]',
+  host: {
+    'role': 'navigation',
+    '[attr.aria-label]': 'ariaLabel()',
+    '[class]': 'computedClass()',
+  },
+})
+export class TonNavbarDirective {
+  readonly variant = input<NavbarVariant>('default');
+  readonly sticky = input(false);
+  readonly ariaLabel = input<string>('Main navigation');
+  readonly class = input<string>('');
+
+  protected readonly computedClass = computed(() => {
+    const v = this.variant();
+    const base = 'flex items-center justify-between px-4 py-2 w-full bg-background';
+    const variantClass =
+      v === 'bordered' ? 'border-b border-border' :
+      v === 'floating' ? 'mx-4 mt-2 rounded-lg border border-border shadow-sm' :
+      '';
+    const stickyClass = this.sticky() ? 'sticky top-0 z-40' : '';
+    return cn(base, variantClass, stickyClass, this.class());
+  });
+}
+
+@Directive({
+  selector: '[tonNavbarBrand]',
+  host: { '[class]': 'computedClass()' },
+})
+export class TonNavbarBrandDirective {
+  readonly class = input<string>('');
+  protected readonly computedClass = computed(() => cn('flex items-center gap-2 font-bold text-lg', this.class()));
+}
+
+@Directive({
+  selector: '[tonNavbarContent]',
+  host: { '[class]': 'computedClass()' },
+})
+export class TonNavbarContentDirective {
+  readonly class = input<string>('');
+  protected readonly computedClass = computed(() => cn('flex items-center gap-1', this.class()));
+}
+
+@Directive({
+  selector: '[tonNavbarEnd]',
+  host: { '[class]': 'computedClass()' },
+})
+export class TonNavbarEndDirective {
+  readonly class = input<string>('');
+  protected readonly computedClass = computed(() => cn('flex items-center gap-2 ml-auto', this.class()));
+}

package/src/lib/number-input/index.ts

@@ -0,0 +1,2 @@
+export { TonNumberInputComponent } from './number-input.component';
+export { numberInputVariants, type NumberInputSize } from './number-input.variants';

package/src/lib/number-input/number-input.component.spec.ts

@@ -0,0 +1,151 @@
+import { Component, signal } from '@angular/core';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { TestBed, type ComponentFixture } from '@angular/core/testing';
+import { TonNumberInputComponent } from './number-input.component';
+
+@Component({
+  standalone: true,
+  imports: [TonNumberInputComponent],
+  template: `
+    <ton-number-input
+      [(value)]="num"
+      [min]="min()"
+      [max]="max()"
+      [step]="step()"
+      [disabled]="disabled()"
+    />
+  `,
+})
+class TestHost {
+  num = signal(5);
+  min = signal<number | null>(null);
+  max = signal<number | null>(null);
+  step = signal(1);
+  disabled = signal(false);
+}
+
+describe('TonNumberInputComponent', () => {
+  let fixture: ComponentFixture<TestHost>;
+  let el: HTMLElement;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({ imports: [TestHost] }).compileComponents();
+    fixture = TestBed.createComponent(TestHost);
+    fixture.detectChanges();
+    el = fixture.nativeElement;
+  });
+
+  function getInput(): HTMLInputElement {
+    return el.querySelector('input') as HTMLInputElement;
+  }
+  function getButtons(): HTMLButtonElement[] {
+    return Array.from(el.querySelectorAll('button'));
+  }
+
+  it('should render with initial value', () => {
+    expect(getInput().value).toBe('5');
+  });
+
+  it('should increment on + click', () => {
+    getButtons()[1].click();
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(6);
+  });
+
+  it('should decrement on - click', () => {
+    getButtons()[0].click();
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(4);
+  });
+
+  it('should respect min', () => {
+    fixture.componentInstance.min.set(5);
+    fixture.detectChanges();
+    getButtons()[0].click();
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(5);
+  });
+
+  it('should respect max', () => {
+    fixture.componentInstance.max.set(5);
+    fixture.detectChanges();
+    getButtons()[1].click();
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(5);
+  });
+
+  it('should use step', () => {
+    fixture.componentInstance.step.set(10);
+    fixture.detectChanges();
+    getButtons()[1].click();
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(15); // 5 + 10
+  });
+
+  it('should handle manual input on blur', () => {
+    const input = getInput();
+    input.value = '42';
+    input.dispatchEvent(new Event('input'));
+    input.dispatchEvent(new Event('blur'));
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(42);
+  });
+
+  it('should revert invalid input on blur', () => {
+    const input = getInput();
+    input.value = 'abc';
+    input.dispatchEvent(new Event('input', { bubbles: true }));
+    input.dispatchEvent(new Event('blur', { bubbles: true }));
+    fixture.detectChanges();
+    // Value should remain unchanged at 5
+    expect(fixture.componentInstance.num()).toBe(5);
+  });
+
+  it('should handle ArrowUp/Down', () => {
+    const input = getInput();
+    input.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp', bubbles: true }));
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(6);
+    input.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }));
+    fixture.detectChanges();
+    expect(fixture.componentInstance.num()).toBe(5);
+  });
+
+  it('should disable when disabled', () => {
+    fixture.componentInstance.disabled.set(true);
+    fixture.detectChanges();
+    expect(getInput().disabled).toBe(true);
+    expect(getButtons().every(b => b.disabled)).toBe(true);
+  });
+});
+
+@Component({
+  standalone: true,
+  imports: [ReactiveFormsModule, TonNumberInputComponent],
+  template: `<ton-number-input [formControl]="ctrl" />`,
+})
+class ReactiveHost {
+  ctrl = new FormControl(10);
+}
+
+describe('TonNumberInputComponent — Reactive Forms', () => {
+  let fixture: ComponentFixture<ReactiveHost>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({ imports: [ReactiveHost] }).compileComponents();
+    fixture = TestBed.createComponent(ReactiveHost);
+    fixture.detectChanges();
+  });
+
+  it('should display FormControl value', () => {
+    const input = fixture.nativeElement.querySelector('input') as HTMLInputElement;
+    expect(input.value).toBe('10');
+  });
+
+  it('should update FormControl on increment', () => {
+    const buttons = fixture.nativeElement.querySelectorAll('button');
+    buttons[1].click();
+    fixture.detectChanges();
+    expect(fixture.componentInstance.ctrl.value).toBe(11);
+  });
+});

package/src/lib/number-input/number-input.component.ts

@@ -0,0 +1,152 @@
+import {
+  ChangeDetectionStrategy,
+  Component,
+  computed,
+  effect,
+  forwardRef,
+  input,
+  model,
+  signal,
+  untracked,
+} from '@angular/core';
+import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { cn } from '../core/utils/cn';
+import { numberInputVariants, type NumberInputSize } from './number-input.variants';
+
+@Component({
+  selector: 'ton-number-input',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  providers: [
+    { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => TonNumberInputComponent), multi: true },
+  ],
+  template: `
+    <div [class]="containerClass()">
+      <button
+        type="button"
+        class="px-2.5 hover:bg-accent transition-colors border-r border-border disabled:opacity-40 disabled:cursor-not-allowed"
+        [disabled]="isDisabled() || atMin()"
+        (click)="decrement()"
+        aria-label="Decrease"
+      >
+        <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12h14"/></svg>
+      </button>
+      <input
+        #inputEl
+        type="text"
+        inputmode="decimal"
+        class="flex-1 w-14 text-center outline-none bg-transparent font-medium"
+        [value]="inputValue()"
+        [disabled]="isDisabled()"
+        [placeholder]="placeholder()"
+        [attr.aria-label]="'Number input'"
+        [attr.aria-valuemin]="min() ?? null"
+        [attr.aria-valuemax]="max() ?? null"
+        [attr.aria-valuenow]="value()"
+        role="spinbutton"
+        (input)="onInput($event)"
+        (blur)="commitValue()"
+        (keydown)="onKeydown($event)"
+      />
+      <button
+        type="button"
+        class="px-2.5 hover:bg-accent transition-colors border-l border-border disabled:opacity-40 disabled:cursor-not-allowed"
+        [disabled]="isDisabled() || atMax()"
+        (click)="increment()"
+        aria-label="Increase"
+      >
+        <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12h14"/><path d="M12 5v14"/></svg>
+      </button>
+    </div>
+  `,
+})
+export class TonNumberInputComponent implements ControlValueAccessor {
+  readonly value = model(0);
+  readonly min = input<number | null>(null);
+  readonly max = input<number | null>(null);
+  readonly step = input(1);
+  readonly disabled = input(false);
+  readonly size = input<NumberInputSize>('md');
+  readonly placeholder = input('');
+  readonly class = input<string>('');
+
+  readonly inputValue = signal('0');
+  private readonly _disabledByCva = signal(false);
+  readonly isDisabled = computed(() => this.disabled() || this._disabledByCva());
+
+  readonly atMin = computed(() => this.min() !== null && this.value() <= this.min()!);
+  readonly atMax = computed(() => this.max() !== null && this.value() >= this.max()!);
+
+  readonly containerClass = computed(() =>
+    cn(numberInputVariants({ size: this.size() }), this.isDisabled() && 'opacity-50', this.class())
+  );
+
+  private _onChange: (value: number) => void = () => {};
+  private _onTouched: () => void = () => {};
+
+  constructor() {
+    effect(() => {
+      const val = this.value();
+      untracked(() => this.inputValue.set(String(val)));
+    });
+  }
+
+  writeValue(val: number): void {
+    this.value.set(val ?? 0);
+  }
+
+  registerOnChange(fn: (value: number) => void): void {
+    this._onChange = fn;
+  }
+
+  registerOnTouched(fn: () => void): void {
+    this._onTouched = fn;
+  }
+
+  setDisabledState(isDisabled: boolean): void {
+    this._disabledByCva.set(isDisabled);
+  }
+
+  increment(): void {
+    this.setValue(this.value() + this.step());
+  }
+
+  decrement(): void {
+    this.setValue(this.value() - this.step());
+  }
+
+  onInput(event: Event): void {
+    this.inputValue.set((event.target as HTMLInputElement).value);
+  }
+
+  commitValue(): void {
+    const parsed = parseFloat(this.inputValue());
+    if (isNaN(parsed)) {
+      this.inputValue.set(String(this.value()));
+    } else {
+      this.setValue(parsed);
+    }
+    this._onTouched();
+  }
+
+  onKeydown(event: KeyboardEvent): void {
+    switch (event.key) {
+      case 'ArrowUp':
+        event.preventDefault();
+        this.increment();
+        break;
+      case 'ArrowDown':
+        event.preventDefault();
+        this.decrement();
+        break;
+    }
+  }
+
+  private setValue(raw: number): void {
+    let clamped = raw;
+    if (this.min() !== null) clamped = Math.max(this.min()!, clamped);
+    if (this.max() !== null) clamped = Math.min(this.max()!, clamped);
+    const rounded = parseFloat(clamped.toFixed(10));
+    this.value.set(rounded);
+    this._onChange(rounded);
+  }
+}

package/src/lib/number-input/number-input.variants.ts

@@ -0,0 +1,17 @@
+import { cva } from 'class-variance-authority';
+
+export const numberInputVariants = cva(
+  'inline-flex items-center border border-border rounded-md bg-background transition-colors focus-within:ring-2 focus-within:ring-ring focus-within:ring-offset-2',
+  {
+    variants: {
+      size: {
+        sm: 'h-9 text-xs',
+        md: 'h-10 text-sm',
+        lg: 'h-11 text-base',
+      },
+    },
+    defaultVariants: { size: 'md' },
+  }
+);
+
+export type NumberInputSize = 'sm' | 'md' | 'lg';

package/src/lib/otp-input/index.ts

@@ -0,0 +1,2 @@
+export { TonOtpInputComponent } from './otp-input.component';
+export { otpCellVariants, type OtpInputSize, type OtpInputType } from './otp-input.variants';