@sneat/core 0.1.0

package/src/lib/sneat-extensions.ts

@@ -0,0 +1,49 @@
+export interface ISneatExtension {
+  id: string;
+  title: string;
+  emoji: string;
+}
+
+const assetsExtension: ISneatExtension = {
+  id: 'assets',
+  title: 'Assets',
+  emoji: '🏡',
+};
+
+// const contactsExtension: ISneatExtension = {
+// 	id: 'contacts',
+// 	title: 'Contacts',
+// 	emoji: '📇'
+// }
+
+const documentsExtension: ISneatExtension = {
+  id: 'documents',
+  title: 'Documents',
+  emoji: '📄',
+};
+
+const sizesExtension: ISneatExtension = {
+  id: 'sizes',
+  title: 'Sizes',
+  emoji: '📏',
+};
+
+const calendariumExtension: ISneatExtension = {
+  id: 'calendarium',
+  title: 'Calendar',
+  emoji: '🗓️',
+};
+
+export const defaultFamilyExtension: ISneatExtension[] = [
+  assetsExtension,
+  calendariumExtension,
+  documentsExtension,
+  sizesExtension,
+];
+
+export const defaultFamilyMemberExtensions: ISneatExtension[] = [
+  assetsExtension,
+  calendariumExtension,
+  documentsExtension,
+  sizesExtension,
+];

package/src/lib/store.spec.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect } from 'vitest';
+import {
+  STORE_ID_FIRESTORE,
+  STORE_TYPE_FIRESTORE,
+  STORE_TYPE_GITHUB,
+  STORE_ID_GITHUB_COM,
+  GITLAB_REPO_PREFIX,
+  storeCanProvideListOfProjects,
+  storeRefToId,
+  parseStoreRef,
+  IStoreRef,
+} from './store';
+
+describe('store', () => {
+  describe('constants', () => {
+    it('should have correct value for STORE_ID_FIRESTORE', () => {
+      expect(STORE_ID_FIRESTORE).toBe('firestore');
+    });
+
+    it('should have correct value for STORE_TYPE_FIRESTORE', () => {
+      expect(STORE_TYPE_FIRESTORE).toBe('firestore');
+    });
+
+    it('should have correct value for STORE_TYPE_GITHUB', () => {
+      expect(STORE_TYPE_GITHUB).toBe('github');
+    });
+
+    it('should have correct value for STORE_ID_GITHUB_COM', () => {
+      expect(STORE_ID_GITHUB_COM).toBe('github.com');
+    });
+
+    it('should have correct value for GITLAB_REPO_PREFIX', () => {
+      expect(GITLAB_REPO_PREFIX).toBe('gitlab.');
+    });
+  });
+
+  describe('storeCanProvideListOfProjects', () => {
+    it('should return false for firestore store', () => {
+      expect(storeCanProvideListOfProjects(STORE_ID_FIRESTORE)).toBe(false);
+    });
+
+    it('should return false for github.com store', () => {
+      expect(storeCanProvideListOfProjects(STORE_ID_GITHUB_COM)).toBe(false);
+    });
+
+    it('should return true for custom store', () => {
+      expect(storeCanProvideListOfProjects('custom-store')).toBe(true);
+    });
+
+    it('should return true for gitlab store', () => {
+      expect(storeCanProvideListOfProjects('gitlab.example.com')).toBe(true);
+    });
+  });
+
+  describe('storeRefToId', () => {
+    it('should return type for firestore without url', () => {
+      const ref: IStoreRef = { type: 'firestore' };
+      expect(storeRefToId(ref)).toBe('firestore');
+    });
+
+    it('should return url for firestore with url', () => {
+      const ref: IStoreRef = { type: 'firestore', url: 'custom-firestore' };
+      expect(storeRefToId(ref)).toBe('custom-firestore');
+    });
+
+    it('should return type for github without url', () => {
+      const ref: IStoreRef = { type: 'github' };
+      expect(storeRefToId(ref)).toBe('github');
+    });
+
+    it('should return url for github with url', () => {
+      const ref: IStoreRef = { type: 'github', url: 'github.com' };
+      expect(storeRefToId(ref)).toBe('github.com');
+    });
+
+    it('should return url for gitlab with url', () => {
+      const ref: IStoreRef = { type: 'gitlab', url: 'gitlab.example.com' };
+      expect(storeRefToId(ref)).toBe('gitlab.example.com');
+    });
+
+    it('should throw error for gitlab without url', () => {
+      const ref: IStoreRef = { type: 'gitlab' };
+      expect(() => storeRefToId(ref)).toThrow(
+        'store with type "agent" must have URL',
+      );
+    });
+
+    it('should return url for agent with url', () => {
+      const ref: IStoreRef = { type: 'agent', url: 'http://example.com' };
+      expect(storeRefToId(ref)).toBe('http://example.com');
+    });
+
+    it('should throw error for agent without url', () => {
+      const ref: IStoreRef = { type: 'agent' };
+      expect(() => storeRefToId(ref)).toThrow(
+        'store with type "agent" must have URL',
+      );
+    });
+
+    it('should return empty string for browser type', () => {
+      const ref: IStoreRef = { type: 'browser' };
+      expect(storeRefToId(ref)).toBe('');
+    });
+  });
+
+  describe('parseStoreRef', () => {
+    it('should throw error for undefined storeId', () => {
+      expect(() => parseStoreRef(undefined)).toThrow(
+        'storeId is a required parameter',
+      );
+    });
+
+    it('should throw error for empty storeId', () => {
+      expect(() => parseStoreRef('')).toThrow(
+        'storeId is a required parameter',
+      );
+    });
+
+    it('should parse firestore store', () => {
+      const result = parseStoreRef('firestore');
+      expect(result).toEqual({ type: 'firestore' });
+    });
+
+    it('should parse github store', () => {
+      const result = parseStoreRef('github');
+      expect(result).toEqual({ type: 'github' });
+    });
+
+    it('should parse github.com as github type', () => {
+      const result = parseStoreRef('github.com');
+      expect(result).toEqual({ type: 'github' });
+    });
+
+    it('should parse http- prefix as agent with http url', () => {
+      const result = parseStoreRef('http-example.com');
+      expect(result).toEqual({ type: 'agent', url: 'http://example.com' });
+    });
+
+    it('should parse https- prefix as agent with https url', () => {
+      const result = parseStoreRef('https-example.com');
+      expect(result).toEqual({ type: 'agent', url: 'https://example.com' });
+    });
+
+    it('should throw error for unsupported format', () => {
+      expect(() => parseStoreRef('unsupported-format')).toThrow(
+        'unsupported format of store id:unsupported-format',
+      );
+    });
+
+    it('should throw error for random string', () => {
+      expect(() => parseStoreRef('random-string')).toThrow(
+        'unsupported format of store id:random-string',
+      );
+    });
+  });
+});

package/src/lib/store.ts

@@ -0,0 +1,54 @@
+// Migrated
+export const STORE_ID_FIRESTORE = 'firestore';
+export const STORE_TYPE_FIRESTORE = 'firestore';
+
+export const STORE_TYPE_GITHUB = 'github';
+export const STORE_ID_GITHUB_COM = 'github.com';
+
+export const GITLAB_REPO_PREFIX = 'gitlab.';
+
+export function storeCanProvideListOfProjects(storeId: string): boolean {
+  return !(storeId === STORE_ID_FIRESTORE || storeId === STORE_ID_GITHUB_COM);
+}
+
+export type StoreType = 'firestore' | 'agent' | 'browser' | 'github' | 'gitlab';
+
+export interface IStoreRef {
+  type: StoreType;
+  id?: string;
+  url?: string;
+}
+
+export function storeRefToId(ref: IStoreRef): string {
+  switch (ref.type) {
+    case 'firestore':
+    case 'github':
+      return ref.url || ref.type;
+    case 'gitlab':
+    case 'agent':
+      if (ref.url) {
+        return ref.url;
+      }
+      throw new Error('store with type "agent" must have URL');
+    default:
+      return ``;
+  }
+}
+
+export function parseStoreRef(storeId?: string): IStoreRef {
+  if (!storeId) {
+    throw new Error('storeId is a required parameter');
+  }
+  switch (storeId) {
+    case 'firestore':
+    case 'github':
+      return { type: storeId };
+    case 'github.com':
+      return { type: 'github' };
+    default:
+      if (storeId.startsWith('http-') || storeId.startsWith('https-')) {
+        return { type: 'agent', url: storeId.replace('-', '://') };
+      }
+      throw new Error('unsupported format of store id:' + storeId);
+  }
+}

package/src/lib/team-type.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+import { SpaceTypeFamily } from './team-type';
+
+describe('team-type', () => {
+  it('should have correct value for SpaceTypeFamily', () => {
+    expect(SpaceTypeFamily).toBe('family');
+  });
+});

package/src/lib/team-type.ts

@@ -0,0 +1,13 @@
+export const SpaceTypeFamily = 'family';
+
+export type SpaceType =
+  | 'family'
+  | 'private'
+  | 'company'
+  | 'team'
+  | 'parish'
+  | 'educator'
+  | 'realtor'
+  | 'sport_club'
+  | 'cohabit'
+  | 'unknown';

package/src/lib/testing/base-test-setup.ts

@@ -0,0 +1,247 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import '@analogjs/vitest-angular/setup-zone';
+import { TestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+
+export function setupAngularTestingEnvironment() {
+  try {
+    TestBed.initTestEnvironment(
+      BrowserDynamicTestingModule,
+      platformBrowserDynamicTesting(),
+    );
+  } catch {
+    // ignore
+  }
+}
+
+export function setupGlobalMocks() {
+  if (typeof window !== 'undefined') {
+    // Wrap URL constructor to handle invalid bases gracefully (fixes Ionic/Stencil asset loading in tests)
+    const OriginalURL = (window as any).URL;
+    (window as any).URL = class extends OriginalURL {
+      constructor(url: string, base?: string | URL) {
+        try {
+          super(url, base);
+        } catch {
+          // If the base is invalid, try with a default base
+          try {
+            super(url, 'http://localhost/');
+          } catch {
+            // If URL is completely invalid, fall back to localhost with the path
+            // This handles cases where Ionic/Stencil tries to load assets in tests
+            const fallbackUrl = url.startsWith('/') ? `http://localhost${url}` : 'http://localhost/';
+            super(fallbackUrl);
+          }
+        }
+      }
+    };
+
+    // Set document.baseURI to prevent Ionic/Stencil "Invalid URL" errors
+    if ((window as any).document) {
+      Object.defineProperty((window as any).document, 'baseURI', {
+        get: () => 'http://localhost/',
+        configurable: true,
+      });
+
+      // Ensure document.dir is defined to prevent Ionic's isRTL() from throwing
+      // "Cannot read properties of undefined (reading 'toLowerCase')"
+      if ((window as any).document.dir === undefined) {
+        (window as any).document.dir = '';
+      }
+    }
+
+    if (!(window as any).location) {
+      (window as any).location = {
+        href: 'http://localhost',
+        pathname: '/',
+        search: '',
+        hash: '',
+        host: 'localhost',
+        hostname: 'localhost',
+        origin: 'http://localhost',
+        port: '',
+        protocol: 'http:',
+        assign: () => {
+          /* ignore */
+        },
+        replace: () => {
+          /* ignore */
+        },
+        reload: () => {
+          /* ignore */
+        },
+      };
+    }
+
+    if (!window.matchMedia) {
+      Object.defineProperty(window, 'matchMedia', {
+        writable: true,
+        value: vi.fn().mockImplementation((query) => ({
+          matches: false,
+          media: query,
+          onchange: null,
+          addListener: vi.fn(), // deprecated
+          removeListener: vi.fn(), // deprecated
+          addEventListener: vi.fn(),
+          removeEventListener: vi.fn(),
+          dispatchEvent: vi.fn(),
+        })),
+      });
+    }
+
+    if (!window.performance) {
+      (window as any).performance = {
+        mark: vi.fn(),
+        measure: vi.fn(),
+        clearMarks: vi.fn(),
+        getEntriesByName: vi.fn(() => []),
+        getEntriesByType: vi.fn(() => []),
+        now: vi.fn(() => Date.now()),
+      };
+    }
+
+    if (!(window as any).CSSStyleSheet) {
+      (window as any).CSSStyleSheet = class {
+        replaceSync() {
+          /* ignore */
+        }
+        replace() {
+          return Promise.resolve();
+        }
+      };
+    }
+
+    if ((window as any).CSSStyleSheet) {
+      (window as any).CSSStyleSheet.prototype.replaceSync = function () {
+        /* ignore */
+      };
+      (window as any).CSSStyleSheet.prototype.replace = function () {
+        return Promise.resolve();
+      };
+    }
+
+    // Mock Object.getOwnPropertyDescriptor(win.document.adoptedStyleSheets, "length")
+    // to avoid TypeError in Stencil: https://github.com/ionic-team/stencil/issues/5323
+    const originalGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    Object.getOwnPropertyDescriptor = function (obj, prop) {
+      if (obj === undefined || obj === null) {
+        return undefined;
+      }
+      try {
+        if (
+          obj === (window.document as any).adoptedStyleSheets &&
+          prop === 'length'
+        ) {
+          return {
+            writable: true,
+            enumerable: true,
+            configurable: true,
+            value: (obj as any).length,
+          };
+        }
+      } catch {
+        // ignore
+      }
+      try {
+        return originalGetOwnPropertyDescriptor(obj, prop);
+      } catch {
+        return undefined;
+      }
+    };
+
+    if (!(window as any).CSS) {
+      (window as any).CSS = {
+        supports: () => false,
+      };
+    }
+
+    if (!(window as any).CSSParser) {
+      (window as any).CSSParser = class {
+        parseFromString() {
+          return {
+            cssRules: [],
+          };
+        }
+      };
+    }
+
+    const mockCollection = vi.fn().mockImplementation((...args) => {
+      const path = args
+        .map((arg) => (typeof arg === 'string' ? arg : arg?.path || 'ref'))
+        .join('/');
+      return {
+        type: 'collection',
+        path,
+        toJSON: () => ({ path }),
+      };
+    });
+
+    const mockDoc = vi.fn().mockImplementation((...args) => {
+      const path = args
+        .map((arg) => (typeof arg === 'string' ? arg : arg?.path || 'ref'))
+        .join('/');
+      return {
+        type: 'document',
+        path,
+        toJSON: () => ({ path }),
+      };
+    });
+
+    (window as any).collection = mockCollection;
+    (window as any).doc = mockDoc;
+    (global as any).collection = mockCollection;
+    (global as any).doc = mockDoc;
+
+    const MockMutationObserver = class {
+      observe() {
+        /* ignore */
+      }
+      disconnect() {
+        /* ignore */
+      }
+      takeRecords() {
+        return [];
+      }
+    };
+    (window as any).MutationObserver = MockMutationObserver;
+    (global as any).MutationObserver = MockMutationObserver;
+
+    const MockIntersectionObserver = class {
+      observe() {
+        /* ignore */
+      }
+      unobserve() {
+        /* ignore */
+      }
+      disconnect() {
+        /* ignore */
+      }
+      takeRecords() {
+        return [];
+      }
+    };
+    (window as any).IntersectionObserver = MockIntersectionObserver;
+    (global as any).IntersectionObserver = MockIntersectionObserver;
+  }
+
+  // Global mocks for fetch if not available
+  if (!global.fetch) {
+    (global as any).fetch = vi.fn().mockImplementation(() =>
+      Promise.resolve({
+        json: () => Promise.resolve({}),
+        ok: true,
+      }),
+    );
+    (global as any).Request = vi.fn();
+    (global as any).Response = vi.fn();
+    (global as any).Headers = vi.fn();
+  }
+}
+
+export function setupBaseTestEnvironment() {
+  setupAngularTestingEnvironment();
+  setupGlobalMocks();
+}

package/src/lib/testing/test-setup-light.ts

@@ -0,0 +1 @@
+import '@analogjs/vitest-angular/setup-zone';

package/src/lib/testing/test-setup.ts

@@ -0,0 +1,70 @@
+import '@analogjs/vitest-angular/setup-zone';
+import { TestBed } from '@angular/core/testing';
+import {
+  setupAngularTestingEnvironment,
+  setupGlobalMocks,
+} from './base-test-setup';
+import { ErrorLogger } from '../logging/interfaces';
+import { Firestore } from '@angular/fire/firestore';
+import { Auth } from '@angular/fire/auth';
+import { AngularFirestore } from '@angular/fire/compat/firestore';
+import { AngularFireAuth } from '@angular/fire/compat/auth';
+import { of } from 'rxjs';
+import { AnalyticsService } from '../analytics.interface';
+
+export function configureGlobalTestBed() {
+  try {
+    TestBed.configureTestingModule({
+      providers: [
+        {
+          provide: ErrorLogger,
+          useValue: {
+            logError: vi.fn(),
+            logErrorHandler: () => {
+              return vi.fn();
+            },
+          },
+        },
+        {
+          provide: Firestore,
+          useValue: {
+            type: 'Firestore',
+            toJSON: () => ({}),
+          },
+        },
+        {
+          provide: Auth,
+          useValue: {
+            onIdTokenChanged: vi.fn(() => () => void 0),
+            onAuthStateChanged: vi.fn(() => () => void 0),
+          },
+        },
+        {
+          provide: AnalyticsService,
+          useValue: {
+            logEvent: vi.fn(),
+            identify: vi.fn(),
+            loggedOut: vi.fn(),
+            setCurrentScreen: vi.fn(),
+          },
+        },
+        {
+          provide: AngularFirestore,
+          useValue: {
+            collection: () => ({ valueChanges: () => of([]) }),
+            doc: () => ({ valueChanges: () => of(null) }),
+          },
+        },
+        { provide: AngularFireAuth, useValue: { authState: of(null) } },
+      ],
+    });
+  } catch {
+    // ignore
+  }
+}
+
+export function setupTestEnvironment() {
+  setupAngularTestingEnvironment();
+  setupGlobalMocks();
+  configureGlobalTestBed();
+}

package/src/lib/types/age-group.ts

@@ -0,0 +1 @@
+export type AgeGroupID = 'adult' | 'child' | 'pet' | 'undisclosed' | 'unknown';

package/src/lib/types/gender.spec.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import {
+  GenderUndisclosed,
+  GenderUnknown,
+  GenderMale,
+  GenderFemale,
+  GenderOther,
+} from './gender';
+
+describe('Gender constants', () => {
+  it('should have correct value for GenderUndisclosed', () => {
+    expect(GenderUndisclosed).toBe('undisclosed');
+  });
+
+  it('should have correct value for GenderUnknown', () => {
+    expect(GenderUnknown).toBe('unknown');
+  });
+
+  it('should have correct value for GenderMale', () => {
+    expect(GenderMale).toBe('male');
+  });
+
+  it('should have correct value for GenderFemale', () => {
+    expect(GenderFemale).toBe('female');
+  });
+
+  it('should have correct value for GenderOther', () => {
+    expect(GenderOther).toBe('other');
+  });
+
+  it('should have all unique values', () => {
+    const values = [
+      GenderUndisclosed,
+      GenderUnknown,
+      GenderMale,
+      GenderFemale,
+      GenderOther,
+    ];
+    const uniqueValues = new Set(values);
+    expect(uniqueValues.size).toBe(values.length);
+  });
+});

package/src/lib/types/gender.ts

@@ -0,0 +1,12 @@
+export const GenderUndisclosed = 'undisclosed';
+export const GenderUnknown = 'unknown';
+export const GenderMale = 'male';
+export const GenderFemale = 'female';
+export const GenderOther = 'other';
+
+export type Gender =
+  | typeof GenderUndisclosed
+  | typeof GenderUnknown
+  | typeof GenderMale
+  | typeof GenderFemale
+  | typeof GenderOther;

package/src/lib/types/index.ts

@@ -0,0 +1,2 @@
+export * from './age-group';
+export * from './gender';