@sneat/dto 0.1.1

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/dto",
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

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

package/src/index.ts

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

package/src/lib/by-user.ts

@@ -0,0 +1,4 @@
+export interface IByUser {
+  uid: string;
+  title?: string;
+}

package/src/lib/dto-app.ts

@@ -0,0 +1,9 @@
+// import { IAuthStateRecord } from '../../auth/interfaces';
+import { ITitledRecord } from './dto-models';
+
+export interface DtoApp {
+  /*extends IRecord*/ users?: ITitledRecord[];
+  currentLanguage?: string;
+  // authState?: IAuthStateRecord;
+  isInDemoMode?: boolean;
+}

package/src/lib/dto-brief.ts

@@ -0,0 +1,4 @@
+export interface IWithIdAndTitle {
+  id: string;
+  title: string;
+}

package/src/lib/dto-commune.ts

@@ -0,0 +1,158 @@
+import { IDemoRecord, ITitledRecord, ITotalsHolder } from './dto-models';
+import { CommuneType, CountryId } from './types';
+
+export const enum SpaceCounter {
+  activities = 'activities',
+  assets = 'assets',
+  assetGroups = 'assetGroups',
+  contacts = 'contacts',
+  documents = 'documents',
+  liabilities = 'liabilities',
+  members = 'members',
+  // membersByRole = 'membersByRole',
+  memberGroups = 'memberGroups',
+  overdues = 'overdues',
+  pupils = 'pupils',
+  regularTasks = 'regularTasks',
+  staff = 'staff',
+  todos = 'todos',
+  upcomings = 'upcomings',
+}
+
+// type TeamCounters = {
+// 	[P in EnumAsUnionOfKeys<typeof TeamCounter>]: number;
+// };
+
+export interface SpaceCounts {
+  [SpaceCounter.activities]?: number;
+  [SpaceCounter.assets]?: number;
+  [SpaceCounter.assetGroups]?: number;
+  [SpaceCounter.contacts]?: number;
+  [SpaceCounter.documents]?: number;
+  [SpaceCounter.regularTasks]?: number;
+  [SpaceCounter.liabilities]?: number;
+  [SpaceCounter.pupils]?: number;
+  [SpaceCounter.staff]?: number;
+  [SpaceCounter.members]?: number;
+  [SpaceCounter.memberGroups]?: number;
+  [SpaceCounter.overdues]?: number;
+  [SpaceCounter.todos]?: number;
+  [SpaceCounter.upcomings]?: number;
+  // [CommuneCounter.membersByRole]?: { [role: string]: number }; this does not make sense here
+}
+
+export function incrementNumberOf<
+  NumberOf,
+  Dbo extends { numberOf?: NumberOf },
+>(dto: Dbo, init: () => NumberOf, counter: keyof NumberOf, v = 1): Dbo {
+  const current: number = ((dto.numberOf && dto.numberOf[counter]) ||
+    0) as unknown as number;
+  return {
+    ...dto,
+    numberOf: {
+      ...(dto.numberOf || init()),
+      [counter]: current + v,
+    },
+  };
+}
+
+export function newSpaceCounts(numberOf?: SpaceCounts): SpaceCounts {
+  numberOf = numberOf || {};
+  return {
+    activities: numberOf.activities || 0,
+    assets: numberOf.assets || 0,
+    assetGroups: numberOf.assetGroups || 0,
+    contacts: numberOf.contacts || 0,
+    documents: numberOf.documents || 0,
+    members: numberOf.members || 0,
+    memberGroups: numberOf.memberGroups || 0,
+    liabilities: numberOf.liabilities || 0,
+    overdues: numberOf.overdues || 0,
+    regularTasks: numberOf.regularTasks || 0,
+    todos: numberOf.todos || 0,
+    upcomings: numberOf.upcomings || 0,
+  };
+}
+
+export interface ICommuneDbo extends IDemoRecord, ITitledRecord, ITotalsHolder {
+  readonly countryId?: CountryId;
+  readonly type: CommuneType;
+  readonly desc?: string;
+  readonly userID: string;
+  readonly order?: number;
+  readonly numberOf?: SpaceCounts;
+  readonly membersCountByRole?: Record<string, number>;
+  readonly noContactRoles?: string[];
+  // readonly groups?: ICommuneDtoMemberGroupInfo[];
+  // readonly members?: readonly ITeamMemberInfo[];
+}
+
+export function isCommuneShouldHoldMembersInfo(type: CommuneType): boolean {
+  return type === 'family' || type === 'cohabit';
+}
+
+// export function findCommuneMemberInfo(
+// 	members: readonly ITeamMemberInfo[],
+// 	member: { readonly id?: string; readonly userID?: string },
+// ): ITeamMemberInfo | undefined {
+// 	return (
+// 		members &&
+// 		members.find(
+// 			(m) =>
+// 				(m && !!m.id && m.id === member.id) ||
+// 				(!!m.userID && m.userID === member.userID),
+// 		)
+// 	);
+// }
+
+export const personalCommuneIdPrefix = 'u_';
+
+export function getUserPersonalCommuneID(userID?: string): string {
+  if (!userID) {
+    throw new Error('userID is required parameter');
+  }
+  return personalCommuneIdPrefix + userID;
+}
+
+export function isPersonalCommuneId(id: string): boolean {
+  return !!id && id.startsWith(personalCommuneIdPrefix);
+}
+
+export function isUserPersonalCommune(
+  communeID: string,
+  userID?: string,
+): boolean {
+  return !!userID && communeID === getUserPersonalCommuneID(userID);
+}
+
+// export const CommuneModel = {
+// 	getListInfoByRealId: (dto: ITeamDto, listId: string) => {
+// 		const result =
+// 			dto.listGroups &&
+// 			dto.listGroups
+// 				.map((lg) => lg.lists && lg.lists.find((l) => l.id === listId))
+// 				.find((l) => !!l);
+// 		console.log(
+// 			`CommuneModel.getListInfoByRealId(${listId})`,
+// 			dto.listGroups,
+// 			' => ',
+// 			result,
+// 		);
+// 		return result;
+// 	},
+//
+// 	getListInfoByShortId: (dto: ICommuneDto, shortListId: string) => {
+// 		console.log(
+// 			`CommuneModel.getListInfoByShortId(${shortListId})`,
+// 			dto.listGroups,
+// 		);
+// 		return (
+// 			dto.listGroups &&
+// 			dto.listGroups
+// 				.map(
+// 					(lg) => lg.lists && lg.lists.find((l) => l.shortId === shortListId),
+// 				)
+// 				.find((l) => !!l)
+// 		);
+// 	},
+// };

package/src/lib/dto-constants.spec.ts

@@ -0,0 +1,7 @@
+import { CompoundIndexSeparator } from './dto-constants';
+
+describe('dto constants', () => {
+  it('should have CompoundIndexSeparator defined', () => {
+    expect(CompoundIndexSeparator).toBe(':');
+  });
+});

package/src/lib/dto-constants.ts

@@ -0,0 +1,2 @@
+export const CompoundIndexSeparator = ':';
+export const COMPLETED = true;

package/src/lib/dto-models.ts

@@ -0,0 +1,105 @@
+import { Restriction } from './types';
+
+// import {IPersonSize} from '../ui/dto-sizechart';
+
+export interface ITitled {
+  title: string;
+}
+
+export interface ITitledRecord {
+  id?: string;
+  title?: string;
+}
+
+export interface ITitledRecordInfo {
+  id: string;
+  title: string;
+}
+
+// | MemberRoleWork;
+
+export interface DtoTotal {
+  count: number;
+  day?: number;
+  week?: number;
+  month?: number;
+  quarter?: number;
+  year?: number;
+}
+
+export interface IDemoRecord {
+  id?: string;
+  isDemo?: boolean;
+  isLocal?: boolean;
+}
+
+export interface ITotalsHolder {
+  totals?: DtoTotals;
+}
+
+export interface DtoTotals {
+  incomes?: DtoTotal;
+  expenses?: DtoTotal;
+}
+
+// export interface Category extends ITitledRecord {
+//     id: string;
+// }
+
+export interface IWithSpaceIDs {
+  spaceIDs?: string[];
+}
+
+export interface IWithTag {
+  tags?: string[];
+}
+
+export interface IWithAssetIDs {
+  assetIDs?: string[];
+}
+
+export interface IWithMemberIDs {
+  memberIDs?: string[];
+}
+
+export interface IRealEstate {
+  leaseExpires?: string;
+}
+
+export interface IWithRestrictions {
+  restrictions?: Restriction[];
+}
+
+function newTotal(): DtoTotal {
+  return { count: 0, day: 0, week: 0, month: 0, quarter: 0, year: 0 };
+}
+
+export function newTotals(): DtoTotals {
+  // TODO: Rename to ITotalsDto
+  return { incomes: newTotal(), expenses: newTotal() };
+}
+
+export function zeroIfEmptyTotals(totals: DtoTotals): DtoTotals {
+  const f = (t?: DtoTotal) =>
+    t
+      ? {
+          count: t.count || 0,
+          day: t.day || 0,
+          week: t.week || 0,
+          month: t.month || 0,
+          quarter: t.quarter || 0,
+          year: t.year || 0,
+        }
+      : newTotal();
+  totals.incomes = f(totals.incomes);
+  totals.expenses = f(totals.expenses);
+  return totals;
+}
+
+export interface IVerification {
+  isVerified?: boolean;
+  verification?: {
+    confirmedBy?: string[]; // List of ID of users who confirmed validity of the member
+    rejectedBy?: string[]; // List of ID of users who questions validity of the member
+  };
+}

package/src/lib/dto-pricing.ts

@@ -0,0 +1,5 @@
+export interface IPrice {
+  title?: string;
+  amount: number;
+  currency?: 'EUR' | 'RUB' | 'USD';
+}

package/src/lib/dto-team-brief.ts

@@ -0,0 +1,20 @@
+import { SpaceType } from '@sneat/core';
+
+export interface ISpaceBrief {
+  readonly title: string;
+  readonly type: SpaceType;
+  readonly parentSpaceID?: string;
+  readonly roles?: string[];
+}
+
+export const equalSpaceBriefs = (
+  v1?: ISpaceBrief | null | undefined,
+  v2?: ISpaceBrief | null | undefined,
+): boolean => {
+  if (v1 === v2) return true;
+  return v1?.parentSpaceID === v2?.parentSpaceID && v1?.title === v2?.title;
+};
+
+export const isSpaceSupportsMemberGroups = (t: SpaceType): boolean => {
+  return t === 'educator' || t === 'sport_club' || t === 'cohabit';
+};

package/src/lib/dto-team-info.ts

@@ -0,0 +1,15 @@
+import { SpaceType } from '@sneat/core';
+import { IUserCommuneInfo } from './dto-user';
+
+export interface IShortSpaceInfo {
+  type: SpaceType;
+  id?: string;
+  // shortId?: CommuneShortId;
+  title?: string;
+}
+
+export function createShortCommuneInfoFromUserCommuneInfo(
+  v: IUserCommuneInfo,
+): IShortSpaceInfo {
+  return { id: v.id, title: v.title, /*shortId: v.shortId,*/ type: v.type };
+}

package/src/lib/dto-team-meeting.ts

@@ -0,0 +1,6 @@
+export interface IMeetingInfo {
+  id: string;
+  stage: string;
+  started?: string;
+  finished?: string;
+}

package/src/lib/dto-team-metric.ts

@@ -0,0 +1,29 @@
+export type MetricColor =
+  | 'primary'
+  | 'secondary'
+  | 'tertiary'
+  | 'success'
+  | 'danger'
+  | 'warning';
+
+export interface IBoolMetricVal {
+  label: string;
+  color: MetricColor;
+}
+
+export interface IBoolMetric {
+  true: IBoolMetricVal;
+  false: IBoolMetricVal;
+}
+
+export interface ISpaceMetric {
+  id?: string;
+  title: string;
+  colorTrue?: MetricColor;
+  colorFalse?: MetricColor;
+  type: 'bool' | 'integer' | 'options';
+  mode: 'personal' | 'team';
+  bool?: IBoolMetric;
+  min?: number;
+  max?: number;
+}

package/src/lib/dto-team.ts

@@ -0,0 +1,27 @@
+import { ITotalsHolder } from './dto-models';
+import { ISpaceBrief } from './dto-team-brief';
+import { ISpaceMetric } from './dto-team-metric';
+
+// export interface ITeamMeetings {
+// 	scrum?: IMemberBrief;
+// 	retrospective?: IMeetingInfo;
+// }
+
+export interface ISpaceDbo extends ISpaceBrief, ITotalsHolder {
+  readonly countryID: string;
+  readonly userIDs: string[];
+  // readonly members?: IMemberBrief[];
+  // readonly assets?: IAssetBrief[];
+  // readonly contacts?: IContactBrief[];
+  // readonly numberOf?: TeamCounts;
+  // readonly recurringHappenings?: { [id: string]: IHappeningBrief }; // TODO: Move to ISchedulusTeamDto
+
+  metrics: ISpaceMetric[];
+  // active?: ITeamMeetings;
+  // last?: ITeamMeetings;
+  upcomingRetro?: {
+    itemsByUserAndType?: Record<string, Record<string, number>>;
+  };
+
+  noContactRoles?: string[]; // lists roles that have no contacts. For example families that have no plumber contacts.
+}

package/src/lib/dto-user.ts

@@ -0,0 +1,85 @@
+// import { MemberRelationship } from './dto-member';
+import { ITitledRecord } from './dto-models';
+import { ICommuneDbo } from './dto-commune';
+import { CommuneType, CountryId } from './types';
+
+export interface IUserCommuneInfo {
+  id?: string;
+  shortId?: string;
+  title?: string;
+  type: CommuneType;
+  // members?: {
+  // 	[id: string]: {
+  // 		relatedAs: MemberRelationship;
+  // 		// title?: string;
+  // 	};
+  // };
+}
+
+export function createUserCommuneInfoFromCommuneDto(
+  communeDto: ICommuneDbo,
+  shortId?: string,
+): IUserCommuneInfo {
+  return {
+    id: communeDto.id,
+    shortId,
+    title: communeDto.title,
+    type: communeDto.type,
+  };
+}
+
+export interface IUserDbo extends ITitledRecord {
+  countryIds?: CountryId[];
+  created: {
+    hostOrApp: string;
+    at: string;
+  };
+  readonly communes?: readonly IUserCommuneInfo[]; // Returns real ID and Title, find by shortId
+  communesCount?: number;
+  isAnonymous: boolean;
+  isDemo?: boolean;
+  autogeneratedPassword?: string;
+  emailVerified?: boolean;
+  email?: string;
+  emailOriginal?: string;
+  gender?: 'male' | 'female' | 'undisclosed';
+}
+
+export function addCommuneToUserDto(
+  userDto: IUserDbo,
+  communeInfo: IUserCommuneInfo,
+): IUserDbo {
+  const communes = userDto.communes || [];
+  if (
+    communeInfo.id &&
+    communes.find((c) => !!c.id && !!communeInfo.id && c.id === communeInfo.id)
+  ) {
+    throw new Error(`Can't add commune with duplicate id: ${communeInfo.id}`);
+  }
+  return {
+    ...userDto,
+    communes: [...communes, communeInfo],
+    communesCount: communes.length + 1,
+  };
+}
+
+export class UserModel {
+  public static getCommuneInfoByShortId(
+    id: string,
+    communes?: readonly IUserCommuneInfo[],
+  ): IUserCommuneInfo | undefined {
+    return communes && communes.find((c) => c.shortId === id);
+  }
+
+  public static getCommuneInfoById(
+    id: string,
+    communes: readonly IUserCommuneInfo[],
+  ): IUserCommuneInfo | undefined {
+    const ci =
+      communes && communes.find((c) => c.shortId === id || c.id === id);
+    if (!ci && id === 'family') {
+      return { type: 'family', shortId: 'family', title: 'Family' };
+    }
+    return ci;
+  }
+}

package/src/lib/dto-with-modified.ts

@@ -0,0 +1,32 @@
+export interface timestamp {
+  seconds: number;
+  nanoseconds: number;
+}
+export const emptyTimestamp: timestamp = { seconds: 0, nanoseconds: 0 };
+
+export interface IWithCreatedShort {
+  readonly at: string;
+  readonly by: string;
+}
+
+export interface IWithCreatedOn {
+  readonly createdOn: string;
+}
+
+export interface IWithCreated {
+  readonly createdAt: timestamp;
+  readonly createdBy: string;
+}
+
+export interface IWithUpdated {
+  readonly updatedAt: timestamp;
+  readonly updatedBy: string;
+}
+
+export interface IWithDeleted {
+  readonly deletedAt?: timestamp;
+  readonly deletedBy?: string;
+}
+
+export interface IWithModified
+  extends IWithCreated, IWithUpdated, IWithDeleted {}

package/src/lib/index.ts

@@ -0,0 +1,18 @@
+export * from './ui-state';
+export * from './dto-app';
+export * from './dto-brief';
+export * from './dto-commune';
+export * from './dto-constants';
+export * from './dto-models';
+export * from './dto-pricing';
+export * from './dto-team';
+export * from './dto-team-brief';
+export * from './dto-team-info';
+export * from './dto-team-meeting';
+export * from './dto-team-metric';
+export * from './dto-user';
+export * from './dto-with-modified';
+export * from './by-user';
+export * from './types';
+export * from './with-related';
+export * from './period';

package/src/lib/period.ts

@@ -0,0 +1 @@
+export type Period = 'day' | 'week' | 'month' | 'quarter' | 'year';

package/src/lib/types.ts

@@ -0,0 +1,34 @@
+import { SpaceType } from '@sneat/core';
+
+export { SpaceMemberType } from '@sneat/auth-models';
+
+export type Restriction = 'adults_only' | 'personal' | string;
+
+export type SneatRecordStatus = 'active' | 'archived' | 'deleted';
+
+export type CommuneType = SpaceType;
+
+export type CountryId =
+  | 'IE'
+  | 'US'
+  | 'UK'
+  | 'RU'
+  | 'FR'
+  | 'ES'
+  | 'AU'
+  | 'ZA'
+  | string;
+
+export type CommuneItemCounter =
+  | 'activities'
+  | 'assets'
+  | 'assetGroups'
+  | 'contacts'
+  | 'documents'
+  | 'liabilities'
+  | 'members'
+  | 'memberGroups'
+  | 'overdues'
+  | 'regularTasks'
+  | 'todos'
+  | 'upcomings';

package/src/lib/ui-state.ts

@@ -0,0 +1,5 @@
+export interface UiState {
+  readonly isAdding?: boolean;
+  readonly isDeleting?: boolean;
+  readonly isReordering?: boolean;
+}

package/src/lib/with-related.ts

@@ -0,0 +1,180 @@
+import { IWithCreatedShort } from './dto-with-modified';
+
+export interface IRelatedItemKey {
+  readonly itemID: string;
+  readonly spaceID?: string;
+}
+
+export interface ISpaceModuleItemRef {
+  readonly module: string;
+  readonly collection: string;
+  readonly spaceID: string;
+  readonly itemID: string;
+}
+
+export interface IRelationshipRole {
+  readonly created: IWithCreatedShort;
+}
+
+export type WritableRelationshipRoles = Record<string, IRelationshipRole>;
+// {
+// 	// -readonly [K in keyof IRelationshipRoles]: IRelationshipRoles[K];
+// };
+export type IRelationshipRoles = Readonly<WritableRelationshipRoles>;
+
+export interface IRelatedItem {
+  // readonly keys: readonly IRelatedItemKey[];
+  readonly rolesOfItem?: IRelationshipRoles; // if related item is a child of the current record, then rolesOfItem = {"child": ...}
+  readonly rolesToItem?: IRelationshipRoles; // if related item is a child of the current contact, then rolesToItem = {"parent": ...}
+}
+
+export type IRelatedItems = Readonly<Record<string, IRelatedItem>>;
+export type IRelatedCollections = Readonly<Record<string, IRelatedItems>>;
+export type IRelatedModules = Readonly<Record<string, IRelatedCollections>>;
+
+export interface IRelatedTo extends IWithRelatedOnly {
+  readonly key: ISpaceModuleItemRef;
+  readonly title: string; // pass empty string if you don't want to display name
+}
+
+export function getRelatedItems(
+  moduleId: string,
+  collectionId: string,
+  related?: IRelatedModules,
+): IRelatedItems {
+  return (related && related[moduleId]?.[collectionId]) || {};
+}
+
+export interface IWithRelatedOnly {
+  readonly related?: IRelatedModules;
+}
+
+export function validateRelated(related?: IRelatedModules): void {
+  if (!related) {
+    return;
+  }
+  Object.entries(related).forEach(([, collections]) => {
+    Object.entries(collections).forEach(([, items]) => {
+      if (!items) {
+        return;
+      }
+      Object.entries(items).forEach(([itemID]) => {
+        if (!itemID) {
+          throw new Error('ItemID is not set');
+        }
+      });
+    });
+  });
+}
+
+export interface IWithRelatedAndRelatedIDs extends IWithRelatedOnly {
+  readonly relatedIDs?: readonly string[];
+}
+
+export const addRelatedItem = (
+  related: IRelatedModules | undefined,
+  key: ISpaceModuleItemRef,
+  rolesOfItem?: IRelationshipRoles,
+) => {
+  related = related || {};
+  let collectionRelated = related[key.module] || {};
+  let relatedItems = collectionRelated[key.collection] || {};
+  if (!hasRelated(related, key)) {
+    relatedItems = {
+      ...relatedItems,
+      [key.itemID]: { rolesOfItem },
+    };
+    collectionRelated = {
+      ...collectionRelated,
+      [key.collection]: relatedItems,
+    };
+    related = { ...related, [key.module]: collectionRelated };
+  }
+  return related;
+};
+
+export const removeRelatedItem = (
+  related: IRelatedModules | undefined,
+  key: ISpaceModuleItemRef,
+) => {
+  if (!related) {
+    return related;
+  }
+  let collectionRelated = related[key.module];
+  if (!collectionRelated) {
+    return related;
+  }
+  const relatedItems = collectionRelated[key.collection];
+  if (!relatedItems) {
+    return related;
+  }
+  if (hasRelated(related, key)) {
+    const collectionItems = { ...relatedItems };
+    delete collectionItems[key.itemID];
+    collectionRelated = {
+      ...collectionRelated,
+      [key.collection]: collectionItems,
+    };
+    related = { ...related, [key.module]: collectionRelated };
+  }
+  return related;
+};
+
+export const getLongRelatedItemID = (itemID: string, spaceID: string) =>
+  `${itemID}@${spaceID}`;
+
+export const getRelatedItemByIDs = (
+  relatedItems: Readonly<Record<string, IRelatedItem>> | undefined,
+  itemID: string,
+  spaceID?: string,
+) =>
+  relatedItems &&
+  (relatedItems[itemID] ||
+    (spaceID && relatedItems[getLongRelatedItemID(itemID, spaceID)]));
+
+export const getRelatedItemByKey = (
+  related: IRelatedModules | undefined,
+  key: ISpaceModuleItemRef,
+): IRelatedItem | undefined => {
+  const items = related?.[key.module]?.[key.collection];
+  const { itemID, spaceID } = key;
+  return getRelatedItemByIDs(items, itemID, spaceID);
+};
+
+export const getRelatedItemIDs = (
+  related: IRelatedModules | undefined,
+  module: string,
+  collection: string,
+  spaceID?: string,
+): readonly string[] => {
+  if (!related) {
+    return [];
+  }
+  // console.log('getRelatedItemIDs', module, collection, spaceID, related);
+  const collectionRelated = (related || {})[module] || {};
+  const relatedItems = collectionRelated[collection];
+  const keys = Object.keys(relatedItems);
+  return spaceID
+    ? keys.filter((k) => !k.includes('@') || k.endsWith(`@${spaceID}`))
+    : keys;
+};
+
+export const hasRelated = (
+  related: IRelatedModules | undefined,
+  key: ISpaceModuleItemRef,
+): boolean => {
+  if (!related) {
+    return false;
+  }
+  const collectionRelated = (related || {})[key.module] || {};
+  const relatedItems = collectionRelated[key.collection];
+  return hasRelatedItem(relatedItems, key);
+};
+
+const hasRelatedItem = (
+  relatedItems: IRelatedItems,
+  itemKey: IRelatedItemKey,
+): boolean => {
+  const { itemID, spaceID } = itemKey;
+  return !!getRelatedItemByIDs(relatedItems, itemID, spaceID);
+};

package/src/test-setup.ts

@@ -0,0 +1 @@
+import '@sneat/core/testing-light';

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.angular.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.lib.base.json",
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/test-setup.ts",
+    "src/lib/testing/**/*"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {}
+}

package/tsconfig.spec.json

@@ -0,0 +1,31 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ],
+  "files": [
+    "src/test-setup.ts"
+  ]
+}

package/vite.config.mts

@@ -0,0 +1,10 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vitest/config';
+import { createBaseViteConfig } from '../../vite.config.base';
+
+export default defineConfig(() =>
+	createBaseViteConfig({
+		dirname: __dirname,
+		name: 'dto',
+	}),
+);