@sneat/core 0.1.0

package/eslint.config.js

@@ -0,0 +1,7 @@
+const baseConfig = require('../../eslint.config.js');
+const { sneatLibConfig } = require('../../eslint.lib.config.js');
+
+module.exports = [
+  ...baseConfig,
+  ...sneatLibConfig(__dirname),
+];

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/libs/core",
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@sneat/core",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": ">=21.0.0",
+    "@angular/core": ">=21.0.0"
+  },
+  "dependencies": {
+    "tslib": "2.8.1"
+  }
+}

package/project.json

@@ -0,0 +1,38 @@
+{
+  "name": "core",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "projectType": "library",
+  "sourceRoot": "libs/core/src",
+  "prefix": "sneat",
+  "targets": {
+    "build": {
+      "executor": "@nx/angular:ng-packagr-lite",
+      "outputs": [
+        "{workspaceRoot}/dist/libs/core"
+      ],
+      "options": {
+        "project": "libs/core/ng-package.json",
+        "tsConfig": "libs/core/tsconfig.lib.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "libs/core/tsconfig.lib.prod.json"
+        },
+        "development": {}
+      },
+      "defaultConfiguration": "production"
+    },
+    "test": {
+      "executor": "@nx/vitest:test",
+      "outputs": [
+        "{workspaceRoot}/coverage/libs/core"
+      ],
+      "options": {
+        "tsConfig": "libs/core/tsconfig.spec.json"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './lib';

package/src/lib/analytics.interface.ts

@@ -0,0 +1,34 @@
+import { InjectionToken } from '@angular/core';
+
+export interface IAnalyticsCallOptions {
+  // If true, this config or event call applies globally to all analytics properties on the page.
+  // This is from Firebase Analytics https://firebase.google.com/docs/reference/js/analytics.md#logevent_d5f1743
+  global: boolean;
+}
+
+export type UserProperties = Record<string, unknown>;
+
+/*
+ * An interface for analytics service
+ */
+export interface IAnalyticsService {
+  logEvent(
+    eventName: string,
+    eventParams?: Readonly<Record<string, unknown>>,
+    options?: IAnalyticsCallOptions,
+  ): void;
+
+  identify(
+    userID: string,
+    userPropertiesToSet?: UserProperties,
+    userPropertiesToSetOnce?: UserProperties,
+  ): void;
+
+  loggedOut(): void;
+
+  setCurrentScreen(screenName: string, options?: IAnalyticsCallOptions): void;
+}
+
+export const AnalyticsService = new InjectionToken<IAnalyticsService>(
+  'IAnalyticsService',
+);

package/src/lib/animations/form-animations.spec.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { formNexInAnimation } from './form-animations';
+
+describe('form-animations', () => {
+  describe('formNexInAnimation', () => {
+    it('should be defined', () => {
+      expect(formNexInAnimation).toBeDefined();
+    });
+
+    it('should have trigger name "formNextIn"', () => {
+      // Angular animation triggers have a name property
+      // @ts-expect-error - accessing internal property for testing
+      expect(formNexInAnimation.name).toBe('formNextIn');
+    });
+
+    it('should have definitions array', () => {
+      // @ts-expect-error - accessing internal property for testing
+      expect(Array.isArray(formNexInAnimation.definitions)).toBe(true);
+    });
+
+    it('should have at least one definition', () => {
+      // @ts-expect-error - accessing internal property for testing
+      expect(formNexInAnimation.definitions.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/lib/animations/form-animations.ts

@@ -0,0 +1,11 @@
+import { animate, style, transition, trigger } from '@angular/animations';
+
+export const formNexInAnimation = trigger('formNextIn', [
+  transition(':enter', [
+    style({ opacity: 0 }), // initial styles
+    animate(
+      '250ms',
+      style({ opacity: 1 }), // final style after the transition has finished
+    ),
+  ]),
+]);

package/src/lib/animations/index.ts

@@ -0,0 +1,2 @@
+export * from './list-animations';
+export * from './form-animations';

package/src/lib/animations/list-animations.spec.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { listItemAnimations, listAddRemoveAnimation } from './list-animations';
+
+describe('list-animations', () => {
+  describe('listItemAnimations', () => {
+    it('should be defined', () => {
+      expect(listItemAnimations).toBeDefined();
+    });
+
+    it('should have trigger name "listItem"', () => {
+      // Angular animation triggers have a name property
+      // @ts-expect-error - accessing internal property for testing
+      expect(listItemAnimations.name).toBe('listItem');
+    });
+
+    it('should have definitions array', () => {
+      // @ts-expect-error - accessing internal property for testing
+      expect(Array.isArray(listItemAnimations.definitions)).toBe(true);
+    });
+
+    it('should have multiple definitions for add and remove', () => {
+      // @ts-expect-error - accessing internal property for testing
+      expect(listItemAnimations.definitions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('listAddRemoveAnimation', () => {
+    it('should be defined', () => {
+      expect(listAddRemoveAnimation).toBeDefined();
+    });
+
+    it('should be an array', () => {
+      expect(Array.isArray(listAddRemoveAnimation)).toBe(true);
+    });
+
+    it('should have at least one animation trigger', () => {
+      expect(listAddRemoveAnimation.length).toBeGreaterThan(0);
+    });
+
+    it('should have trigger name "addRemove"', () => {
+      // @ts-expect-error - accessing internal property for testing
+      expect(listAddRemoveAnimation[0].name).toBe('addRemove');
+    });
+
+    it('should have definitions array in the first trigger', () => {
+      // @ts-expect-error - accessing internal property for testing
+      expect(Array.isArray(listAddRemoveAnimation[0].definitions)).toBe(true);
+    });
+  });
+});

package/src/lib/animations/list-animations.ts

@@ -0,0 +1,44 @@
+import {
+  animate,
+  AnimationTriggerMetadata,
+  style,
+  transition,
+  trigger,
+} from '@angular/animations';
+
+const removeListItemAnimation = transition('* => void', [
+  animate(
+    '0.2s ease-in-out',
+    style({
+      height: 0,
+      opacity: 0,
+    }),
+  ),
+]);
+
+const addListItemAnimation = transition('void => added', [
+  style({
+    height: 0,
+    opacity: 0,
+  }),
+  animate(
+    '0.5s ease-in',
+    style({
+      height: '*',
+      opacity: 1,
+    }),
+  ),
+]);
+
+// TODO: How it is different from listAddRemoveAnimation ?
+export const listItemAnimations = trigger('listItem', [
+  removeListItemAnimation,
+  addListItemAnimation,
+]);
+
+// TODO: How it is different from listItemAnimations ?
+export const listAddRemoveAnimation: AnimationTriggerMetadata[] = [
+  trigger('addRemove', [
+    transition(':leave', [animate('0.2s  ease-in-out', style({ height: 0 }))]),
+  ]),
+];

package/src/lib/app.service.ts

@@ -0,0 +1,33 @@
+import { InjectionToken } from '@angular/core';
+import { SpaceType } from './team-type';
+
+export type SneatApp =
+  | 'sneat'
+  | 'aaproject'
+  | 'agendum'
+  | 'class'
+  | 'contactus'
+  | 'creche'
+  | 'debtus'
+  | 'docus'
+  | 'dream7'
+  | 'feis'
+  | 'logist'
+  | 'listus'
+  | 'neighbours'
+  | 'parish'
+  | 'renterra'
+  | 'rsvp'
+  | 'sizechart'
+  | 'splitus'
+  | 'sportclubs'
+  | 'tournament'
+  | 'datatug';
+
+export interface IAppInfo {
+  readonly appId: SneatApp;
+  readonly appTitle: string;
+  readonly requiredSpaceType?: SpaceType;
+}
+
+export const APP_INFO = new InjectionToken<IAppInfo>('app_info');

package/src/lib/constants.spec.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { CurrencyList } from './constants';
+
+describe('CurrencyList', () => {
+  it('should contain USD', () => {
+    expect(CurrencyList).toContain('USD');
+  });
+
+  it('should contain EUR', () => {
+    expect(CurrencyList).toContain('EUR');
+  });
+
+  it('should have exactly 2 currencies', () => {
+    expect(CurrencyList).toHaveLength(2);
+  });
+
+  it('should be an array', () => {
+    expect(Array.isArray(CurrencyList)).toBe(true);
+  });
+});

package/src/lib/constants.ts

@@ -0,0 +1 @@
+export const CurrencyList = ['USD', 'EUR'];

package/src/lib/core-models.ts

@@ -0,0 +1,12 @@
+export interface IApiError {
+  code?: string;
+  message: string;
+}
+
+export interface IErrorResponse {
+  error: IApiError;
+}
+
+export interface IFieldError extends IApiError {
+  field: string;
+}

package/src/lib/directives/index.ts

@@ -0,0 +1 @@
+export { SneatSelectAllOnFocusDirective } from './sneat-select-all-on-focus.directive';

package/src/lib/directives/sneat-select-all-on-focus.directive.spec.ts

@@ -0,0 +1,142 @@
+import { Component } from '@angular/core';
+import { TestBed, ComponentFixture } from '@angular/core/testing';
+import { SneatSelectAllOnFocusDirective } from './sneat-select-all-on-focus.directive';
+import { By } from '@angular/platform-browser';
+
+@Component({
+  template: `
+    <input id="directInput" sneatSelectAllOnFocus value="test" />
+    <div id="container" sneatSelectAllOnFocus>
+      <input id="nestedInput" value="nested test" />
+    </div>
+    <textarea id="directTextarea" sneatSelectAllOnFocus>textarea test</textarea>
+    <div id="textareaContainer" sneatSelectAllOnFocus>
+      <textarea id="nestedTextarea">nested textarea</textarea>
+    </div>
+  `,
+  standalone: true,
+  imports: [SneatSelectAllOnFocusDirective],
+})
+class TestHostComponent {}
+
+describe('SneatSelectAllOnFocusDirective', () => {
+  let fixture: ComponentFixture<TestHostComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [TestHostComponent],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(TestHostComponent);
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(fixture.componentInstance).toBeTruthy();
+  });
+
+  it('should select text on focus of input element', () => {
+    const inputEl = fixture.debugElement.query(By.css('#directInput'));
+    const directive = inputEl.injector.get(SneatSelectAllOnFocusDirective);
+    const input = inputEl.nativeElement as HTMLInputElement;
+    input.setSelectionRange = vi.fn();
+
+    directive.selectAll();
+
+    expect(input.setSelectionRange).toHaveBeenCalledWith(0, input.value.length);
+  });
+
+  it('should select text on focus of container element', () => {
+    const containerEl = fixture.debugElement.query(By.css('#container'));
+    const directive = containerEl.injector.get(SneatSelectAllOnFocusDirective);
+    const nestedInput = containerEl.nativeElement.querySelector(
+      'input',
+    ) as HTMLInputElement;
+    nestedInput.setSelectionRange = vi.fn();
+
+    directive.selectAll();
+
+    expect(nestedInput.setSelectionRange).toHaveBeenCalledWith(
+      0,
+      nestedInput.value.length,
+    );
+  });
+
+  it('should handle setSelectionRange failure and fallback to select()', () => {
+    const inputEl = fixture.debugElement.query(By.css('#directInput'));
+    const directive = inputEl.injector.get(SneatSelectAllOnFocusDirective);
+    const input = inputEl.nativeElement as HTMLInputElement;
+    const consoleWarnSpy = vi
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+
+    // Mock setSelectionRange to throw error
+    input.setSelectionRange = vi.fn().mockImplementation(() => {
+      throw new Error('setSelectionRange not supported');
+    });
+    input.select = vi.fn();
+
+    directive.selectAll();
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'Element does not support setSelectionRange',
+    );
+    expect(input.select).toHaveBeenCalled();
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('should select text on focus of textarea element', () => {
+    const textareaEl = fixture.debugElement.query(By.css('#directTextarea'));
+    const directive = textareaEl.injector.get(SneatSelectAllOnFocusDirective);
+    const textarea = textareaEl.nativeElement as HTMLTextAreaElement;
+    textarea.setSelectionRange = vi.fn();
+
+    directive.selectAll();
+
+    expect(textarea.setSelectionRange).toHaveBeenCalledWith(
+      0,
+      textarea.value.length,
+    );
+  });
+
+  it('should select text on focus of container with nested textarea', () => {
+    const containerEl = fixture.debugElement.query(
+      By.css('#textareaContainer'),
+    );
+    const directive = containerEl.injector.get(SneatSelectAllOnFocusDirective);
+    const nestedTextarea = containerEl.nativeElement.querySelector(
+      'textarea',
+    ) as HTMLTextAreaElement;
+    nestedTextarea.setSelectionRange = vi.fn();
+
+    directive.selectAll();
+
+    expect(nestedTextarea.setSelectionRange).toHaveBeenCalledWith(
+      0,
+      nestedTextarea.value.length,
+    );
+  });
+
+  it('should handle textarea when setSelectionRange fails', () => {
+    const textareaEl = fixture.debugElement.query(By.css('#directTextarea'));
+    const directive = textareaEl.injector.get(SneatSelectAllOnFocusDirective);
+    const textarea = textareaEl.nativeElement as HTMLTextAreaElement;
+    const consoleWarnSpy = vi
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+
+    // Mock setSelectionRange to throw error
+    textarea.setSelectionRange = vi.fn().mockImplementation(() => {
+      throw new Error('setSelectionRange not supported');
+    });
+    textarea.select = vi.fn();
+
+    directive.selectAll();
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'Element does not support setSelectionRange',
+    );
+    expect(textarea.select).toHaveBeenCalled();
+    consoleWarnSpy.mockRestore();
+  });
+});

package/src/lib/directives/sneat-select-all-on-focus.directive.ts

@@ -0,0 +1,36 @@
+import { Directive, ElementRef, HostListener, inject } from '@angular/core';
+
+@Directive({
+  selector: '[sneatSelectAllOnFocus]',
+})
+export class SneatSelectAllOnFocusDirective {
+  private readonly el = inject(ElementRef);
+
+  @HostListener('focus', ['$event.target'])
+  public selectAll(_target?: EventTarget | null) {
+    const nativeElement = this.el.nativeElement;
+    const input =
+      nativeElement instanceof HTMLInputElement ||
+      nativeElement instanceof HTMLTextAreaElement
+        ? nativeElement
+        : nativeElement.querySelector('input') ||
+          nativeElement.querySelector('textarea');
+
+    if (input) {
+      if ('setSelectionRange' in input) {
+        try {
+          input.setSelectionRange(0, (input as HTMLInputElement).value.length);
+          return;
+        } catch {
+          console.warn('Element does not support setSelectionRange');
+        }
+      }
+      if (
+        input instanceof HTMLInputElement ||
+        input instanceof HTMLTextAreaElement
+      ) {
+        input.select();
+      }
+    }
+  }
+}

package/src/lib/environment-config.ts

@@ -0,0 +1,54 @@
+import { InjectionToken } from '@angular/core';
+import { BrowserOptions } from '@sentry/browser';
+import { PostHogConfig } from 'posthog-js';
+
+export interface IFirebaseEmulatorConfig {
+  authPort: number;
+  authHost?: string;
+  firestorePort: number;
+  firestoreHost?: string;
+}
+
+export interface IFirebaseConfig {
+  emulator?: IFirebaseEmulatorConfig;
+  //
+  projectId: string;
+  appId: string;
+  measurementId?: string;
+  messagingSenderId?: string;
+  apiKey: string;
+  authDomain: string;
+  databaseURL?: string;
+  storageBucket?: string;
+}
+
+type OnlyValidKeys<T, Shape> = T extends Shape
+  ? Exclude<keyof T, keyof Shape> extends never
+    ? T
+    : never
+  : never;
+
+export interface IPosthogSettings {
+  readonly token: string;
+  readonly config?: OnlyValidKeys<
+    Partial<PostHogConfig>,
+    Partial<PostHogConfig>
+  >;
+}
+
+export interface IEnvironmentConfig {
+  production: boolean;
+  useNgrok?: boolean;
+  posthog?: IPosthogSettings;
+  sentry?: BrowserOptions;
+  agents: Record<string, string>;
+  firebaseConfig: IFirebaseConfig;
+  firebaseBaseUrl?: string;
+}
+
+export const FirebaseConfigToken = new InjectionToken<IFirebaseConfig>(
+  'firebaseConfig',
+);
+export const EnvConfigToken = new InjectionToken<IEnvironmentConfig>(
+  'envConfig',
+);

package/src/lib/eq.spec.ts

@@ -0,0 +1,24 @@
+import { eq } from './eq';
+import { describe, it, expect } from 'vitest';
+
+describe('eq', () => {
+  it('should return true if both are undefined', () => {
+    expect(eq(undefined, undefined)).toBe(true);
+  });
+
+  it('should return true if both are null', () => {
+    expect(eq(null as unknown, null as unknown)).toBe(true);
+  });
+
+  it('should return true if both are same string', () => {
+    expect(eq('a', 'a')).toBe(true);
+  });
+
+  it('should return false if strings differ', () => {
+    expect(eq('a', 'b')).toBe(false);
+  });
+
+  it('should return true if one is null and other is undefined', () => {
+    expect(eq(null as unknown, undefined)).toBe(true);
+  });
+});

package/src/lib/eq.ts

@@ -0,0 +1 @@
+export const eq = <T = string | number>(x?: T, y?: T) => (!x && !y) || x === y;