@dative-gpi/foundation-core-services 0.0.51 → 0.0.53

package/composables/app/useAppOrganisationId.ts

@@ -4,7 +4,7 @@ const organisationId = ref<string | null>(null);
 
 export const useAppOrganisationId = () => {
 
-    const setOrganisationId = (payload: string) => {
+    const setAppOrganisationId = (payload: string) => {
         organisationId.value = payload;
     };
 
@@ -13,6 +13,6 @@ export const useAppOrganisationId = () => {
     return {
         ready,
         organisationId,
-        setOrganisationId
+        setAppOrganisationId
     };
 }

package/composables/services/useAlerts.ts

@@ -1,7 +1,7 @@
 import { onUnmounted, ref } from "vue";
 
 import { AlertDetails, AlertDetailsDTO, AlertFilters, AlertInfos, AlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { ALERTS_URL, ALERT_URL } from "../../config/urls";
 
@@ -9,89 +9,11 @@ const AlertServiceFactory = new ServiceFactory<AlertDetailsDTO, AlertDetails>("a
     factory.addGet(ALERT_URL),
     factory.addGetMany<AlertInfosDTO, AlertInfos, AlertFilters>(ALERTS_URL, AlertInfos),
     factory.addRemove(ALERT_URL),
-    factory.addNotify((notifyService) => ({
-        acknowledge: async (alertId: string): Promise<AlertDetails> => {
-            const response = await ServiceFactory.http.patch(ALERT_URL(alertId));
-            const result = new AlertDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        },
-        getNotify: async (alertId: string): Promise<AlertDetails> => {
-            const response = await ServiceFactory.http.get(ALERT_URL(alertId));
-            const result = new AlertDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        },
-        removeNotify: (alertId: string): void => {
-            notifyService.notify("delete", alertId);
-        }
-    }))
+    factory.addCustom("acknowledge", (axios, alertId: string) => axios.patch(ALERT_URL(alertId))),
+    factory.addNotify()
 ));
 
 export const useAlert = ComposableFactory.get(AlertServiceFactory);
 export const useAlerts = ComposableFactory.getMany(AlertServiceFactory);
 export const useRemoveAlert = ComposableFactory.remove(AlertServiceFactory);
-export const useAcknowledgeAlert = () => {
-    const service = AlertServiceFactory();
-    const subscribersIds : number[] = [];
-
-    const changing = ref(false);
-    const changed = ref<AlertDetails | null>(null);
-
-    onUnmounted(() => {
-        subscribersIds.forEach(id => service.unsubscribe(id));
-        subscribersIds.length = 0;
-    });
-
-    const change = async (alertId: string) => {
-        changing.value = true;
-        try {
-            changed.value = await service.acknowledge(alertId);
-        }
-        finally {
-            changing.value = false;
-        }
-        subscribersIds.push(service.subscribe("all", onEntityChanged(changed)));
-        return changed;
-    }
-
-    return {
-        changing,
-        change,
-        changed
-    };
-}
-export const useNotifyAlert = () => {
-    const service = AlertServiceFactory();
-
-    const fetching = ref(false);
-    const fetched = ref<AlertDetails | null>(null);
-
-    const fetch = async (alertId: string) => {
-        fetching.value = true;
-        try {
-            fetched.value = await service.getNotify(alertId);
-        }
-        finally {
-            fetching.value = false;
-        }
-        return fetched;
-    }
-
-    return {
-        fetching,
-        fetch,
-        fetched
-    };
-}
-export const useNotifyRemoveAlert = () => {
-    const service = AlertServiceFactory();
-
-    return {
-        remove: service.removeNotify
-    };
-}
+export const useAcknowledgeAlert = ComposableFactory.custom(AlertServiceFactory, AlertServiceFactory.acknowledge);

package/composables/services/useConnectivityAlerts.ts

@@ -1,5 +1,3 @@
-import { ref } from "vue";
-
 import { ConnectivityAlertDetails, ConnectivityAlertDetailsDTO, ConnectivityAlertFilters, ConnectivityAlertInfos, ConnectivityAlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
@@ -9,51 +7,9 @@ const ConnectivityAlertServiceFactory = new ServiceFactory<ConnectivityAlertDeta
     factory.addGet(CONNECTIVITY_ALERT_URL),
     factory.addGetMany<ConnectivityAlertInfosDTO, ConnectivityAlertInfos, ConnectivityAlertFilters>(CONNECTIVITY_ALERTS_URL, ConnectivityAlertInfos),
     factory.addRemove(CONNECTIVITY_ALERT_URL),
-    factory.addNotify((notifyService) => ({
-        getNotify: async (connectivityAlertId: string): Promise<ConnectivityAlertDetails> => {
-            const response = await ServiceFactory.http.get(CONNECTIVITY_ALERT_URL(connectivityAlertId));
-            const result = new ConnectivityAlertDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        },
-        removeNotify: (connectivityAlertId: string): void => {
-            notifyService.notify("delete", connectivityAlertId);
-        }
-    }))
+    factory.addNotify()
 ));
 
 export const useConnectivityAlert = ComposableFactory.get(ConnectivityAlertServiceFactory);
 export const useConnectivityAlerts = ComposableFactory.getMany(ConnectivityAlertServiceFactory);
-export const useRemoveConnectivityAlert = ComposableFactory.remove(ConnectivityAlertServiceFactory);
-export const useNotifyConnectivityAlert = () => {
-    const service = ConnectivityAlertServiceFactory();
-
-    const fetching = ref(false);
-    const fetched = ref<ConnectivityAlertDetails | null>(null);
-
-    const fetch = async (connectivityAlertId: string) => {
-        fetching.value = true;
-        try {
-            fetched.value = await service.getNotify(connectivityAlertId);
-        }
-        finally {
-            fetching.value = false;
-        }
-        return fetched;
-    }
-
-    return {
-        fetching,
-        fetch,
-        fetched
-    };
-}
-export const useNotifyRemoveConnectivityAlert = () => {
-    const service = ConnectivityAlertServiceFactory();
-
-    return {
-        remove: service.removeNotify
-    };
-}
+export const useRemoveConnectivityAlert = ComposableFactory.remove(ConnectivityAlertServiceFactory);

package/composables/services/useDeviceConnectivities.ts

@@ -1,5 +1,3 @@
-import { ref } from "vue";
-
 import { DeviceConnectivityDetails, DeviceConnectivityDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
@@ -7,40 +5,7 @@ import { DEVICE_CONNECTIVITY_URL } from "../../config/urls";
 
 const DeviceConnectivityServiceFactory = new ServiceFactory<DeviceConnectivityDetailsDTO, DeviceConnectivityDetails>("deviceConnectivity", DeviceConnectivityDetails).create(factory => factory.build(
     factory.addGet(DEVICE_CONNECTIVITY_URL),
-    factory.addNotify((notifyService) => ({
-        getNotify: async (deviceConnectivityId: string): Promise<DeviceConnectivityDetails> => {
-            const response = await ServiceFactory.http.get(DEVICE_CONNECTIVITY_URL(deviceConnectivityId));
-            const result = new DeviceConnectivityDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        }
-    }))
+    factory.addNotify()
 ));
 
-export const useDeviceConnectivity = ComposableFactory.get(DeviceConnectivityServiceFactory);
-export const useNotifyDeviceConnectivity = () => {
-    const service = DeviceConnectivityServiceFactory();
-
-    const fetching = ref(false);
-    const fetched = ref<DeviceConnectivityDetails | null>(null);
-
-    const fetch = async (deviceConnectivityId: string) => {
-        fetching.value = true;
-        try {
-            fetched.value = await service.getNotify(deviceConnectivityId);
-        }
-        finally {
-            fetching.value = false;
-        }
-
-        return fetched;
-    }
-
-    return {
-        fetching,
-        fetch,
-        fetched
-    };
-}
+export const useDeviceConnectivity = ComposableFactory.get(DeviceConnectivityServiceFactory);

package/composables/services/useDeviceOrganisations.ts

@@ -11,24 +11,9 @@ const DeviceOrganisationServiceFactory = new ServiceFactory<DeviceOrganisationDe
     factory.addCreate<CreateDeviceOrganisationDTO>(DEVICE_ORGANISATIONS_URL),
     factory.addUpdate<UpdateDeviceOrganisationDTO>(DEVICE_ORGANISATION_URL),
     factory.addRemove(DEVICE_ORGANISATION_URL),
-    factory.addNotify((notifyService) => ({
-        changeGroup: async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO): Promise<DeviceOrganisationDetails> => {
-            const response = await ServiceFactory.http.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload);
-            const result = new DeviceOrganisationDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        },
-        changeLocation: async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO): Promise<DeviceOrganisationDetails> => {
-            const response = await ServiceFactory.http.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload);
-            const result = new DeviceOrganisationDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        }
-    }))
+    factory.addCustom("changeGroup", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => axios.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload)),
+    factory.addCustom("changeLocation", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => axios.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload)),
+    factory.addNotify()
 ));
 
 export const useDeviceOrganisation = ComposableFactory.get(DeviceOrganisationServiceFactory);
@@ -36,63 +21,5 @@ export const useDeviceOrganisations = ComposableFactory.getMany(DeviceOrganisati
 export const useCreateDeviceOrganisation = ComposableFactory.create(DeviceOrganisationServiceFactory);
 export const useUpdateDeviceOrganisation = ComposableFactory.update(DeviceOrganisationServiceFactory);
 export const useRemoveDeviceOrganisation = ComposableFactory.remove(DeviceOrganisationServiceFactory);
-export const useChangeDeviceOrganisationGroup = () => {
-    const service = DeviceOrganisationServiceFactory();
-    const subscriberIds: number[] = [];
-
-    const changing = ref(false);
-    const changed = ref<DeviceOrganisationDetails | null>(null);
-
-    onUnmounted(() => {
-        subscriberIds.forEach(id => service.unsubscribe(id));
-        subscriberIds.length = 0;
-    });
-
-    const change = async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => {
-        changing.value = true;
-        try {
-            changed.value = await service.changeGroup(deviceOrganisationId, payload);
-        }
-        finally {
-            changing.value = false;
-        }
-        subscriberIds.push(service.subscribe("all", onEntityChanged(changed)));
-        return changed;
-    }
-
-    return {
-        changing,
-        change,
-        changed
-    }
-}
-export const useChangeDeviceOrganisationLocation = () => {
-    const service = DeviceOrganisationServiceFactory();
-    const subscriberIds: number[] = [];
-
-    const changing = ref(false);
-    const changed = ref<DeviceOrganisationDetails | null>(null);
-
-    onUnmounted(() => {
-        subscriberIds.forEach(id => service.unsubscribe(id));
-        subscriberIds.length = 0;
-    });
-
-    const change = async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => {
-        changing.value = true;
-        try {
-            changed.value = await service.changeLocation(deviceOrganisationId, payload);
-        }
-        finally {
-            changing.value = false;
-        }
-        subscriberIds.push(service.subscribe("all", onEntityChanged(changed)));
-        return changed;
-    }
-
-    return {
-        changing,
-        change,
-        changed
-    }
-}
+export const useChangeDeviceOrganisationGroup = ComposableFactory.custom(DeviceOrganisationServiceFactory, DeviceOrganisationServiceFactory.changeGroup);
+export const useChangeDeviceOrganisationLocation = ComposableFactory.custom(DeviceOrganisationServiceFactory, DeviceOrganisationServiceFactory.changeLocation);

package/composables/services/useDeviceStatuses.ts

@@ -1,5 +1,3 @@
-import { ref } from "vue";
-
 import { DeviceStatusDetails, DeviceStatusDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
@@ -7,39 +5,7 @@ import { DEVICE_STATUS_URL } from "../../config/urls";
 
 const DeviceStatusServiceFactory = new ServiceFactory<DeviceStatusDetailsDTO, DeviceStatusDetails>("deviceStatus", DeviceStatusDetails).create(factory => factory.build(
     factory.addGet(DEVICE_STATUS_URL),
-    factory.addNotify((notifyService) => ({
-        getNotify: async (deviceStatusId: string): Promise<DeviceStatusDetails> => {
-            const response = await ServiceFactory.http.get(DEVICE_STATUS_URL(deviceStatusId));
-            const result = new DeviceStatusDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        }
-    }))
+    factory.addNotify()
 ));
 
-export const useDeviceStatus = ComposableFactory.get(DeviceStatusServiceFactory);
-export const useNotifyDeviceStatus = () => {
-    const service = DeviceStatusServiceFactory();
-
-    const fetching = ref(false);
-    const fetched = ref<DeviceStatusDetails | null>(null);
-
-    const fetch = async (deviceStatusId: string) => {
-        fetching.value = true;
-        try {
-            fetched.value = await service.getNotify(deviceStatusId);
-        }
-        finally {
-            fetching.value = false;
-        }
-        return fetched;
-    }
-
-    return {
-        fetching,
-        fetch,
-        fetched
-    };
-}
+export const useDeviceStatus = ComposableFactory.get(DeviceStatusServiceFactory);

package/composables/services/useGroups.ts

@@ -1,7 +1,5 @@
-import { onUnmounted, ref } from "vue";
-
 import { ChangeGroupParentDTO, CreateGroupDTO, GroupDetails, GroupDetailsDTO, GroupFilters, GroupInfos, GroupInfosDTO, UpdateGroupDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { GROUPS_URL, GROUP_URL } from "../../config/urls";
 
@@ -11,16 +9,8 @@ const GroupServiceFactory = new ServiceFactory<GroupDetailsDTO, GroupDetails>("g
     factory.addCreate<CreateGroupDTO>(GROUPS_URL),
     factory.addUpdate<UpdateGroupDTO>(GROUP_URL),
     factory.addRemove(GROUP_URL),
-    factory.addNotify((notifyService) => ({
-        changeParent: async (groupId: string, payload: ChangeGroupParentDTO): Promise<GroupDetails> => {
-            const response = await ServiceFactory.http.put(GROUP_URL(groupId), payload);
-            const result = new GroupDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        }
-    }))
+    factory.addCustom("changeParent", (axios, groupdId: string, payload: ChangeGroupParentDTO) => axios.put(GROUP_URL(groupdId), payload)),
+    factory.addNotify()
 ));
 
 export const useGroup = ComposableFactory.get(GroupServiceFactory);
@@ -28,33 +18,4 @@ export const useGroups = ComposableFactory.getMany(GroupServiceFactory);
 export const useCreateGroup = ComposableFactory.create(GroupServiceFactory);
 export const useUpdateGroup = ComposableFactory.update(GroupServiceFactory);
 export const useRemoveGroup = ComposableFactory.remove(GroupServiceFactory);
-export const useChangeGroupParent = () => {
-    const service = GroupServiceFactory();
-    const subscriberIds: number[] = [];
-
-    const changing = ref(false);
-    const changed = ref<GroupDetails | null>(null);
-
-    onUnmounted(() => {
-        subscriberIds.forEach(id => service.unsubscribe(id));
-        subscriberIds.length = 0;
-    });
-
-    const change = async (groupId: string, payload: ChangeGroupParentDTO) => {
-        changing.value = true;
-        try {
-            changed.value = await service.changeParent(groupId, payload);
-        }
-        finally {
-            changing.value = false;
-        }
-        subscriberIds.push(service.subscribe("all", onEntityChanged(changed)));
-        return changed;
-    }
-
-    return {
-        changing,
-        change,
-        changed
-    }
-}
+export const useChangeGroupParent = ComposableFactory.custom(GroupServiceFactory, GroupServiceFactory.changeParent);

package/composables/services/useOrganisations.ts

@@ -1,51 +1,12 @@
-import { onUnmounted, ref } from "vue";
-
 import { OrganisationDetails, OrganisationDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
 import { ChangeOrganisationDashboardDTO } from "@dative-gpi/foundation-core-domain/models";
-import { onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { ORGANISATION_DASHBOARD_URL } from "../../config/urls";
 
 const OrganisationServiceFactory = new ServiceFactory<OrganisationDetailsDTO, OrganisationDetails>("organisation", OrganisationDetails).create(factory => factory.build(
-    factory.addNotify((notifyService) => ({
-        changeDashboard: async (payload: ChangeOrganisationDashboardDTO): Promise<OrganisationDetails> => {
-            const response = await ServiceFactory.http.put(ORGANISATION_DASHBOARD_URL(), payload);
-            const result = new OrganisationDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        }
-    }))
+    factory.addCustom("changeDashboard", (axios, payload: ChangeOrganisationDashboardDTO) => axios.put(ORGANISATION_DASHBOARD_URL(), payload)),
+    factory.addNotify()
 ));
 
-export const useChangeDashboardOrganisation = () => {
-    const service = OrganisationServiceFactory();
-    const subscribersIds: number[] = [];
-
-    const changing = ref(false);
-    const changed = ref<OrganisationDetails | null>(null);
-
-    onUnmounted(() => {
-        subscribersIds.forEach(id => service.unsubscribe(id));
-        subscribersIds.length = 0;
-    });
-
-    const change = async (payload: ChangeOrganisationDashboardDTO) => {
-        changing.value = true;
-        try {
-            changed.value = await service.changeDashboard(payload);
-        }
-        finally {
-            changing.value = false;
-        }
-        subscribersIds.push(service.subscribe("all", onEntityChanged(changed)));
-        return changed;
-    }
-
-    return {
-        changing,
-        change,
-        changed
-    }
-}
+export const useChangeDashboardOrganisation = ComposableFactory.custom(OrganisationServiceFactory, OrganisationServiceFactory.changeDashboard);

package/composables/services/useUserOrganisations.ts

@@ -1,7 +1,5 @@
-import { onUnmounted, ref } from "vue";
-
 import { CreateUserOrganisationDTO, UpdateUserOrganisationDTO, UserOrganisationDetails, UserOrganisationDetailsDTO, UserOrganisationFilters, UserOrganisationInfos, UserOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ComposableFactory, onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { USER_ORGANISATIONS_URL, USER_ORGANISATION_CURRENT_URL, USER_ORGANISATION_URL } from "../../config/urls";
 
@@ -11,24 +9,9 @@ const UserOrganisationServiceFactory = new ServiceFactory<UserOrganisationDetail
     factory.addCreate<CreateUserOrganisationDTO>(USER_ORGANISATIONS_URL),
     factory.addUpdate<UpdateUserOrganisationDTO>(USER_ORGANISATION_URL),
     factory.addRemove(USER_ORGANISATION_URL),
-    factory.addNotify((notifyService) => ({
-        getCurrent: async (): Promise<UserOrganisationDetails> => {
-            const response = await ServiceFactory.http.get(USER_ORGANISATION_CURRENT_URL());
-            const result = new UserOrganisationDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        },
-        updateCurrent: async(payload: UpdateUserOrganisationDTO): Promise<UserOrganisationDetails> => {
-            const response = await ServiceFactory.http.post(USER_ORGANISATION_CURRENT_URL(), payload);
-            const result = new UserOrganisationDetails(response.data);
-
-            notifyService.notify("update", result);
-
-            return result;
-        }
-    }))
+    factory.addCustom("getCurrent", (axios) => axios.get(USER_ORGANISATION_CURRENT_URL())),
+    factory.addCustom("updateCurrent", (axios, payload: UpdateUserOrganisationDTO) => axios.post(USER_ORGANISATION_CURRENT_URL(), payload)),
+    factory.addNotify()
 ));
 
 export const useUserOrganisation = ComposableFactory.get(UserOrganisationServiceFactory);
@@ -36,63 +19,5 @@ export const useUserOrganisations = ComposableFactory.getMany(UserOrganisationSe
 export const useCreateUserOrganisation = ComposableFactory.create(UserOrganisationServiceFactory);
 export const useUpdateUserOrganisation = ComposableFactory.update(UserOrganisationServiceFactory);
 export const useRemoveUserOrganisation = ComposableFactory.remove(UserOrganisationServiceFactory);
-export const useCurrentUserOrganisation = () => {
-    const service = UserOrganisationServiceFactory();
-    const subscribersIds: number[] = [];
-
-    const fetching = ref(false);
-    const fetched = ref<UserOrganisationDetails | null>(null);
-
-    onUnmounted(() => {
-        subscribersIds.forEach(id => service.unsubscribe(id));
-        subscribersIds.length = 0;
-    });
-
-    const fetch = async () => {
-        fetching.value = true;
-        try {
-            fetched.value = await service.getCurrent();
-        }
-        finally {
-            fetching.value = false;
-        }
-        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
-        return fetched;
-    }
-
-    return {
-        fetching,
-        fetch,
-        fetched
-    }
-}
-export const useUpdateCurrentUserOrganisation = () => {
-    const service = UserOrganisationServiceFactory();
-    const subscribersIds: number[] = [];
-
-    const updating = ref(false);
-    const updated = ref<UserOrganisationDetails | null>(null);
-
-    onUnmounted(() => {
-        subscribersIds.forEach(id => service.unsubscribe(id));
-        subscribersIds.length = 0;
-    });
-
-    const update = async (payload: UpdateUserOrganisationDTO) => {
-        updating.value = true;
-        try {
-            updated.value = await service.updateCurrent(payload);
-        }
-        finally {
-            updating.value = false;
-        }
-        subscribersIds.push(service.subscribe("all", onEntityChanged(updated)));
-        return updated;
-    }
-
-    return {
-        updating,
-        update,
-        updated
-    }
-}
+export const useCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory, UserOrganisationServiceFactory.getCurrent);
+export const useUpdateCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory, UserOrganisationServiceFactory.updateCurrent);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-core-services",
   "sideEffects": false,
-  "version": "0.0.51",
+  "version": "0.0.53",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.61",
-    "@dative-gpi/foundation-core-domain": "0.0.51",
+    "@dative-gpi/bones-ui": "^0.0.67",
+    "@dative-gpi/foundation-core-domain": "0.0.53",
     "@microsoft/signalr": "^8.0.0",
     "vue": "^3.2.0",
     "vue-router": "^4.2.5"
   },
-  "gitHead": "13a8e0d4bd10a05a35c570412fa2024d33b0c115"
+  "gitHead": "4ecd4c47590cb49ab9f480e12202cde9af5396e1"
 }