@sneat/auth-ui 0.1.3 → 0.1.4

package/src/lib/components/user-required-fields/user-required-fields.service.spec.ts

@@ -1,335 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { ModalController } from '@ionic/angular/standalone';
-import { UserRequiredFieldsService } from './user-required-fields.service';
-import { UserRequiredFieldsModalComponent } from './user-required-fields-modal.component';
-
-describe('UserRequiredFieldsService', () => {
-  let service: UserRequiredFieldsService;
-  let modalController: ModalController;
-  let mockModal: {
-    present: ReturnType<typeof vi.fn>;
-    onDidDismiss: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    // Create a mock modal object
-    mockModal = {
-      present: vi.fn().mockResolvedValue(undefined),
-      onDidDismiss: vi.fn(),
-    };
-
-    TestBed.configureTestingModule({
-      providers: [
-        UserRequiredFieldsService,
-        {
-          provide: ModalController,
-          useValue: {
-            create: vi.fn().mockResolvedValue(mockModal),
-          },
-        },
-      ],
-    });
-
-    service = TestBed.inject(UserRequiredFieldsService);
-    modalController = TestBed.inject(ModalController);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  describe('open', () => {
-    it('should create a modal with UserRequiredFieldsModalComponent', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: true });
-
-      // Act
-      const resultPromise = service.open();
-
-      // Assert
-      expect(modalController.create).toHaveBeenCalledWith({
-        component: UserRequiredFieldsModalComponent,
-      });
-
-      await resultPromise;
-    });
-
-    it('should present the modal after creation', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: true });
-
-      // Act
-      await service.open();
-
-      // Assert
-      expect(mockModal.present).toHaveBeenCalledTimes(1);
-    });
-
-    it('should return a Promise that resolves when modal is dismissed', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: true });
-
-      // Act
-      const resultPromise = service.open();
-
-      // Assert - Just verify we can await it and it returns the expected value
-      const result = await resultPromise;
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to true when dismissal value is truthy', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: 'some value' });
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to true when dismissal value.data is an object', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: { key: 'value' } });
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to true when dismissal value.data is a non-empty string', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: 'success' });
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to true when dismissal value.data is a number', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: 1 });
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to false when dismissal value is undefined', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue(undefined);
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    it('should resolve to false when dismissal value.data is null (object is still truthy)', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: null });
-
-      // Act
-      const result = await service.open();
-
-      // Assert - Object with data:null is still a truthy object
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to false when dismissal value.data is false (object is still truthy)', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: false });
-
-      // Act
-      const result = await service.open();
-
-      // Assert - Object with data:false is still a truthy object
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to false when dismissal value.data is an empty string (object is still truthy)', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: '' });
-
-      // Act
-      const result = await service.open();
-
-      // Assert - Object with data:'' is still a truthy object
-      expect(result).toBe(true);
-    });
-
-    it('should resolve to false when dismissal value.data is zero (object is still truthy)', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({ data: 0 });
-
-      // Act
-      const result = await service.open();
-
-      // Assert - Object with data:0 is still a truthy object
-      expect(result).toBe(true);
-    });
-
-    it('should reject the Promise when modal dismissal fails', async () => {
-      // Arrange
-      const dismissError = new Error('Modal dismissal failed');
-      mockModal.onDidDismiss.mockRejectedValue(dismissError);
-
-      // Act & Assert
-      await expect(service.open()).rejects.toThrow('Modal dismissal failed');
-    });
-
-    it('should reject the Promise when onDidDismiss throws an error', async () => {
-      // Arrange
-      const error = new Error('Unexpected error');
-      mockModal.onDidDismiss.mockRejectedValue(error);
-
-      // Act & Assert
-      await expect(service.open()).rejects.toThrow(error);
-    });
-
-    it('should resolve when modal is dismissed', async () => {
-      // Arrange
-      const dismissalValue = { data: 'test-value' };
-      mockModal.onDidDismiss.mockResolvedValue(dismissalValue);
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should handle multiple sequential open calls independently', async () => {
-      // Arrange
-      const mockModal1 = {
-        present: vi.fn().mockResolvedValue(undefined),
-        onDidDismiss: vi.fn().mockResolvedValue({ data: true }),
-      };
-      const mockModal2 = {
-        present: vi.fn().mockResolvedValue(undefined),
-        onDidDismiss: vi.fn().mockResolvedValue(null), // null is falsy
-      };
-
-      (modalController.create as ReturnType<typeof vi.fn>)
-        .mockResolvedValueOnce(mockModal1)
-        .mockResolvedValueOnce(mockModal2);
-
-      // Act
-      const result1 = await service.open();
-      const result2 = await service.open();
-
-      // Assert
-      expect(result1).toBe(true); // { data: true } is truthy
-      expect(result2).toBe(false); // null is falsy
-      expect(modalController.create).toHaveBeenCalledTimes(2);
-      expect(mockModal1.present).toHaveBeenCalledTimes(1);
-      expect(mockModal2.present).toHaveBeenCalledTimes(1);
-    });
-
-    it('should call onDidDismiss after present completes', async () => {
-      // Arrange
-      const callOrder: string[] = [];
-      mockModal.present.mockImplementation(() => {
-        callOrder.push('present');
-        return Promise.resolve();
-      });
-      mockModal.onDidDismiss.mockImplementation(() => {
-        callOrder.push('onDidDismiss');
-        return Promise.resolve({ data: true });
-      });
-
-      // Act
-      await service.open();
-
-      // Assert
-      expect(callOrder).toEqual(['present', 'onDidDismiss']);
-    });
-
-    it('should handle dismissal with role property', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({
-        data: { success: true },
-        role: 'confirm',
-      });
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should handle empty object as dismissal value', async () => {
-      // Arrange
-      mockModal.onDidDismiss.mockResolvedValue({});
-
-      // Act
-      const result = await service.open();
-
-      // Assert
-      expect(result).toBe(true); // Empty object is truthy
-    });
-
-    describe('edge cases', () => {
-      it('should handle modal creation failure', async () => {
-        // Arrange
-        const createError = new Error('Failed to create modal');
-        (modalController.create as ReturnType<typeof vi.fn>).mockRejectedValue(
-          createError,
-        );
-
-        // Act & Assert
-        await expect(service.open()).rejects.toThrow('Failed to create modal');
-      });
-
-      it('should handle modal present failure', async () => {
-        // Arrange
-        const presentError = new Error('Failed to present modal');
-        mockModal.present.mockRejectedValue(presentError);
-
-        // Act & Assert
-        await expect(service.open()).rejects.toThrow('Failed to present modal');
-      });
-
-      it('should handle dismissal value with data property as array', async () => {
-        // Arrange
-        mockModal.onDidDismiss.mockResolvedValue({ data: [1, 2, 3] });
-
-        // Act
-        const result = await service.open();
-
-        // Assert
-        expect(result).toBe(true);
-      });
-
-      it('should handle dismissal value with data property as empty array', async () => {
-        // Arrange
-        mockModal.onDidDismiss.mockResolvedValue({ data: [] });
-
-        // Act
-        const result = await service.open();
-
-        // Assert
-        expect(result).toBe(true); // Empty array is truthy
-      });
-
-      it('should handle NaN as dismissal value', async () => {
-        // Arrange
-        mockModal.onDidDismiss.mockResolvedValue({ data: NaN });
-
-        // Act
-        const result = await service.open();
-
-        // Assert - Object with data:NaN is still a truthy object (even though NaN itself is falsy)
-        expect(result).toBe(true);
-      });
-    });
-  });
-});

package/src/lib/components/user-required-fields/user-required-fields.service.ts

@@ -1,23 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { ModalController } from '@ionic/angular/standalone';
-import { UserRequiredFieldsModalComponent } from './user-required-fields-modal.component';
-
-@Injectable()
-export class UserRequiredFieldsService {
-  private readonly modalController = inject(ModalController);
-
-  public async open(): Promise<boolean> {
-    const modal = await this.modalController.create({
-      component: UserRequiredFieldsModalComponent,
-    });
-    await modal.present();
-    return new Promise((resolve, reject) => {
-      modal
-        .onDidDismiss()
-        .then((value) => {
-          resolve(!!value);
-        })
-        .catch(reject);
-    });
-  }
-}

package/src/lib/pages/login-page/email-login-form/email-login-form.component.html

@@ -1,165 +0,0 @@
-<div class="ion-padding-horizontal"></div>
-<ion-card>
-  <ion-item-divider color="light" class="ion-no-padding">
-    <ion-segment [(ngModel)]="sign" (ionChange)="signChanged()">
-      <ion-segment-button value="up">
-        <ion-icon name="person-add" class="ion-margin-end"></ion-icon>
-        <ion-label>Sign up</ion-label>
-      </ion-segment-button>
-      <ion-segment-button value="in">
-        <ion-icon name="enter-outline" />
-        <ion-label>Sign in</ion-label>
-      </ion-segment-button>
-    </ion-segment>
-  </ion-item-divider>
-  <!--	<ion-item-divider color="light">-->
-  <!--		<ion-label color="medium" style="text-align: center; width: 100%">-->
-  <!--			Or login with email-->
-  <!--		</ion-label>-->
-  <!--	</ion-item-divider>-->
-  <ion-card-content class="ion-no-padding">
-    <ion-item>
-      <ion-label class="ion-margin-end">
-        <ion-icon name="mail-outline" />
-      </ion-label>
-      <ion-input
-        [disabled]="!!signingWith"
-        [(ngModel)]="email"
-        email
-        type="email"
-        name="email"
-        id="email"
-        required
-        placeholder="my@work-or-personal.email"
-        (keyup.enter)="keyupEnter()"
-      />
-    </ion-item>
-    @switch (sign) {
-      @case ("up") {
-        <ion-item>
-          <ion-label class="ion-margin-end">
-            <ion-icon name="person-add-outline" />
-          </ion-label>
-          <ion-input
-            name="first_name"
-            placeholder="First name"
-            [(ngModel)]="firstName"
-            type="text"
-            required
-            (keyup.enter)="keyupEnter()"
-            [disabled]="!!signingWith"
-          />
-          <ion-input
-            name="last_name"
-            placeholder="Last name"
-            [(ngModel)]="lastName"
-            type="text"
-            required
-            (keyup.enter)="keyupEnter()"
-            [disabled]="!!signingWith"
-          />
-        </ion-item>
-        @if (appInfo.requiredSpaceType === "company") {
-          <ion-item>
-            <ion-label position="stacked">Company name</ion-label>
-            <ion-input
-              #teamTitleInput
-              placeholder="required"
-              required
-              [(ngModel)]="spaceTitle"
-            />
-          </ion-item>
-        }
-      }
-      @case ("in") {
-        <ion-item>
-          <ion-label class="ion-margin-end">
-            <ion-icon name="key-outline" />
-          </ion-label>
-          <ion-input
-            [(ngModel)]="password"
-            placeholder="Password"
-            type="password"
-            required
-            (keyup.enter)="keyupEnter()"
-            [disabled]="!!signingWith"
-          />
-          <ion-buttons slot="end">
-            <ion-button
-              color="danger"
-              [disabled]="!validEmail"
-              (click)="resetPassword()"
-              title="Send email with a link to reset password "
-            >
-              <ion-label>Forgot? Reset!</ion-label>
-            </ion-button>
-          </ion-buttons>
-        </ion-item>
-        @if (wrongPassword) {
-          <ion-item>
-            <ion-label color="danger">Wrong password</ion-label>
-          </ion-item>
-        }
-      }
-    }
-  </ion-card-content>
-  <ion-card-content>
-    @switch (sign) {
-      @case ("up") {
-        <ion-button
-          [disabled]="!!signingWith || !validEmail || (!firstName && !lastName)"
-          (click)="signUp()"
-        >
-          <ion-icon name="enter-outline" slot="start" />
-          @if (signingWith === "email") {
-            <ion-label>Signing up...</ion-label>
-            <ion-spinner
-              class="ion-margin-start"
-              slot="end"
-              name="lines-small"
-            />
-          } @else {
-            <ion-label>Sign up</ion-label>
-          }
-        </ion-button>
-      }
-      @case ("in") {
-        <ion-button
-          [disabled]="!!signingWith || !validEmail || !password"
-          (click)="signIn()"
-        >
-          <ion-icon name="enter-outline" slot="start" />
-          @if (signingWith === "email") {
-            <ion-label>Signing in...</ion-label>
-            <ion-spinner
-              class="ion-margin-start"
-              slot="end"
-              name="lines-small"
-            />
-          } @else {
-            <ion-label>
-              <b>Sign in</b>&nbsp;<ion-text
-                color="light"
-                style="text-transform: none"
-                >with password
-              </ion-text>
-            </ion-label>
-          }
-        </ion-button>
-        <ion-button disabled="disabled" fill="clear" color="medium">
-          or
-        </ion-button>
-        <ion-button
-          size="small"
-          [disabled]="!validEmail || signingWith"
-          (click)="sendSignInLink()"
-          fill="outline"
-          color="tertiary"
-        >
-          <ion-icon name="mail-outline" slot="start" />
-          <ion-label>Get sign-in link</ion-label>
-        </ion-button>
-      }
-    }
-  </ion-card-content>
-</ion-card>

package/src/lib/pages/login-page/email-login-form/email-login-form.component.spec.ts

@@ -1,59 +0,0 @@
-import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
-import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
-import { Auth } from '@angular/fire/auth';
-import { ToastController } from '@ionic/angular/standalone';
-import { SneatApiService } from '@sneat/api';
-import { UserRecordService } from '@sneat/auth-core';
-import { AnalyticsService, APP_INFO, ErrorLogger } from '@sneat/core';
-import { RandomIdService } from '@sneat/random';
-import { EmailLoginFormComponent } from './email-login-form.component';
-
-describe('EmailLoginFormComponent', () => {
-  let component: EmailLoginFormComponent;
-  let fixture: ComponentFixture<EmailLoginFormComponent>;
-
-  beforeEach(waitForAsync(async () => {
-    await TestBed.configureTestingModule({
-      imports: [EmailLoginFormComponent],
-      providers: [
-        {
-          provide: APP_INFO,
-          useValue: { appId: 'test', appTitle: 'Test' },
-        },
-        {
-          provide: AnalyticsService,
-          useValue: { logEvent: vi.fn() },
-        },
-        {
-          provide: ErrorLogger,
-          useValue: { logError: vi.fn(), logErrorHandler: () => vi.fn() },
-        },
-        { provide: ToastController, useValue: { create: vi.fn() } },
-        { provide: Auth, useValue: {} },
-        {
-          provide: RandomIdService,
-          useValue: { newRandomId: () => 'test-id' },
-        },
-        {
-          provide: SneatApiService,
-          useValue: { post: vi.fn(), setApiAuthToken: vi.fn() },
-        },
-        {
-          provide: UserRecordService,
-          useValue: { initUserRecord: vi.fn() },
-        },
-      ],
-      schemas: [CUSTOM_ELEMENTS_SCHEMA],
-    })
-      .overrideComponent(EmailLoginFormComponent, {
-        set: { imports: [], schemas: [CUSTOM_ELEMENTS_SCHEMA] },
-      })
-      .compileComponents();
-    fixture = TestBed.createComponent(EmailLoginFormComponent);
-    component = fixture.componentInstance;
-  }));
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});