@sneat/core 0.1.3 → 0.1.4

package/src/lib/exclude-undefined.spec.ts

@@ -1,165 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  excludeUndefined,
-  excludeEmpty,
-  undefinedIfEmpty,
-  excludeZeroValues,
-} from './exclude-undefined';
-
-describe('excludeUndefined', () => {
-  it('should return the same value if input is null', () => {
-    expect(excludeUndefined(null)).toBe(null);
-  });
-
-  it('should return the same value if input is undefined', () => {
-    expect(excludeUndefined(undefined)).toBe(undefined);
-  });
-
-  it('should remove undefined values from object', () => {
-    const input = { a: 1, b: undefined, c: 'test' };
-    const result = excludeUndefined(input);
-    expect(result).toEqual({ a: 1, c: 'test' });
-  });
-
-  it('should keep null values in object', () => {
-    const input = { a: 1, b: null, c: 'test' };
-    const result = excludeUndefined(input);
-    expect(result).toEqual({ a: 1, b: null, c: 'test' });
-  });
-
-  it('should keep empty string values in object', () => {
-    const input = { a: 1, b: '', c: 'test' };
-    const result = excludeUndefined(input);
-    expect(result).toEqual({ a: 1, b: '', c: 'test' });
-  });
-
-  it('should keep zero values in object', () => {
-    const input = { a: 0, b: 'test' };
-    const result = excludeUndefined(input);
-    expect(result).toEqual({ a: 0, b: 'test' });
-  });
-
-  it('should handle empty object', () => {
-    const input = {};
-    const result = excludeUndefined(input);
-    expect(result).toEqual({});
-  });
-});
-
-describe('excludeEmpty', () => {
-  it('should return the same value if input is null', () => {
-    expect(excludeEmpty(null)).toBe(null);
-  });
-
-  it('should return the same value if input is undefined', () => {
-    expect(excludeEmpty(undefined)).toBe(undefined);
-  });
-
-  it('should remove undefined values from object', () => {
-    const input = { a: 1, b: undefined, c: 'test' };
-    const result = excludeEmpty(input);
-    expect(result).toEqual({ a: 1, c: 'test' });
-  });
-
-  it('should remove empty string values from object', () => {
-    const input = { a: 1, b: '', c: 'test' };
-    const result = excludeEmpty(input);
-    expect(result).toEqual({ a: 1, c: 'test' });
-  });
-
-  it('should keep null values in object', () => {
-    const input = { a: 1, b: null, c: 'test' };
-    const result = excludeEmpty(input);
-    expect(result).toEqual({ a: 1, b: null, c: 'test' });
-  });
-
-  it('should keep zero values in object', () => {
-    const input = { a: 0, b: 'test' };
-    const result = excludeEmpty(input);
-    expect(result).toEqual({ a: 0, b: 'test' });
-  });
-
-  it('should handle empty object', () => {
-    const input = {};
-    const result = excludeEmpty(input);
-    expect(result).toEqual({});
-  });
-});
-
-describe('undefinedIfEmpty', () => {
-  it('should return the same value if input is null', () => {
-    expect(undefinedIfEmpty(null as unknown as Record<string, unknown>)).toBe(
-      null,
-    );
-  });
-
-  it('should return the same value if input is undefined', () => {
-    expect(
-      undefinedIfEmpty(undefined as unknown as Record<string, unknown>),
-    ).toBe(undefined);
-  });
-
-  it('should return undefined for empty object', () => {
-    const input = {};
-    const result = undefinedIfEmpty(input);
-    expect(result).toBe(undefined);
-  });
-
-  it('should return the object if not empty', () => {
-    const input = { a: 1, b: 'test' };
-    const result = undefinedIfEmpty(input);
-    expect(result).toEqual({ a: 1, b: 'test' });
-  });
-
-  it('should return the object with undefined values', () => {
-    const input = { a: undefined, b: undefined };
-    const result = undefinedIfEmpty(input);
-    expect(result).toEqual({ a: undefined, b: undefined });
-  });
-});
-
-describe('excludeZeroValues', () => {
-  it('should return the same value if input is null', () => {
-    expect(excludeZeroValues(null)).toBe(null);
-  });
-
-  it('should return the same value if input is undefined', () => {
-    expect(excludeZeroValues(undefined)).toBe(undefined);
-  });
-
-  it('should remove zero values from object', () => {
-    const input = { a: 0, b: 1, c: 'test' };
-    const result = excludeZeroValues(input);
-    expect(result).toEqual({ b: 1, c: 'test' });
-  });
-
-  it('should remove undefined values from object', () => {
-    const input = { a: 1, b: undefined, c: 'test' };
-    const result = excludeZeroValues(input);
-    expect(result).toEqual({ a: 1, c: 'test' });
-  });
-
-  it('should keep empty string values in object', () => {
-    const input = { a: 1, b: '', c: 'test' };
-    const result = excludeZeroValues(input);
-    expect(result).toEqual({ a: 1, b: '', c: 'test' });
-  });
-
-  it('should keep null values in object', () => {
-    const input = { a: 1, b: null, c: 'test' };
-    const result = excludeZeroValues(input);
-    expect(result).toEqual({ a: 1, b: null, c: 'test' });
-  });
-
-  it('should handle empty object', () => {
-    const input = {};
-    const result = excludeZeroValues(input);
-    expect(result).toEqual({});
-  });
-
-  it('should handle multiple zero values', () => {
-    const input = { a: 0, b: 0, c: 1 };
-    const result = excludeZeroValues(input);
-    expect(result).toEqual({ c: 1 });
-  });
-});

package/src/lib/exclude-undefined.ts

@@ -1,47 +0,0 @@
-type O = Record<string, unknown>;
-
-export function excludeUndefined<T>(o: T): T {
-  if (!o) {
-    return o;
-  }
-  return Object.keys(o).reduce((r, k) => {
-    const v = (o as unknown as O)[k];
-    if (v !== undefined) {
-      r[k] = v;
-    }
-    return r;
-  }, {} as O) as unknown as T;
-}
-
-export function excludeEmpty<T>(o: T): T {
-  if (!o) {
-    return o;
-  }
-  return Object.keys(o).reduce((r, k) => {
-    const v = (o as unknown as O)[k];
-    if (v !== undefined && v !== '') {
-      r[k] = v;
-    }
-    return r;
-  }, {} as O) as unknown as T;
-}
-
-export function undefinedIfEmpty<T extends O>(o: T): T | undefined {
-  if (!o) {
-    return o;
-  }
-  return Object.keys(o).length === 0 ? undefined : o;
-}
-
-export function excludeZeroValues<T>(o: T): T {
-  if (!o) {
-    return o;
-  }
-  return Object.keys(o).reduce((r, k) => {
-    const v = (o as unknown as O)[k];
-    if (v !== undefined && v !== 0) {
-      r[k] = v;
-    }
-    return r;
-  }, {} as O) as unknown as T;
-}

package/src/lib/form-field.ts

@@ -1,5 +0,0 @@
-export interface IFormField {
-  // TODO: This should be in a UI-related package
-  readonly hide?: boolean;
-  readonly required?: boolean;
-}

package/src/lib/interfaces.spec.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  equalSpaceRefs,
-  emptySpaceRef,
-  spaceItemBriefWithSpaceRefFromBrief,
-  type ISpaceRef,
-} from './interfaces';
-
-describe('interfaces', () => {
-  describe('emptySpaceRef', () => {
-    it('should have empty id', () => {
-      expect(emptySpaceRef.id).toBe('');
-    });
-
-    it('should not have type', () => {
-      expect(emptySpaceRef.type).toBeUndefined();
-    });
-  });
-
-  describe('equalSpaceRefs', () => {
-    it('should return true for identical objects', () => {
-      const ref: ISpaceRef = { id: 'space1', type: 'family' };
-      expect(equalSpaceRefs(ref, ref)).toBe(true);
-    });
-
-    it('should return true for null compared to null', () => {
-      expect(equalSpaceRefs(null, null)).toBe(true);
-    });
-
-    it('should return true for undefined compared to undefined', () => {
-      expect(equalSpaceRefs(undefined, undefined)).toBe(true);
-    });
-
-    it('should return true for same id and type', () => {
-      const ref1: ISpaceRef = { id: 'space1', type: 'family' };
-      const ref2: ISpaceRef = { id: 'space1', type: 'family' };
-      expect(equalSpaceRefs(ref1, ref2)).toBe(true);
-    });
-
-    it('should return true for same id without type', () => {
-      const ref1: ISpaceRef = { id: 'space1' };
-      const ref2: ISpaceRef = { id: 'space1' };
-      expect(equalSpaceRefs(ref1, ref2)).toBe(true);
-    });
-
-    it('should return false for different ids', () => {
-      const ref1: ISpaceRef = { id: 'space1', type: 'family' };
-      const ref2: ISpaceRef = { id: 'space2', type: 'family' };
-      expect(equalSpaceRefs(ref1, ref2)).toBe(false);
-    });
-
-    it('should return false for different types', () => {
-      const ref1: ISpaceRef = { id: 'space1', type: 'family' };
-      const ref2: ISpaceRef = { id: 'space1', type: 'team' };
-      expect(equalSpaceRefs(ref1, ref2)).toBe(false);
-    });
-
-    it('should return false when comparing null to non-null', () => {
-      const ref: ISpaceRef = { id: 'space1' };
-      expect(equalSpaceRefs(null, ref)).toBe(false);
-      expect(equalSpaceRefs(ref, null)).toBe(false);
-    });
-
-    it('should return false when comparing undefined to defined', () => {
-      const ref: ISpaceRef = { id: 'space1' };
-      expect(equalSpaceRefs(undefined, ref)).toBe(false);
-      expect(equalSpaceRefs(ref, undefined)).toBe(false);
-    });
-
-    it('should return false for one with type and one without', () => {
-      const ref1: ISpaceRef = { id: 'space1', type: 'family' };
-      const ref2: ISpaceRef = { id: 'space1' };
-      expect(equalSpaceRefs(ref1, ref2)).toBe(false);
-    });
-  });
-
-  describe('spaceItemBriefWithSpaceRefFromBrief', () => {
-    it('should create space item with brief', () => {
-      const space: ISpaceRef = { id: 'space1', type: 'family' };
-      const brief = { name: 'Test Item' };
-      const result = spaceItemBriefWithSpaceRefFromBrief(space, 'item1', brief);
-
-      expect(result.id).toBe('item1');
-      expect(result.space).toBe(space);
-      expect(result.brief).toBe(brief);
-    });
-
-    it('should preserve space reference', () => {
-      const space: ISpaceRef = { id: 'space2', type: 'team' };
-      const brief = { title: 'Project' };
-      const result = spaceItemBriefWithSpaceRefFromBrief(space, 'proj1', brief);
-
-      expect(result.space.id).toBe('space2');
-      expect(result.space.type).toBe('team');
-    });
-
-    it('should work with any brief type', () => {
-      const space: ISpaceRef = { id: 'space3' };
-      const brief = { count: 42, active: true };
-      const result = spaceItemBriefWithSpaceRefFromBrief(space, 'id123', brief);
-
-      expect(result.id).toBe('id123');
-      expect(result.brief.count).toBe(42);
-      expect(result.brief.active).toBe(true);
-    });
-
-    it('should work with empty brief', () => {
-      const space: ISpaceRef = { id: 'space4' };
-      const brief = {};
-      const result = spaceItemBriefWithSpaceRefFromBrief(space, 'empty', brief);
-
-      expect(result.id).toBe('empty');
-      expect(result.brief).toEqual({});
-    });
-  });
-});

package/src/lib/interfaces.ts

@@ -1,85 +0,0 @@
-import { SpaceType } from './team-type';
-
-export interface ISpaceRef {
-  readonly id: string;
-  readonly type?: SpaceType;
-}
-
-export function equalSpaceRefs(
-  v1?: ISpaceRef | null,
-  v2?: ISpaceRef | null,
-): boolean {
-  if (v1 === v2) {
-    return true;
-  }
-  return v1?.id === v2?.id && v1?.type === v2?.type;
-}
-
-export const emptySpaceRef: ISpaceRef = { id: '' };
-
-export interface IIdAndBrief<Brief> {
-  readonly id: string;
-  readonly brief: Brief;
-}
-
-export interface IIdAndBriefWithSpaceRef<Brief> {
-  readonly id: string;
-  readonly brief: Brief;
-  readonly space: ISpaceRef;
-}
-
-export interface IIdAndOptionalBrief<Brief> {
-  readonly id: string;
-  readonly brief?: Brief | null;
-}
-
-export interface IIdAndOptionalDbo<Dbo> {
-  readonly id: string;
-  readonly dbo?: Dbo | null;
-}
-
-export interface IIdAndDbo<Dbo> {
-  readonly id: string;
-  readonly dbo: Dbo;
-}
-
-export interface IIdAndOptionalBriefAndOptionalDbo<Brief, Dbo extends Brief> {
-  readonly id: string;
-  readonly brief?: Brief | null;
-  readonly dbo?: Dbo | null;
-}
-
-export interface IIdAndBriefAndOptionalDbo<Brief, Dbo extends Brief> {
-  readonly id: string;
-  readonly brief: Brief;
-  readonly dbo?: Dbo | null;
-}
-
-export interface IIdAndBriefAndDbo<Brief, Dbo extends Brief> {
-  readonly id: string;
-  readonly brief: Brief;
-  readonly dbo: Dbo;
-}
-
-export interface ISpaceItemWithBriefAndDbo<
-  Brief,
-  Dbo extends Brief,
-> extends IIdAndBriefAndDbo<Brief, Dbo> {
-  readonly space: ISpaceRef;
-}
-
-export interface ISpaceItemBriefWithSpace<Brief> extends IIdAndBrief<Brief> {
-  readonly space: ISpaceRef;
-}
-
-export function spaceItemBriefWithSpaceRefFromBrief<Brief>(
-  space: ISpaceRef,
-  id: string,
-  brief: Brief,
-): ISpaceItemBriefWithSpace<Brief> {
-  return { id, brief, space };
-}
-
-export interface IIdAndDboWithSpaceRef<Dbo> extends IIdAndDbo<Dbo> {
-  space: ISpaceRef;
-}

package/src/lib/location-href.spec.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { setHrefQueryParam } from './location-href';
-
-describe('setHrefQueryParam', () => {
-  it('should add query param to URL without existing params', () => {
-    const href = 'https://example.com/path';
-    const result = setHrefQueryParam('foo', 'bar', href);
-    expect(result).toBe('https://example.com/path?foo=bar');
-  });
-
-  it('should add query param to URL with existing params', () => {
-    const href = 'https://example.com/path?existing=value';
-    const result = setHrefQueryParam('foo', 'bar', href);
-    expect(result).toBe('https://example.com/path?existing=value&foo=bar');
-  });
-
-  it('should update existing query param', () => {
-    const href = 'https://example.com/path?foo=old';
-    const result = setHrefQueryParam('foo', 'new', href);
-    expect(result).toBe('https://example.com/path?foo=new');
-  });
-
-  it('should handle special characters in param value', () => {
-    const href = 'https://example.com/path';
-    const result = setHrefQueryParam('foo', 'hello world', href);
-    expect(result).toBe('https://example.com/path?foo=hello+world');
-  });
-
-  it('should handle empty string value', () => {
-    const href = 'https://example.com/path';
-    const result = setHrefQueryParam('foo', '', href);
-    expect(result).toBe('https://example.com/path?foo=');
-  });
-
-  it('should preserve hash in URL', () => {
-    const href = 'https://example.com/path#section';
-    const result = setHrefQueryParam('foo', 'bar', href);
-    expect(result).toBe('https://example.com/path?foo=bar#section');
-  });
-
-  it('should work with localhost', () => {
-    const href = 'http://localhost:4200/path';
-    const result = setHrefQueryParam('test', 'value', href);
-    expect(result).toBe('http://localhost:4200/path?test=value');
-  });
-
-  it('should handle multiple updates to same URL', () => {
-    const href = 'https://example.com/path';
-    const result1 = setHrefQueryParam('foo', 'bar', href);
-    const result2 = setHrefQueryParam('baz', 'qux', result1);
-    expect(result2).toBe('https://example.com/path?foo=bar&baz=qux');
-  });
-});

package/src/lib/location-href.ts

@@ -1,9 +0,0 @@
-export function setHrefQueryParam(
-  param: string,
-  value: string,
-  href = location.href,
-): string {
-  const url = new URL(href);
-  url.searchParams.set(param, value);
-  return url.href;
-}

package/src/lib/logging/interfaces.ts

@@ -1,19 +0,0 @@
-import { InjectionToken } from '@angular/core';
-
-export interface ILogErrorOptions {
-  readonly report?: boolean;
-  readonly feedback?: boolean;
-  readonly show?: boolean;
-  readonly showDuration?: number;
-}
-
-export interface IErrorLogger {
-  logError(e: unknown, message?: string, options?: ILogErrorOptions): void;
-
-  logErrorHandler(
-    message?: string,
-    options?: ILogErrorOptions,
-  ): (error: unknown) => void;
-}
-
-export const ErrorLogger = new InjectionToken<IErrorLogger>('IErrorLogger');

package/src/lib/logging.spec.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { loggerFactory } from './logging';
-
-describe('loggerFactory', () => {
-  beforeEach(() => {
-    // Clear all mocks before each test
-    vi.clearAllMocks();
-  });
-
-  it('should throw error when logger name is empty string', () => {
-    expect(() => loggerFactory.getLogger('')).toThrow(
-      'Logger name is required',
-    );
-  });
-
-  it('should throw error when logger name is null', () => {
-    expect(() => loggerFactory.getLogger(null as unknown as string)).toThrow(
-      'Logger name is required',
-    );
-  });
-
-  it('should throw error when logger name is undefined', () => {
-    expect(() =>
-      loggerFactory.getLogger(undefined as unknown as string),
-    ).toThrow('Logger name is required');
-  });
-
-  it('should return logger with valid name', () => {
-    const logger = loggerFactory.getLogger('test-logger');
-    expect(logger).toBeDefined();
-    expect(logger.debug).toBeDefined();
-    expect(logger.info).toBeDefined();
-    expect(logger.warn).toBeDefined();
-    expect(logger.error).toBeDefined();
-  });
-
-  it('should have debug method that calls console.log', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'log')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.debug('test message');
-
-    expect(consoleSpy).toHaveBeenCalledWith('test message');
-    consoleSpy.mockRestore();
-  });
-
-  it('should have info method that calls console.log', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'log')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.info('info message');
-
-    expect(consoleSpy).toHaveBeenCalledWith('info message');
-    consoleSpy.mockRestore();
-  });
-
-  it('should have warn method that calls console.warn', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'warn')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.warn('warn message');
-
-    expect(consoleSpy).toHaveBeenCalledWith('warn message');
-    consoleSpy.mockRestore();
-  });
-
-  it('should have error method that calls console.error', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'error')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.error('error message');
-
-    expect(consoleSpy).toHaveBeenCalledWith('error message');
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle multiple arguments in debug', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'log')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.debug('message', { data: 'test' }, 123);
-
-    expect(consoleSpy).toHaveBeenCalledWith('message', { data: 'test' }, 123);
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle multiple arguments in info', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'log')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.info('message', { data: 'test' }, 123);
-
-    expect(consoleSpy).toHaveBeenCalledWith('message', { data: 'test' }, 123);
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle multiple arguments in warn', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'warn')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.warn('message', { data: 'test' }, 123);
-
-    expect(consoleSpy).toHaveBeenCalledWith('message', { data: 'test' }, 123);
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle multiple arguments in error', () => {
-    const consoleSpy = vi
-      .spyOn(console, 'error')
-      .mockImplementation(() => undefined);
-    const logger = loggerFactory.getLogger('test-logger');
-
-    logger.error('message', { data: 'test' }, 123);
-
-    expect(consoleSpy).toHaveBeenCalledWith('message', { data: 'test' }, 123);
-    consoleSpy.mockRestore();
-  });
-});

package/src/lib/logging.ts

@@ -1,33 +0,0 @@
-import { InjectionToken } from '@angular/core';
-
-export interface ILogger {
-  debug(...v: unknown[]): void;
-
-  info(...v: unknown[]): void;
-
-  warn(...v: unknown[]): void;
-
-  error(...v: unknown[]): void;
-}
-
-export interface ILoggerFactory {
-  getLogger(name: string): ILogger;
-}
-
-export const LOGGER_FACTORY = new InjectionToken<ILoggerFactory>(
-  'loggerFactory',
-);
-
-export const loggerFactory: ILoggerFactory = {
-  getLogger(name: string): ILogger {
-    if (!name) {
-      throw new Error('Logger name is required');
-    }
-    return {
-      debug: console.log,
-      info: console.log,
-      error: console.error,
-      warn: console.warn,
-    };
-  },
-};

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

@@ -1,16 +0,0 @@
-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;
-// }