@sneat/core 0.1.0

package/src/lib/nav/nav-context.ts

@@ -0,0 +1,16 @@
+import { IIdAndOptionalBriefAndOptionalDbo } from '../interfaces';
+
+export type SpaceItem = 'happening' | 'contact' | 'document' | 'asset' | 'list';
+
+export type DeleteOperationState = 'deleting' | 'deleted' | undefined;
+
+export type INavContext<
+  Brief,
+  Dbo extends Brief,
+> = IIdAndOptionalBriefAndOptionalDbo<Brief, Dbo>;
+
+// export interface INavContext<Brief, Dto> {
+// 	readonly id: string;
+// 	readonly brief?: Brief | null;
+// 	readonly dto?: Dto | null;
+// }

package/src/lib/nav/routing-state.spec.ts

@@ -0,0 +1,65 @@
+import { TestBed } from '@angular/core/testing';
+import { NavigationEnd, Router, Event } from '@angular/router';
+import { Subject } from 'rxjs';
+import { RoutingState } from './routing-state';
+
+describe('RoutingState', () => {
+  let eventsSubject: Subject<Event>;
+
+  beforeEach(() => {
+    eventsSubject = new Subject();
+    TestBed.configureTestingModule({
+      providers: [
+        RoutingState,
+        {
+          provide: Router,
+          useValue: { events: eventsSubject },
+        },
+      ],
+    });
+  });
+
+  it('should be created', () => {
+    const service = TestBed.inject(RoutingState);
+    expect(service).toBeTruthy();
+  });
+
+  it('should return false when no history exists', () => {
+    const service = TestBed.inject(RoutingState);
+    expect(service.hasHistory()).toBe(false);
+  });
+
+  it('should return false after one navigation', () => {
+    const service = TestBed.inject(RoutingState);
+    const navEnd = new NavigationEnd(1, '/home', '/home');
+    eventsSubject.next(navEnd);
+    expect(service.hasHistory()).toBe(false);
+  });
+
+  it('should return true after two navigations', () => {
+    const service = TestBed.inject(RoutingState);
+
+    const navEnd1 = new NavigationEnd(1, '/home', '/home');
+    eventsSubject.next(navEnd1);
+
+    const navEnd2 = new NavigationEnd(2, '/about', '/about');
+    eventsSubject.next(navEnd2);
+
+    expect(service.hasHistory()).toBe(true);
+  });
+
+  it('should handle multiple navigations', () => {
+    const service = TestBed.inject(RoutingState);
+
+    const navEnd1 = new NavigationEnd(1, '/home', '/home');
+    eventsSubject.next(navEnd1);
+
+    const navEnd2 = new NavigationEnd(2, '/about', '/about');
+    eventsSubject.next(navEnd2);
+
+    const navEnd3 = new NavigationEnd(3, '/contact', '/contact');
+    eventsSubject.next(navEnd3);
+
+    expect(service.hasHistory()).toBe(true);
+  });
+});

package/src/lib/nav/routing-state.ts

@@ -0,0 +1,26 @@
+import { Injectable, inject } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+
+@Injectable({ providedIn: 'root' })
+export class RoutingState {
+  private history: string[] = [];
+
+  constructor() {
+    const router = inject(Router);
+
+    router.events.subscribe({
+      next: (event) => {
+        if (event instanceof NavigationEnd) {
+          this.history = [...this.history, event.urlAfterRedirects];
+          if (this.history.length > 2) {
+            this.history.slice(this.history.length - 2, this.history.length);
+          }
+        }
+      },
+    });
+  }
+
+  public hasHistory(): boolean {
+    return this.history.length > 1;
+  }
+}

package/src/lib/services/index.ts

@@ -0,0 +1,3 @@
+export * from './top-menu.service';
+export * from './ng-module-preloader.service';
+export * from './sneat-nav.service';

package/src/lib/services/ng-module-preloader.service.spec.ts

@@ -0,0 +1,72 @@
+import { TestBed } from '@angular/core/testing';
+// import { describe, beforeEach, it, expect } from 'vitest';
+
+import { NgModulePreloaderService } from './ng-module-preloader.service';
+
+describe('NgModulePreloaderService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: NgModulePreloaderService = TestBed.inject(
+      NgModulePreloaderService,
+    );
+    expect(service).toBeTruthy();
+  });
+
+  it('should add preload configs', () => {
+    const service: NgModulePreloaderService = TestBed.inject(
+      NgModulePreloaderService,
+    );
+    class MockModule {}
+    service.addPreloadConfigs({
+      id: 'test',
+      path: 'path/to/test',
+      type: MockModule,
+    });
+    // @ts-expect-error accessing private property for testing
+    expect(service.configs['test']).toEqual({
+      path: 'path/to/test',
+      type: MockModule,
+    });
+  });
+
+  it('should mark as preloaded', () => {
+    const service: NgModulePreloaderService = TestBed.inject(
+      NgModulePreloaderService,
+    );
+    service.markAsPreloaded('test-path');
+    // @ts-expect-error accessing private property for testing
+    expect(service.preloaded).toContain('test-path');
+  });
+
+  it('should warn when preload is called', () => {
+    const service: NgModulePreloaderService = TestBed.inject(
+      NgModulePreloaderService,
+    );
+    const warnSpy = vi
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    service.preload(['path1']);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Preloading is disabled'),
+    );
+    warnSpy.mockRestore();
+  });
+
+  it('should only warn once when preload is called multiple times', () => {
+    const service: NgModulePreloaderService = TestBed.inject(
+      NgModulePreloaderService,
+    );
+    const warnSpy = vi
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+
+    service.preload(['path1']);
+    service.preload(['path2']);
+    service.preload(['path3']);
+
+    // Should only warn once
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    warnSpy.mockRestore();
+  });
+});

package/src/lib/services/ng-module-preloader.service.ts

@@ -0,0 +1,125 @@
+import { Injectable, Type } from '@angular/core';
+
+export type PreloadPages =
+  | 'assets'
+  | 'contacts'
+  | 'members'
+  | 'real-estates'
+  | 'budget';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class NgModulePreloaderService {
+  private readonly preloaded: string[] = [];
+
+  /*
+		 'applicants': './pages/commune/contact/contacts/commune-contacts.page.module#CommuneContactsPageModule',
+		 'assets': './pages/commune/asset/assets/assets.module#AssetsPageModule',
+		 'commune-overview': './pages/commune/overview/commune-overview.module#CommuneOverviewPageModule',
+		 'bills': '',
+		 'budget': './pages/commune/budget/budget.module#BudgetPageModule',
+		 'staff': './pages/commune/members/staff/staff.module#StaffPageModule',
+		 'member': './pages/commune/member/member/commune-member.module#CommuneMemberPageModule',
+		 'member-new': './pages/commune/member/member-new/member-new.module#MemberNewPageModule',
+		 'members': './pages/commune/members/members/commune-members.module#CommuneMembersPageModule',
+		 'group': './pages/commune/member-group/member-group/member-group.module#MemberGrpupPageModule',
+		 'group-new': './pages/commune/member-group/member-group-new/member-group-new.module#MemberGroupNewPageModule',
+		 'groups': './pages/commune/member-group/member-groups/member-groups.module#MemberGroupsPageModule',
+		 'contact': './pages/commune/contact/contact/commune-contact.module#CommuneContactPageModule',
+		 'contact-new': './pages/commune/contact/contact-new/contact-new.module#ContactNewPageModule',
+		 'contacts': './pages/commune/contact/contacts/commune-contacts.page.module#CommuneContactsPageModule',
+		 'document': './pages/commune/document/document/commune-document.module#CommuneDocumentPageModule',
+		 'document-new': './pages/commune/document/document-new/document-new.module#DocumentNewPageModule',
+		 'documents': './pages/commune/document/documents/commune-documents.module#CommuneDocumentsPageModule',
+		 'landlords': './pages/commune/contact/contacts/commune-contacts.page.module#CommuneContactsPageModule',
+		 'lists': './shared/listus/commune/list/lists/lists.module#ListsPageModule',
+		 'pupils': './pages/commune/members/pupils/pupils.module#PupilsPageModule',
+		 'real-estates': './pages/commune/asset/real-estate/real-estate.module#RealEstatePageModule',
+		 'schedule': './pages/commune/calendar/schedule/schedule-page.module#SchedulePageModule',
+		 'tenants': './pages/commune/contact/contacts/commune-contacts.page.module#CommuneContactsPageModule',
+		 'terms': './pages/commune/term/terms/terms.module#TermsPageModule',
+		 'tasks': './pages/commune/todo/tasks/tasks-page.module#TasksPageModule',
+	 */
+  private readonly configs: Record<
+    string,
+    { path: string; type: Type<unknown> }
+  > = {}; // Use addPreloadConfigs
+
+  private warned = false;
+
+  /*
+   * https://blog.angularindepth.com/as-busy-as-a-bee-lazy-loading-in-the-angular-cli-d2812141637f
+   * https://blog.angularindepth.com/here-is-what-you-need-to-know-about-dynamic-components-in-angular-ac1e96167f9e
+   */
+  // constructor(
+  // 	// private readonly injector: Injector,
+  // 	// private loader: NgModuleFactoryLoader,
+  // ) {
+  // }
+
+  public addPreloadConfigs(
+    ...configs: {
+      id: string;
+      path: string;
+      type: Type<unknown>;
+      module?: string;
+    }[]
+  ): void {
+    configs.forEach((config) => {
+      this.configs[config.id] = { path: config.path, type: config.type };
+    });
+  }
+
+  public markAsPreloaded(path: string): void {
+    this.preloaded.push(path);
+  }
+
+  public preload(paths: string[], ms = 1000): void {
+    if (!this.warned) {
+      this.warned = true;
+      console.warn(
+        `Preloading is disabled until migrated to Ivy (delay=${ms}ms)`,
+      );
+    }
+    return; // TODO: Enable preloading once migrated to Angular Ivy
+    // setTimeout(
+    // 	() => {
+    // 		paths = paths.filter(p => !this.preloaded.includes(p));
+    // 		if (!paths.length) {
+    // 			return;
+    // 		}
+    // 		console.log('preloading:', paths);
+    // 		paths.forEach(p => {
+    // 			if (this.preloaded.includes(p)) {
+    // 				return;
+    // 			}
+    // 			const config = this.configs[p];
+    // 			if (!config) {
+    // 				console.error('Unknown preload id:', p);
+    // 				return;
+    // 			}
+    // 				this.loader.load(config.path)
+    // 					.then((factory) => {
+    // 						console.log('preloaded:', factory);
+    // 						this.preloaded.push(p);
+    // 						if (config.type) {
+    // 							try {
+    // 								const module = factory.create(this.injector);
+    // 								const cf = module.componentFactoryResolver.resolveComponentFactory(config.type);
+    // 								const cr = cf.create(this.injector);
+    // 								cr.destroy();
+    // 							} catch (e) {
+    // 								console.error(`Failed to create or destroy preloaded component ${config.path}:`, e);
+    // 							}
+    // 						}
+    // 					})
+    // 					.catch(err => {
+    // 						console.error('Failed to preload NG module:', err);
+    // 					});
+    // 		});
+    // 	},
+    // 	ms,
+    // );
+  }
+}

package/src/lib/services/sneat-nav.service.spec.ts

@@ -0,0 +1,95 @@
+import { TestBed } from '@angular/core/testing';
+import { NavigationEnd, Router, Event } from '@angular/router';
+import { Location } from '@angular/common';
+import { NavController } from '@ionic/angular/standalone';
+import { Subject } from 'rxjs';
+import { SneatNavService } from './sneat-nav.service';
+
+describe('SneatNavService', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        SneatNavService,
+        {
+          provide: Router,
+          useValue: { events: new Subject() },
+        },
+        { provide: Location, useValue: { back: vi.fn() } },
+        { provide: NavController, useValue: { pop: vi.fn() } },
+      ],
+    });
+  });
+
+  it('should be created', () => {
+    expect(TestBed.inject(SneatNavService)).toBeTruthy();
+  });
+
+  it('should navigateByUrl when no previous page exists', () => {
+    const service = TestBed.inject(SneatNavService);
+    const router = TestBed.inject(Router);
+    router.navigateByUrl = vi.fn().mockReturnValue(Promise.resolve(true));
+
+    service.goBack('/home');
+
+    expect(router.navigateByUrl).toHaveBeenCalledWith('/home', undefined);
+  });
+
+  it('should call navController.pop when previous page exists', async () => {
+    const router = TestBed.inject(Router);
+    const eventsSubject = router.events as Subject<Event>;
+    const service = TestBed.inject(SneatNavService);
+
+    // Simulate navigation end
+    const navEnd = new NavigationEnd(1, '/prev', '/prev');
+    eventsSubject.next(navEnd);
+
+    const navController = TestBed.inject(NavController);
+    navController.pop = vi.fn().mockReturnValue(Promise.resolve(true));
+
+    service.goBack('/home');
+
+    expect(navController.pop).toHaveBeenCalled();
+  });
+
+  it('should call location.back when navController.pop fails', async () => {
+    const router = TestBed.inject(Router);
+    const eventsSubject = router.events as Subject<Event>;
+    const service = TestBed.inject(SneatNavService);
+
+    // Simulate navigation end
+    const navEnd = new NavigationEnd(1, '/prev', '/prev');
+    eventsSubject.next(navEnd);
+
+    const navController = TestBed.inject(NavController);
+    navController.pop = vi.fn().mockReturnValue(Promise.resolve(false));
+    const location = TestBed.inject(Location);
+
+    service.goBack('/home');
+
+    // Wait for promise
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(location.back).toHaveBeenCalled();
+  });
+
+  it('should handle navigation error when no previous page exists', async () => {
+    const service = TestBed.inject(SneatNavService);
+    const router = TestBed.inject(Router);
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+    const error = new Error('Navigation failed');
+    router.navigateByUrl = vi.fn().mockReturnValue(Promise.reject(error));
+
+    service.goBack('/home');
+
+    // Wait for promise to reject
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'SneatNavService.goBack() - failed to navigate',
+      error,
+    );
+    consoleErrorSpy.mockRestore();
+  });
+});

package/src/lib/services/sneat-nav.service.ts

@@ -0,0 +1,46 @@
+import { Location } from '@angular/common';
+import { Injectable, inject } from '@angular/core';
+import {
+  NavigationBehaviorOptions,
+  NavigationEnd,
+  Router,
+  UrlTree,
+} from '@angular/router';
+import { NavController } from '@ionic/angular/standalone';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SneatNavService {
+  private readonly router = inject(Router);
+  private readonly location = inject(Location);
+  private readonly navController = inject(NavController);
+
+  private previous?: NavigationEnd;
+
+  constructor() {
+    const router = this.router;
+
+    router.events.subscribe((event) => {
+      if (event instanceof NavigationEnd) {
+        this.previous = event;
+      }
+    });
+  }
+
+  goBack(url: string | UrlTree, extras?: NavigationBehaviorOptions): void {
+    if (this.previous) {
+      this.navController.pop().then((isPopped) => {
+        if (!isPopped) {
+          this.location.back();
+        }
+      });
+    } else {
+      this.router
+        .navigateByUrl(url, extras)
+        .catch((err) =>
+          console.error('SneatNavService.goBack() - failed to navigate', err),
+        );
+    }
+  }
+}

package/src/lib/services/top-menu.service.spec.ts

@@ -0,0 +1,42 @@
+import { TestBed } from '@angular/core/testing';
+
+import { TopMenuService } from './top-menu.service';
+
+describe('TopMenuService', () => {
+  let service: TopMenuService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(TopMenuService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should update visibility when visibilityChanged is called', () => {
+    const mockEvent = {
+      detail: { visible: true },
+    } as unknown as CustomEvent;
+
+    let isVisible: boolean | undefined;
+    let isHidden: boolean | undefined;
+
+    service.isTopMenuVisible.subscribe((v) => (isVisible = v));
+    service.isTopMenuHidden.subscribe((v) => (isHidden = v));
+
+    service.visibilityChanged(mockEvent);
+
+    expect(isVisible).toBe(true);
+    expect(isHidden).toBe(false);
+
+    const mockEventHidden = {
+      detail: { visible: false },
+    } as unknown as CustomEvent;
+
+    service.visibilityChanged(mockEventHidden);
+
+    expect(isVisible).toBe(false);
+    expect(isHidden).toBe(true);
+  });
+});

package/src/lib/services/top-menu.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TopMenuService {
+  private $isTopMenuVisible = new BehaviorSubject<boolean>(false);
+  private $isTopMenuHidden = new BehaviorSubject<boolean>(true);
+
+  public readonly isTopMenuVisible = this.$isTopMenuVisible.asObservable();
+  public readonly isTopMenuHidden = this.$isTopMenuHidden.asObservable();
+
+  public readonly visibilityChanged = (event: Event): void => {
+    const visible = !!(event as CustomEvent).detail['visible'];
+    this.$isTopMenuVisible.next(visible);
+    this.$isTopMenuHidden.next(!visible);
+  };
+}

package/src/lib/sneat-enum-keys.ts

@@ -0,0 +1,2 @@
+// https://stackoverflow.com/questions/50376977/generic-type-to-get-enum-keys-as-union-string-in-typescript
+export type EnumAsUnionOfKeys<TEnum> = keyof TEnum;

package/src/lib/sneat-extensions.spec.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ISneatExtension,
+  defaultFamilyExtension,
+  defaultFamilyMemberExtensions,
+} from './sneat-extensions';
+
+describe('Sneat Extensions', () => {
+  describe('defaultFamilyExtension', () => {
+    it('should be an array', () => {
+      expect(Array.isArray(defaultFamilyExtension)).toBe(true);
+    });
+
+    it('should have 4 extensions', () => {
+      expect(defaultFamilyExtension).toHaveLength(4);
+    });
+
+    it('should contain assets extension', () => {
+      const assets = defaultFamilyExtension.find((ext) => ext.id === 'assets');
+      expect(assets).toBeDefined();
+      expect(assets?.title).toBe('Assets');
+      expect(assets?.emoji).toBe('🏡');
+    });
+
+    it('should contain calendarium extension', () => {
+      const calendarium = defaultFamilyExtension.find(
+        (ext) => ext.id === 'calendarium',
+      );
+      expect(calendarium).toBeDefined();
+      expect(calendarium?.title).toBe('Calendar');
+      expect(calendarium?.emoji).toBe('🗓️');
+    });
+
+    it('should contain documents extension', () => {
+      const documents = defaultFamilyExtension.find(
+        (ext) => ext.id === 'documents',
+      );
+      expect(documents).toBeDefined();
+      expect(documents?.title).toBe('Documents');
+      expect(documents?.emoji).toBe('📄');
+    });
+
+    it('should contain sizes extension', () => {
+      const sizes = defaultFamilyExtension.find((ext) => ext.id === 'sizes');
+      expect(sizes).toBeDefined();
+      expect(sizes?.title).toBe('Sizes');
+      expect(sizes?.emoji).toBe('📏');
+    });
+
+    it('should have all valid ISneatExtension objects', () => {
+      defaultFamilyExtension.forEach((ext: ISneatExtension) => {
+        expect(ext.id).toBeDefined();
+        expect(typeof ext.id).toBe('string');
+        expect(ext.title).toBeDefined();
+        expect(typeof ext.title).toBe('string');
+        expect(ext.emoji).toBeDefined();
+        expect(typeof ext.emoji).toBe('string');
+      });
+    });
+  });
+
+  describe('defaultFamilyMemberExtensions', () => {
+    it('should be an array', () => {
+      expect(Array.isArray(defaultFamilyMemberExtensions)).toBe(true);
+    });
+
+    it('should have 4 extensions', () => {
+      expect(defaultFamilyMemberExtensions).toHaveLength(4);
+    });
+
+    it('should contain assets extension', () => {
+      const assets = defaultFamilyMemberExtensions.find(
+        (ext) => ext.id === 'assets',
+      );
+      expect(assets).toBeDefined();
+      expect(assets?.title).toBe('Assets');
+      expect(assets?.emoji).toBe('🏡');
+    });
+
+    it('should contain calendarium extension', () => {
+      const calendarium = defaultFamilyMemberExtensions.find(
+        (ext) => ext.id === 'calendarium',
+      );
+      expect(calendarium).toBeDefined();
+      expect(calendarium?.title).toBe('Calendar');
+      expect(calendarium?.emoji).toBe('🗓️');
+    });
+
+    it('should contain documents extension', () => {
+      const documents = defaultFamilyMemberExtensions.find(
+        (ext) => ext.id === 'documents',
+      );
+      expect(documents).toBeDefined();
+      expect(documents?.title).toBe('Documents');
+      expect(documents?.emoji).toBe('📄');
+    });
+
+    it('should contain sizes extension', () => {
+      const sizes = defaultFamilyMemberExtensions.find(
+        (ext) => ext.id === 'sizes',
+      );
+      expect(sizes).toBeDefined();
+      expect(sizes?.title).toBe('Sizes');
+      expect(sizes?.emoji).toBe('📏');
+    });
+
+    it('should have all valid ISneatExtension objects', () => {
+      defaultFamilyMemberExtensions.forEach((ext: ISneatExtension) => {
+        expect(ext.id).toBeDefined();
+        expect(typeof ext.id).toBe('string');
+        expect(ext.title).toBeDefined();
+        expect(typeof ext.title).toBe('string');
+        expect(ext.emoji).toBeDefined();
+        expect(typeof ext.emoji).toBe('string');
+      });
+    });
+
+    it('should have same extensions as defaultFamilyExtension', () => {
+      expect(defaultFamilyMemberExtensions.length).toBe(
+        defaultFamilyExtension.length,
+      );
+      defaultFamilyExtension.forEach((ext) => {
+        expect(defaultFamilyMemberExtensions).toContainEqual(ext);
+      });
+    });
+  });
+});