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

package/package.json

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

package/project.json

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

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/dto';
+export * from './lib/contexts';
+export * from './lib/apidto';

package/src/lib/apidto/index.ts

@@ -0,0 +1,3 @@
+// TODO: move to services?
+export * from './requests';
+export * from './responses';

package/src/lib/apidto/requests.ts

@@ -0,0 +1,131 @@
+import { mustHaveAtLeastOneName } from '@sneat/auth-models';
+import { validateRelated } from '@sneat/dto';
+import {
+  ContactType,
+  IAddress,
+  IContact2Asset,
+  IContact2ContactInRequest,
+  ICreatePeronRequest,
+  IMemberBrief,
+  IRelatedPerson,
+  MemberContactType,
+} from '../dto';
+import { IMemberContext } from '../contexts';
+import { ISpaceRequest, SpaceMemberStatus } from '@sneat/space-models';
+
+export interface ICreateSpaceMemberRequest
+  extends ISpaceRequest, IRelatedPerson {
+  readonly type: MemberContactType;
+  readonly status: SpaceMemberStatus;
+  readonly countryID: string;
+  readonly roles: readonly string[];
+  readonly message?: string;
+}
+
+export function validateCreateSpaceMemberRequest(
+  request: ICreateSpaceMemberRequest,
+): void {
+  mustHaveAtLeastOneName(request.names);
+  validateRelated(request.related);
+}
+
+export interface ICreateContactBaseRequest extends ISpaceRequest {
+  readonly status: 'active' | 'draft';
+  readonly type: ContactType;
+  // countryID: string;
+  readonly parentContactID?: string;
+  readonly roles?: readonly string[];
+  readonly relatedToAssets?: readonly IContact2Asset[];
+  readonly relatedToContacts?: Readonly<
+    Record<string, IContact2ContactInRequest>
+  >;
+}
+
+export interface ICreateContactPersonRequest extends ICreateContactBaseRequest {
+  readonly type: 'person';
+  readonly person?: ICreatePeronRequest;
+}
+
+export interface ICreateContactLocationRequest extends ICreateContactBaseRequest {
+  readonly type: 'location';
+  readonly location?: ICreateLocationRequest;
+}
+
+export interface IBasicContactRequest {
+  // type: ContactType;
+  // relationship?: string;
+  // message?: string;
+  readonly title: string;
+  // parentContactID?: string;
+}
+
+export interface ICreateContactBasicRequest extends ICreateContactBaseRequest {
+  readonly basic: IBasicContactRequest;
+}
+
+export interface ICreateLocationBaseRequest {
+  readonly title: string;
+  readonly address: IAddress;
+}
+
+export type ICreateLocationRequest = ICreateLocationBaseRequest;
+export type ICreateCompanyRequest = ICreateLocationBaseRequest;
+
+export interface ICreateContactCompanyRequest extends ICreateContactBaseRequest {
+  company?: ICreateCompanyRequest;
+}
+
+export type ICreateContactRequest =
+  | ICreateContactPersonRequest
+  | ICreateContactCompanyRequest
+  | ICreateContactLocationRequest
+  | ICreateContactBasicRequest;
+
+export interface IBy {
+  readonly memberID?: string;
+  readonly userID?: string;
+  readonly title: string;
+}
+
+interface IInvite {
+  readonly message?: string;
+}
+
+export interface IInviteFromContact {
+  readonly memberID: string;
+  readonly userID?: string;
+  readonly title?: string;
+}
+
+export type InviteChannel = 'email' | 'sms' | 'link';
+
+export interface IInviteToContact {
+  readonly channel: InviteChannel;
+  readonly address?: string;
+  readonly memberID?: string;
+  readonly title?: string;
+}
+
+export interface IPersonalInvite extends IInvite {
+  readonly space: { readonly id: string; readonly title: string };
+  readonly memberID: string;
+  readonly from: IInviteFromContact;
+  readonly to: IInviteToContact;
+}
+
+export interface IAddSpaceMemberResponse {
+  readonly member: IMemberContext;
+}
+
+export interface IAcceptPersonalInviteRequest extends ISpaceRequest {
+  readonly inviteID: string;
+  readonly pin: string; // Do not make number as we can lose leading 0's
+  readonly member?: IMemberBrief;
+  // fullName?: string;
+  // email?: string;
+}
+
+export interface ICreatePersonalInviteRequest extends ISpaceRequest {
+  readonly to: IInviteToContact;
+  readonly message: string;
+}

package/src/lib/apidto/responses.ts

@@ -0,0 +1,21 @@
+import { IInviteSpace } from '@sneat/space-models';
+import { IMemberBrief } from '../dto';
+import { IInviteFromContact, IInviteToContact } from './requests';
+
+export interface IJoinSpaceInfoResponse {
+  space: IInviteSpace;
+  invite: {
+    id: string;
+    pin: string;
+    status: string;
+    created: string;
+    from: IInviteFromContact;
+    to: IInviteToContact;
+    message?: string;
+  };
+  member: IMemberBrief;
+}
+
+export interface ICreatePersonalInviteResponse {
+  invite: { id: string; pin?: string };
+}

package/src/lib/contexts/contact-context.ts

@@ -0,0 +1,22 @@
+import { IIdAndDboWithSpaceRef, ISpaceRef } from '@sneat/core';
+import { IContactBase, IContactBrief, IContactDbo } from '../dto';
+import { ISpaceItemNavContext } from '@sneat/space-models';
+
+export interface IContactContext extends ISpaceItemNavContext<
+  IContactBrief,
+  IContactDbo
+> {
+  parentContact?: IContactContext;
+}
+
+export type ContactDboWithSpaceRef = {
+  readonly dbo: IContactDbo;
+  readonly space: ISpaceRef;
+};
+
+export type ContactIdAndDboWithSpaceRef = IIdAndDboWithSpaceRef<IContactDbo>;
+
+export type NewContactBaseDboAndSpaceRef = {
+  readonly dbo: IContactBase;
+  readonly space: ISpaceRef;
+};

package/src/lib/contexts/index.ts

@@ -0,0 +1,2 @@
+export * from './contact-context';
+export * from './person-context';

package/src/lib/contexts/member-group.ts

@@ -0,0 +1,35 @@
+import {
+  DtoGroupTerms,
+  IContactGroupBrief,
+  IContactGroupDbo,
+  IContactGroupDtoCounts,
+} from '../dto';
+import { IMemberGroupContext } from '.';
+
+export class MemberGroup {
+  public readonly id: string;
+  public readonly dto?: IContactGroupDbo | null;
+  public readonly brief?: IContactGroupBrief | null;
+
+  constructor(memberGroup: IMemberGroupContext) {
+    this.id = memberGroup.id;
+    this.brief = memberGroup.brief;
+    this.dto = memberGroup.dbo;
+  }
+
+  public get numberOf(): IContactGroupDtoCounts {
+    const n = this.dto?.numberOf || {};
+    if (!n.members) {
+      n.members = 0;
+    }
+    return n;
+  }
+
+  public get title(): string {
+    return this.brief?.title || '';
+  }
+
+  public get terms(): DtoGroupTerms {
+    return this.dto?.terms || {};
+  }
+}

package/src/lib/contexts/person-context.ts

@@ -0,0 +1,41 @@
+import { ISpaceItemWithBriefAndDbo } from '@sneat/core';
+import {
+  IContactGroupBrief,
+  IContactGroupDbo,
+  IMemberBrief,
+  IMemberDbo,
+} from '../dto';
+import { ISpaceItemNavContext, Totals } from '@sneat/space-models';
+import { IPerson, IPersonBrief } from '../dto';
+
+export type IMemberContext = ISpaceItemNavContext<IMemberBrief, IMemberDbo>;
+export type IPersonContext = ISpaceItemWithBriefAndDbo<IPersonBrief, IPerson>;
+
+export type IMemberGroupContext = ISpaceItemNavContext<
+  IContactGroupBrief,
+  IContactGroupDbo
+>;
+
+export class Member {
+  // TODO - document usage or remove
+  public readonly totals: Totals;
+
+  constructor(
+    public member: IMemberContext,
+    public isChecked = false,
+  ) {
+    this.totals = new Totals(member.dbo?.totals);
+  }
+
+  public get id(): string {
+    return this.member.id;
+  }
+
+  public get title(): string {
+    return this.member.brief?.title || this.member.id;
+  }
+
+  public get emoji(): string {
+    return this.member.dbo?.ageGroup === 'child' ? '🧒' : '🧑';
+  }
+}

package/src/lib/dto/address.ts

@@ -0,0 +1,26 @@
+export interface IAddress {
+  readonly countryID: string;
+  readonly zipCode?: string;
+  readonly state?: string;
+  readonly city?: string;
+  readonly lines?: string;
+}
+
+export function validateAddress(
+  address?: IAddress,
+  requires?: { city?: boolean; lines?: boolean },
+): IAddress {
+  if (!address) {
+    throw new Error('Address is required');
+  }
+  if (address.countryID === '') {
+    throw new Error('Country is required');
+  }
+  if (requires?.city && !address?.city?.trim()) {
+    throw new Error('Address city is required');
+  }
+  if (requires?.lines && !address?.lines?.trim()) {
+    throw new Error('Address text is required');
+  }
+  return address;
+}

package/src/lib/dto/contact-base.ts

@@ -0,0 +1,47 @@
+import { IAvatar, IPersonNames } from '@sneat/auth-models';
+import { AgeGroupID, Gender } from '@sneat/core';
+import { IWithRelatedOnly } from '@sneat/dto';
+import { IAddress } from './address';
+import { ContactType } from './contact-types';
+import { PetKind } from './pet-kind';
+
+export type ContactCommChannelType = 'email' | 'phone';
+
+export interface IContactCommChannelProps {
+  type: 'work' | 'personal';
+  isPrimary?: boolean;
+  isVerified?: boolean;
+  original?: string;
+}
+
+// Originally was in IPerson but also required by company
+// and also if in IPerson troubles with Person Wizard component
+export interface IContactChannels {
+  readonly email?: string; // TODO: Document how email is different from emails
+  readonly emails?: Readonly<Record<string, IContactCommChannelProps>>;
+
+  readonly phone?: string; // TODO: Document how phone is different from phones
+  readonly phones?: Readonly<Record<string, IContactCommChannelProps>>;
+}
+
+// This is used to pass to create_contact API endpoint
+// as IContactDbo have required fields
+// that are not needed at client side at time of creation.
+export interface IContactBase extends IWithRelatedOnly, IContactChannels {
+  readonly type: ContactType;
+  readonly title?: string;
+  readonly shortTitle?: string;
+  readonly names?: IPersonNames;
+  readonly countryID?: string;
+  readonly userID?: string;
+  readonly gender?: Gender; // is required for contact "person" and "animal" type, for others it should be `undefined`
+  readonly ageGroup?: AgeGroupID;
+  readonly petKind?: PetKind;
+  readonly petBreed?: string;
+  readonly address?: IAddress;
+  readonly avatar?: IAvatar;
+  readonly roles?: readonly string[];
+  readonly groupIDs?: readonly string[];
+  readonly invitesCount?: string;
+  readonly dob?: string; // Date of birth
+}

package/src/lib/dto/contact-group-brief.ts

@@ -0,0 +1,8 @@
+import { IIdAndBrief } from '@sneat/core';
+
+export interface IContactGroupBrief {
+  readonly emoji?: string;
+  readonly title: string;
+}
+
+export type ContactGroupWithIdAndBrief = IIdAndBrief<IContactGroupBrief>;

package/src/lib/dto/contact-group.ts

@@ -0,0 +1,19 @@
+import { IContactGroupBrief } from './contact-group-brief';
+import { IContactRoleWithIdAndBrief } from './contact-roles';
+
+import { MembersVisibility } from './member-types';
+import { DtoGroupTerms } from './term';
+
+export interface IContactGroupDtoCounts {
+  members?: number;
+}
+
+export interface IContactGroupDbo extends IContactGroupBrief {
+  // spaceID: string; This is part of a key
+  readonly desc?: string;
+  readonly timetable?: string;
+  readonly membersVisibility?: MembersVisibility;
+  readonly numberOf?: IContactGroupDtoCounts;
+  readonly terms?: DtoGroupTerms;
+  readonly roles?: readonly IContactRoleWithIdAndBrief[];
+}

package/src/lib/dto/contact-roles.ts

@@ -0,0 +1,99 @@
+export const ContactRoleEmployee = 'employee';
+export const ContactRoleInsurer = 'insurer';
+
+export const ContactRolePet = 'pet';
+export const ContactRoleFriend = 'friend';
+export const ContactRoleRelative = 'relative';
+
+// export type ContactRoleFriend = 'friend';
+export const ContactRoleParentOfFriend = 'parent_of_friend';
+export const ContactRoleDriver = 'driver';
+export const ContactRoleLocation = 'location';
+export type ContactRoleDwellingRelated =
+  | typeof ContactRoleInsurer
+  | 'cleaner'
+  | 'gardener'
+  | 'plumber'
+  | 'handyman'
+  | 'gp'
+  | 'landlord'
+  | 'tenant'
+  | 'realtor';
+export type ContactRoleVehicle =
+  | typeof ContactRoleInsurer
+  | 'mechanic'
+  | 'electrician'
+  | 'handyman'
+  | typeof ContactRoleDriver;
+export type ContactRoleMedRelated = 'GP' | 'med_specialist';
+export type ContactRoleFamilyRelated =
+  | typeof RoleSpaceMember
+  | typeof ContactRolePet
+  | typeof ContactRoleFriend
+  | typeof ContactRoleRelative;
+export type ContactRoleWorkRelated =
+  | typeof ContactRoleEmployee
+  | 'client'
+  | 'supplier';
+export type ContactRoleKidRelated =
+  | typeof ContactRoleFriend
+  | typeof ContactRoleParentOfFriend
+  | 'teacher'
+  | 'babysitter';
+export const ContactRoleShip = 'ship';
+export type ContactRoleLogistSubContact =
+  | typeof ContactRoleShip
+  | typeof ContactRoleLocation;
+export type ContactRoleLogistParentContact = 'shipper' | 'dispatcher';
+import { MemberRole, RoleSpaceMember } from './member-types';
+
+export type LogistOrderContactRole =
+  | ContactRoleLogistParentContact
+  | ContactRoleLogistSubContact
+  | 'consignee'
+  | 'dispatch_point'
+  | 'receive_point'
+  | 'dispatch_agent'
+  | 'receive_agent'
+  | 'buyer'
+  | 'courier'
+  | 'freight_agent'
+  | 'notify_party'
+  | 'port'
+  | 'port_from'
+  | 'port_from_location'
+  | 'port_to'
+  | 'port_to_location'
+  | 'shipping_line'
+  | 'truck'
+  | 'trucker'
+  | 'warehouse';
+export type ContactRole =
+  | MemberRole
+  | typeof RoleSpaceMember
+  | ContactRoleFamilyRelated
+  | ContactRoleWorkRelated
+  | ContactRoleKidRelated
+  | ContactRoleMedRelated
+  | ContactRoleDwellingRelated
+  | ContactRoleVehicle
+  | LogistOrderContactRole
+  | 'applicant';
+
+export interface IContactRoleBrief {
+  readonly title: string;
+  readonly titlePlural?: string;
+  readonly emoji?: string;
+  readonly finder?: string;
+}
+
+export interface IContactRoleWithIdAndBrief {
+  readonly id: ContactRole;
+  readonly brief: IContactRoleBrief;
+  readonly hideInNewContactForm?: boolean;
+}
+
+export interface IContactRoleWithIdAndOptionalBrief {
+  readonly id: ContactRole;
+  readonly brief?: IContactRoleBrief;
+}

package/src/lib/dto/contact-types.ts

@@ -0,0 +1,41 @@
+import { SpaceMemberType } from '@sneat/auth-models';
+import { IFormField } from '@sneat/core';
+
+export const ContactTypePerson = 'person',
+  ContactTypeCompany = 'company',
+  ContactTypeLocation = 'location',
+  ContactTypeAnimal = 'animal',
+  ContactTypeVehicle = 'vehicle';
+
+export type ContactType =
+  | SpaceMemberType
+  | typeof ContactTypePerson
+  | typeof ContactTypeCompany
+  | typeof ContactTypeLocation
+  | typeof ContactTypeAnimal
+  | typeof ContactTypeVehicle
+  | 'landlord'
+  | 'tenant';
+export type MemberContactType =
+  | typeof ContactTypePerson
+  | typeof ContactTypeAnimal;
+
+export interface IEmail {
+  readonly type: 'work' | 'personal';
+  readonly address: string;
+}
+
+export interface IPhone {
+  readonly type: 'work' | 'mobile' | 'personal' | 'fax';
+  readonly number: string;
+}
+
+export interface IPersonRequirements {
+  readonly lastName?: IFormField;
+  readonly ageGroup?: IFormField;
+  readonly gender?: IFormField;
+  readonly phone?: IFormField;
+  readonly email?: IFormField;
+  readonly relatedAs?: IFormField;
+  readonly roles?: IFormField;
+}

package/src/lib/dto/contact.ts

@@ -0,0 +1,85 @@
+import {
+  IIdAndBrief,
+  IIdAndBriefAndDbo,
+  IIdAndBriefAndOptionalDbo,
+  ISpaceItemBriefWithSpace,
+} from '@sneat/core';
+import { IWithRelatedAndRelatedIDs } from '@sneat/dto';
+import { ISpaceRef } from '@sneat/core';
+import { IContactBase } from './contact-base';
+import { ContactRole } from './contact-roles';
+import { IContact2Asset } from './contact2item';
+import { IPersonRecord } from './person';
+
+// // Default value: 'optional'
+export type RequirementOption = 'required' | 'optional' | 'excluded';
+
+export interface IContactBrief extends IContactBase {
+  readonly parentID?: string;
+}
+
+export type IContactWithBrief = IIdAndBrief<IContactBrief>;
+
+export function filterContactsByTextAndRole( // TODO(help-wanted): add test
+  contacts: readonly IContactWithCheck[] | undefined,
+  text: string,
+  role?: ContactRole,
+): readonly IContactWithCheck[] | undefined {
+  return !text && !role
+    ? contacts
+    : contacts?.filter((c) => {
+        return isContactPassFilter(c, text, role);
+      });
+}
+
+export function isContactPassFilter(
+  c: IContactWithBrief,
+  text: string,
+  role?: ContactRole,
+): boolean {
+  const { brief } = c;
+  const names = brief?.names;
+  return (
+    (!role || (!!c.brief?.roles && c?.brief.roles.includes(role))) &&
+    (!text ||
+      brief?.title?.toLowerCase().includes(text) ||
+      (!!names &&
+        (!!names.firstName?.toLowerCase().includes(text) ||
+          !!names.lastName?.toLowerCase().includes(text) ||
+          !!names.nickName?.toLowerCase().includes(text) ||
+          !!names.middleName?.toLowerCase().includes(text) ||
+          !!names.fullName?.toLowerCase().includes(text))))
+  );
+}
+
+export interface IContactWithBriefAndSpace extends IContactWithBrief {
+  readonly space: ISpaceRef;
+}
+
+export function addSpace<IBrief>(
+  space: ISpaceRef,
+): (item: IIdAndBrief<IBrief>) => ISpaceItemBriefWithSpace<IBrief> {
+  return (item) => ({ ...item, space });
+}
+
+export interface IContactDbo
+  extends IContactBase, IPersonRecord, IWithRelatedAndRelatedIDs {
+  readonly assets?: IContact2Asset[]; // TODO: Remove as it can be replaced with IWithRelatedItems?
+}
+
+export type IContactWithDbo = IIdAndBriefAndDbo<IContactBrief, IContactDbo>;
+
+export type IContactWithOptionalDbo = IIdAndBriefAndOptionalDbo<
+  IContactBrief,
+  IContactDbo
+>;
+
+export interface IContactWithDboAndSpace
+  extends IContactWithDbo, IContactWithBriefAndSpace {}
+
+export interface IContactWithOptionalDboAndSpace
+  extends IContactWithOptionalDbo, IContactWithBriefAndSpace {}
+
+export interface IContactWithCheck extends IContactWithOptionalDboAndSpace {
+  readonly isChecked?: boolean;
+}

package/src/lib/dto/contact2item.ts

@@ -0,0 +1,23 @@
+import { IWithIdAndTitle } from '@sneat/dto';
+
+export type ContactToContactRelation =
+  | 'undefined'
+  | 'parent'
+  | 'mother'
+  | 'father'
+  | 'sibling'
+  | 'childminder'
+  | 'friend'
+  | 'child';
+
+export type ContactToAssetRelation = string;
+
+// This is a DTO object to be used in request and NOT to be used in DB records
+export interface IContact2ContactInRequest {
+  relation: ContactToContactRelation;
+}
+
+export interface IContact2Asset extends IWithIdAndTitle {
+  // TODO: Remove deprecated
+  relation: ContactToAssetRelation;
+}

package/src/lib/dto/contactus-space.ts

@@ -0,0 +1,8 @@
+import { IIdAndOptionalDbo } from '@sneat/core';
+import { IContactBrief } from './contact';
+
+export interface IContactusSpaceDbo {
+  contacts: Readonly<Record<string, IContactBrief>>;
+}
+
+export type IContactusSpaceDboAndID = IIdAndOptionalDbo<IContactusSpaceDbo>;

package/src/lib/dto/index.ts

@@ -0,0 +1,14 @@
+export * from './address';
+export * from './contact';
+export * from './contact-base';
+export * from './contact-group';
+export * from './contact-roles';
+export * from './contactus-space';
+export * from './member';
+export * from './person';
+export * from './pet-kind';
+export * from './term';
+export * from './contact2item';
+export * from './contact-group-brief';
+export * from './contact-types';
+export * from './member-types';

package/src/lib/dto/member-types.ts

@@ -0,0 +1,29 @@
+export type MembersVisibility = 'private' | 'protected' | 'public';
+export const RoleSpaceMember = 'member';
+export const MemberRoleContributor = 'contributor';
+export const MemberRoleSpectator = 'spectator';
+export const MemberRoleParish = 'pastor';
+export type MemberRoleEducation =
+  | 'administrator'
+  | 'principal'
+  | 'pupil'
+  | 'teacher';
+export type MemberRoleRealtor = 'administrator' | 'agent';
+export type MemberRole =
+  | typeof MemberRoleContributor
+  | typeof MemberRoleSpectator
+  | MemberRoleEducation
+  | MemberRoleRealtor
+  | typeof MemberRoleParish;
+
+export enum FamilyMemberRelation {
+  child = 'child',
+  cousin = 'cousin',
+  grandparent = 'grandparent',
+  grandparentInLaw = 'grandparent_in_law',
+  parent = 'parent',
+  parentInLaw = 'parent_in_law',
+  partner = 'partner',
+  sibling = 'sibling',
+  spouse = 'spouse',
+}

package/src/lib/dto/member.ts

@@ -0,0 +1,87 @@
+import { IAvatar, SpaceMemberType } from '@sneat/auth-models';
+import { EnumAsUnionOfKeys, excludeUndefined } from '@sneat/core';
+import { ITitledRecordInfo, ITotalsHolder, IVerification } from '@sneat/dto';
+import { IContactBrief } from './contact';
+import { IContactGroupBrief } from './contact-group-brief';
+import { FamilyMemberRelation, MemberRole } from './member-types';
+import { IPersonRecord, ISpaceMemberInfo } from './person';
+
+export function relationshipTitle(id: string): string {
+  // TODO: Needs fix to replace all _ with space
+  return id ? id[0].toUpperCase() + id.substring(1).replace(/_+/g, ' ') : '';
+}
+
+export type FamilyMemberRelations = EnumAsUnionOfKeys<
+  typeof FamilyMemberRelation
+>;
+
+export const MemberRelationshipOther = 'other';
+export const MemberRelationshipUndisclosed = 'undisclosed';
+
+export type MemberRelationship =
+  | FamilyMemberRelations
+  | typeof MemberRelationshipOther
+  | typeof MemberRelationshipUndisclosed;
+
+export interface IMemberBase
+  extends IPersonRecord, IVerification, ITotalsHolder {
+  readonly type: SpaceMemberType;
+  readonly title?: string;
+  readonly userID?: string; // User ID
+  readonly roles?: readonly MemberRole[];
+  readonly avatar?: IAvatar;
+}
+
+export type IMemberBrief = IContactBrief;
+
+export interface IMemberDbo extends IMemberBase {
+  position?: string;
+  groups?: IContactGroupBrief[];
+}
+
+export interface IWithContactGroups {
+  groupIDs?: readonly string[];
+  groups: Record<string, IContactGroupBrief>;
+}
+
+// export function newCommuneMemberInfo(id: string, m: IMemberDto): ITeamMemberInfo {
+// 	return excludeUndefined({
+// 		id: id,
+// 		userID: m.uid,
+// 		title: m.title && m.uid && m.title === m.uid ? undefined : m.title,
+// 		ageGroup: m.ageGroup,
+// 		roles: m.roles,
+// 		gender: m.gender,
+// 		groupIds: m.groupIDs,
+// 	});
+// }
+
+export function memberDtoFromMemberInfo(
+  memberInfo: ISpaceMemberInfo,
+  spaceID: string,
+  title: string,
+): IMemberDbo {
+  const memberType: SpaceMemberType = 'member';
+  return excludeUndefined({
+    ...memberInfo,
+    spaceID,
+    title,
+    type: memberType,
+  });
+}
+
+// Deprecated
+export interface ICommuneDtoMemberGroupInfo extends ITitledRecordInfo {
+  members: number;
+}
+
+export const MemberGroupTypeAdults = 'adults';
+export const MemberGroupTypeKids = 'kids';
+export const MemberGroupTypePets = 'pets';
+export const MemberGroupTypeOther = 'other';
+
+export type MemberGroupType =
+  | typeof MemberGroupTypeAdults
+  | typeof MemberGroupTypeKids
+  | typeof MemberGroupTypePets
+  | typeof MemberGroupTypeOther;

package/src/lib/dto/person.ts

@@ -0,0 +1,92 @@
+import { isNameEmpty } from '@sneat/auth-models';
+import { excludeUndefined } from '@sneat/core';
+import { IWithRelatedOnly, IWithSpaceIDs } from '@sneat/dto';
+import { IContactBase } from './contact-base';
+import {
+  ContactType,
+  IPersonRequirements,
+  MemberContactType,
+} from './contact-types';
+
+import { MemberRole } from './member-types';
+
+export type IPersonBrief = IContactBase;
+
+export type IPerson = IContactBase;
+
+export interface ISpaceMemberInfo extends IPerson {
+  readonly id?: string;
+  readonly userID?: string;
+  readonly title?: string;
+  readonly groupIDs?: readonly string[];
+  readonly roles?: readonly MemberRole[];
+}
+
+export interface IRelatedPerson extends IPerson, IWithRelatedOnly {
+  // relatedAs to current user or a specific contact
+  // readonly roles?: string[]; // Either member roles or contact roles
+}
+
+export interface IMemberPerson extends IRelatedPerson {
+  type: MemberContactType;
+}
+
+export function relatedPersonToPerson(v: IRelatedPerson): IPerson {
+  const v2 = { ...excludeUndefined(v) };
+  delete v2['related'];
+  return v2 as IPerson;
+}
+
+export interface IRelatedPersonContact extends IRelatedPerson {
+  readonly type: 'person';
+}
+
+export interface ICreatePeronRequest extends IRelatedPersonContact {
+  readonly status: 'active' | 'draft';
+}
+
+export function isPersonNotReady(
+  p: IPerson,
+  requires: IPersonRequirements,
+): boolean {
+  const nameIsEmpty = isNameEmpty(p.names);
+  const isMissingRequiredFields =
+    (!!requires.lastName?.required && !p.names?.lastName) ||
+    (!!requires.ageGroup?.required && !p.ageGroup) ||
+    (!!requires.gender?.required && !p.gender);
+  return nameIsEmpty || isMissingRequiredFields;
+}
+
+export function isPersonReady(
+  p: IPerson,
+  requires: IPersonRequirements,
+): boolean {
+  return !isPersonNotReady(p, requires);
+}
+
+export function isRelatedPersonNotReady(
+  p: IRelatedPerson,
+  requires: IPersonRequirements,
+): boolean {
+  return (
+    isPersonNotReady(p, requires) ||
+    (p.type !== 'animal' && !!requires.relatedAs?.required && !p.related)
+  );
+}
+
+export function isRelatedPersonReady(
+  p: IPerson,
+  requires: IPersonRequirements,
+): boolean {
+  return !isRelatedPersonNotReady(p, requires);
+}
+
+export interface IPersonRecord extends IWithSpaceIDs, IPerson {
+  /*, IPersonSize*/
+}
+
+export const emptyContactBase: IContactBase = {
+  type: undefined as unknown as ContactType,
+};
+
+export const emptyMemberPerson = emptyContactBase as IMemberPerson;

package/src/lib/dto/pet-kind.ts

@@ -0,0 +1,16 @@
+export enum PetKinds {
+  dog = 'dog',
+  cat = 'cat',
+  hamster = 'hamster',
+  rabbit = 'rabbit',
+  bird = 'bird',
+  fish = 'fish',
+  turtle = 'turtle',
+  snake = 'snake',
+  lizard = 'lizard',
+  horse = 'horse',
+  pig = 'pig',
+  cow = 'cow',
+}
+
+export type PetKind = keyof typeof PetKinds;

package/src/lib/dto/requests.ts

@@ -0,0 +1 @@
+export const empty = {};

package/src/lib/dto/term.ts

@@ -0,0 +1,28 @@
+import { IPrice, ITitledRecord, IWithSpaceIDs } from '@sneat/dto';
+
+export interface DtoTerm extends IWithSpaceIDs, ITitledRecord {
+  status: 'active' | 'archived';
+  startsOn: string;
+  endsOn: string;
+  weeks?: number;
+  classesTotal?: number;
+  classesPerWeek?: number;
+  prices?: ITermPrice[];
+}
+
+export interface DtoGroupTerms {
+  current?: DtoTerm;
+  next?: DtoTerm;
+  prev?: DtoTerm;
+}
+
+export interface ITermPrice extends IPrice {
+  title: string;
+  description?: string;
+  numberOfClasses?: number; // -1 => unlimited
+}
+
+export interface ITermCustomer {
+  memberId: string;
+  paid: boolean;
+}

package/src/lib/sanity.spec.ts

@@ -0,0 +1,5 @@
+describe('libs/contactus/core sanity', () => {
+  it('should pass sanity check', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/test-setup.ts

@@ -0,0 +1,3 @@
+import { setupTestEnvironment } from '@sneat/core/testing';
+
+setupTestEnvironment();

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: 'contactus-core',
+	}),
+);