@vc-shell/framework 1.0.52 → 1.0.54

package/core/composables/index.ts

@@ -1,6 +1,5 @@
 export { default as useFunctions } from "./useFunctions";
 export { default as useI18n } from "./useI18n";
-export { default as useLogger } from "./useLogger";
 export { default as useUser } from "./useUser";
 export { default as useNotifications } from "./useNotifications";
 export { default as useSettings } from "./useSettings";

package/core/composables/useApiClient/index.ts

@@ -1,12 +1,17 @@
-import { AuthApiBase } from "@/core/api";
 import useUser from "../useUser";
 
-interface UseApiClient<ApiClient extends AuthApiBase> {
+interface IAuthApiBase {
+  authToken: string;
+  setAuthToken(token: string);
+  getBaseUrl(defaultUrl: string, baseUrl: string);
+}
+
+interface UseApiClient<ApiClient extends IAuthApiBase> {
   getApiClient: () => Promise<ApiClient>;
 }
 
-export function useApiClient<ApiClient extends AuthApiBase>(
-  c: new () => ApiClient
+export function useApiClient<ApiClient extends IAuthApiBase>(
+  c: new (baseUrl?: string, http?: { fetch(url: RequestInfo, init?: RequestInit): Promise<Response> }) => ApiClient
 ): UseApiClient<ApiClient> {
   const { getAccessToken } = useUser();
 

package/core/composables/useAsync/index.ts

@@ -1,10 +1,7 @@
 import { readonly, ref } from "vue";
 import { HasLoading } from "../useLoading";
-import useLogger from "../useLogger";
 
-export type AsyncAction<Payload = void, Result = void> = (
-  payload?: Payload
-) => Promise<Result>;
+export type AsyncAction<Payload = void, Result = void> = (payload?: Payload) => Promise<Result>;
 
 export interface UseAsync<Payload = void, Result = void> extends HasLoading {
   action: AsyncAction<Payload, Result>;
@@ -13,7 +10,6 @@ export interface UseAsync<Payload = void, Result = void> extends HasLoading {
 export function useAsync<Payload = void, Result = void>(
   innerAction: AsyncAction<Payload, Result>
 ): UseAsync<Payload, Result> {
-  const logger = useLogger();
   const loading = ref(false);
 
   async function action(payload?: Payload): Promise<Result> {
@@ -21,7 +17,7 @@ export function useAsync<Payload = void, Result = void>(
     try {
       return await innerAction(payload);
     } catch (e) {
-      logger.error(e);
+      console.error(e);
       throw e;
     } finally {
       loading.value = false;

package/core/composables/useAutosave/index.ts

@@ -8,9 +8,7 @@ interface IUseAutosave {
 
 export default (data, modified, defaultName: string): IUseAutosave => {
   const rawValue = computed(() => (isRef(data) ? unref(data) : data));
-  const isModified = computed(() =>
-    isRef(modified) ? unref(modified) : modified
-  );
+  const isModified = computed(() => (isRef(modified) ? unref(modified) : modified));
   const savedValue = ref();
 
   const isSaving = ref(false);

package/core/composables/useFunctions/debounce.ts

@@ -1,7 +1,4 @@
-export default function debounce(
-  func: (...args: unknown[]) => void,
-  delay: number
-): (...args: unknown[]) => void {
+export default function debounce(func: (...args: unknown[]) => void, delay: number): (...args: unknown[]) => void {
   console.debug(`[@vc-shell/framework#useFunctions:debounce] - Entry point`);
   let timer: number | null = null;
 

package/core/composables/useFunctions/delay.ts

@@ -1,7 +1,4 @@
-export default function delay(
-  func: (...args: unknown[]) => void,
-  delay = 0
-): void {
+export default function delay(func: (...args: unknown[]) => void, delay = 0): void {
   console.debug(`[@vc-shell/framework#useFunctions:delay] - Entry point`);
   setTimeout(func, delay);
 }

package/core/composables/useFunctions/once.ts

@@ -1,8 +1,6 @@
 const resultsMap = new WeakMap();
 
-export default function once(
-  func: (...args: unknown[]) => void
-): (...args: unknown[]) => unknown {
+export default function once(func: (...args: unknown[]) => void): (...args: unknown[]) => unknown {
   console.debug(`[@vc-shell/framework#useFunctions:once] - Entry point`);
   return function (...args: unknown[]): unknown {
     if (!resultsMap.has(func)) {

package/core/composables/useFunctions/throttle.ts

@@ -1,7 +1,4 @@
-export default function throttle(
-  func: (...args: unknown[]) => void,
-  delay: number
-): (...args: unknown[]) => void {
+export default function throttle(func: (...args: unknown[]) => void, delay: number): (...args: unknown[]) => void {
   console.debug(`[@vc-shell/framework#useFunctions:throttle] - Entry point`);
   let wasThrottled = false;
 

package/core/composables/useI18n/index.ts

@@ -1,28 +1,7 @@
-import { App } from "vue";
-import {Composer, createI18n, useI18n as VueUseI18n, VueMessageType} from "vue-i18n";
+import { useI18n as VueUseI18n } from "vue-i18n";
 
-export function init(app: App): App {
-  console.debug(`[@vc-shell/framework#useI18n:init] - Entry point`);
-  const i18nPlugin = createI18n({
-    legacy: false,
-    globalInjection: true,
-    locale: "en",
-    fallbackLocale: "en",
-  });
-  app.use(i18nPlugin);
-
-  app.config.globalProperties.$mergeLocaleMessage =
-    i18nPlugin.global.mergeLocaleMessage;
-
-  return app;
-}
-
-export default function useI18n(): Composer<
-    unknown,
-    unknown,
-    unknown,
-    {}
-    > {
+/** @deprecated use `useI18n({ useScope: "global" })` directly from `vue-i18n` */
+export default function useI18n() {
   console.debug(`[@vc-shell/framework#useI18n] - Entry point`);
   return VueUseI18n({ useScope: "global" });
 }

package/core/composables/useLoading/index.ts

@@ -4,8 +4,6 @@ export interface HasLoading {
   loading: Readonly<Ref<boolean>>;
 }
 
-export function useLoading(
-  ...args: Readonly<Ref<boolean>>[]
-): ComputedRef<boolean> {
+export function useLoading(...args: Readonly<Ref<boolean>>[]): ComputedRef<boolean> {
   return computed(() => args.some((item) => item.value));
 }

package/core/composables/useNotifications/index.ts

@@ -1,7 +1,6 @@
-import { PushNotification, PushNotificationClient } from "@/core/api";
+import { PushNotification, PushNotificationClient } from "./../../../core/api";
 import useUser from "../useUser";
 import { computed, ComputedRef, readonly, ref } from "vue";
-import useLogger from "../useLogger";
 import { orderBy, remove } from "lodash-es";
 
 const notificationsClient = new PushNotificationClient();
@@ -22,7 +21,6 @@ const popupNotifications = ref<PushNotification[]>([]);
 
 export default (): INotifications => {
   const { getAccessToken } = useUser();
-  const logger = useLogger();
 
   async function loadFromHistory(take = 10) {
     const token = await getAccessToken();
@@ -41,11 +39,10 @@ export default (): INotifications => {
         });
 
         result.text().then((response) => {
-          notifications.value =
-            <PushNotification[]>JSON.parse(response).notifyEvents ?? [];
+          notifications.value = <PushNotification[]>JSON.parse(response).notifyEvents ?? [];
         });
       } catch (e) {
-        logger.error(e);
+        console.error(e);
         throw e;
       }
     }
@@ -53,9 +50,7 @@ export default (): INotifications => {
 
   function addNotification(message: PushNotification) {
     if (message.notifyType !== "IndexProgressPushNotification") {
-      const existsNotification = notifications.value.find(
-        (x) => x.id == message.id
-      );
+      const existsNotification = notifications.value.find((x) => x.id == message.id);
 
       if (existsNotification) {
         message.isNew = existsNotification.isNew;
@@ -95,16 +90,14 @@ export default (): INotifications => {
           return x;
         });
       } catch (e) {
-        logger.error(e);
+        console.error(e);
         throw e;
       }
     }
   }
 
   return {
-    notifications: computed(() =>
-      readonly(orderBy(notifications.value, ["created"], ["desc"]))
-    ),
+    notifications: computed(() => readonly(orderBy(notifications.value, ["created"], ["desc"]))),
     popupNotifications: computed(() => readonly(popupNotifications.value)),
     loadFromHistory,
     addNotification,

package/core/composables/usePermissions/index.ts

@@ -1,4 +1,4 @@
-import { useUser } from "@/core/composables";
+import { useUser } from "./../../../core/composables";
 import { computed, ComputedRef } from "vue";
 
 interface IUsePermissions {

package/core/composables/useSettings/index.ts

@@ -1,6 +1,6 @@
-import { useUser, useLogger } from "@/core/composables";
+import { useUser } from "./../../../core/composables";
 import { computed, Ref, ref } from "vue";
-import { ObjectSettingEntry, SettingClient } from "@/core/api";
+import { SettingClient } from "./../../../core/api";
 
 interface IUISetting {
   contrast_logo?: string;
@@ -20,7 +20,6 @@ const uiSettings = ref<IUISetting>({
 });
 export default (): IUseSettings => {
   const { getAccessToken } = useUser();
-  const logger = useLogger();
 
   async function getApiClient() {
     const client = new SettingClient();
@@ -41,7 +40,7 @@ export default (): IUseSettings => {
         title: settings.title,
       };
     } catch (e) {
-      logger.error(e);
+      console.error(e);
     }
   }
 

package/core/composables/useUser/index.ts

@@ -7,8 +7,8 @@ import {
   SecurityResult,
   ValidatePasswordResetTokenRequest,
   IdentityResult,
-} from "@/core/api";
-import { AuthData, RequestPasswordResult, SignInResults } from "@/core/types";
+} from "./../../../core/api";
+import { AuthData, RequestPasswordResult, SignInResults } from "./../../../core/types";
 //The Platform Manager uses the same key to store authorization data in the
 //local storage, so we can exchange authorization data between the Platform Manager
 //and the user application that is hosted in the same domain as the sub application.
@@ -32,25 +32,13 @@ interface IUseUser {
   signOut: () => Promise<void>;
   validateToken: (userId: string, token: string) => Promise<boolean>;
   validatePassword: (password: string) => Promise<IdentityResult>;
-  resetPasswordByToken: (
-    userId: string,
-    password: string,
-    token: string
-  ) => Promise<SecurityResult>;
-  requestPasswordReset: (
-    loginOrEmail: string
-  ) => Promise<RequestPasswordResult>;
-  changeUserPassword: (
-    oldPassword: string,
-    newPassword: string
-  ) => Promise<SecurityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
+  requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult>;
 }
 
 export default (): IUseUser => {
-  async function validateToken(
-    userId: string,
-    token: string
-  ): Promise<boolean> {
+  async function validateToken(userId: string, token: string): Promise<boolean> {
     let result = false;
     try {
       loading.value = true;
@@ -69,21 +57,14 @@ export default (): IUseUser => {
     return securityClient.validatePassword(password);
   }
 
-  async function resetPasswordByToken(
-    userId: string,
-    password: string,
-    token: string
-  ): Promise<SecurityResult> {
+  async function resetPasswordByToken(userId: string, password: string, token: string): Promise<SecurityResult> {
     return securityClient.resetPasswordByToken(userId, {
       newPassword: password,
       token,
     } as ResetPasswordConfirmRequest);
   }
 
-  async function signIn(
-    username: string,
-    password: string
-  ): Promise<SignInResults> {
+  async function signIn(username: string, password: string): Promise<SignInResults> {
     console.debug(`[@vc-shell/framework#useUser:signIn] - Entry point`);
     let token = undefined;
     try {
@@ -103,10 +84,7 @@ export default (): IUseUser => {
         expiresAt: addOffsetToCurrentDate(Number(token.data["expires_in"])),
         userName: username,
       };
-      console.log(
-        "[userUsers]: an access token has been obtained successfully",
-        authData.value
-      );
+      console.log("[userUsers]: an access token has been obtained successfully", authData.value);
 
       storeAuthData(authData.value);
       await loadUser();
@@ -153,9 +131,7 @@ export default (): IUseUser => {
         authData.value.refreshToken ?? "",
         {}
       );
-      console.log(
-        "[userUsers]: an access token is expired, using refresh token to receive a new"
-      );
+      console.log("[userUsers]: an access token is expired, using refresh token to receive a new");
       try {
         const newToken = await token.refresh();
         if (newToken) {
@@ -164,9 +140,7 @@ export default (): IUseUser => {
             accessToken: newToken.accessToken,
             token: newToken.accessToken,
             refreshToken: newToken.refreshToken,
-            expiresAt: addOffsetToCurrentDate(
-              Number(newToken.data["expires_in"])
-            ),
+            expiresAt: addOffsetToCurrentDate(Number(newToken.data["expires_in"])),
           };
           storeAuthData(authData.value);
         }
@@ -179,24 +153,17 @@ export default (): IUseUser => {
   }
 
   function storeAuthData(authData: AuthData) {
-    localStorage.setItem(
-      VC_AUTH_DATA_KEY,
-      JSON.stringify({ ...(authData || {}) })
-    );
+    localStorage.setItem(VC_AUTH_DATA_KEY, JSON.stringify({ ...(authData || {}) }));
   }
   function readAuthData(): AuthData {
-    return JSON.parse(
-      localStorage.getItem(VC_AUTH_DATA_KEY) || "{}"
-    ) as AuthData;
+    return JSON.parse(localStorage.getItem(VC_AUTH_DATA_KEY) || "{}") as AuthData;
   }
 
   function addOffsetToCurrentDate(offsetInSeconds: number): number {
     return Date.now() + offsetInSeconds * 1000;
   }
 
-  async function requestPasswordReset(
-    loginOrEmail: string
-  ): Promise<RequestPasswordResult> {
+  async function requestPasswordReset(loginOrEmail: string): Promise<RequestPasswordResult> {
     try {
       loading.value = true;
       await securityClient.requestPasswordReset(loginOrEmail);
@@ -209,10 +176,7 @@ export default (): IUseUser => {
     }
   }
 
-  async function changeUserPassword(
-    oldPassword: string,
-    newPassword: string
-  ): Promise<SecurityResult> {
+  async function changeUserPassword(oldPassword: string, newPassword: string): Promise<SecurityResult> {
     const token = await getAccessToken();
     let result;
 
@@ -220,21 +184,18 @@ export default (): IUseUser => {
     if (token) {
       try {
         loading.value = true;
-        const res = await fetch(
-          "/api/platform/security/currentuser/changepassword",
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json-patch+json",
-              Accept: "text/plain",
-              authorization: `Bearer ${token}`,
-            },
-            body: JSON.stringify({
-              oldPassword,
-              newPassword,
-            }),
-          }
-        );
+        const res = await fetch("/api/platform/security/currentuser/changepassword", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json-patch+json",
+            Accept: "text/plain",
+            authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({
+            oldPassword,
+            newPassword,
+          }),
+        });
         if (res.status !== 500) {
           result = await res.text().then((response) => {
             return JSON.parse(response);

package/core/directives/permissions/index.ts

@@ -1,5 +1,5 @@
 import { Directive, DirectiveBinding } from "vue";
-import { usePermissions } from "@/core/composables";
+import { usePermissions } from "./../../../core/composables";
 const { checkPermission } = usePermissions();
 
 function checkAndRemove(el: HTMLElement, binding: DirectiveBinding) {

package/core/plugins/i18n/index.ts

@@ -0,0 +1,8 @@
+import { createI18n } from "vue-i18n";
+
+export default createI18n({
+  legacy: false,
+  globalInjection: true,
+  locale: "en",
+  fallbackLocale: "en",
+});

package/core/plugins/index.ts

@@ -1,2 +1,4 @@
-export * from "./validation";
 export * from "./moment";
+export { default as i18n } from "./i18n";
+export * from "./validation";
+export * from "./modularity";

package/core/plugins/modularity/index.ts

@@ -0,0 +1,32 @@
+import { App } from "vue";
+import { default as i18n } from "../i18n";
+
+export const createModule = (components: unknown, locales?: unknown) => ({
+  install(app: App): void {
+    // Register components
+    Object.entries(components).forEach(([componentName, component]) => {
+      app.component(componentName, component);
+    });
+
+    // Load locales
+    if (locales) {
+      Object.entries(locales).forEach(([key, message]) => {
+        i18n.global.mergeLocaleMessage(key, message);
+      });
+    }
+  },
+});
+
+export const createAppModule = (pages: unknown, locales?: unknown) => {
+  const module = createModule(pages, locales);
+
+  return {
+    install(app: App): void {
+      // Register pages
+      Object.entries(pages).forEach(([, page]) => {
+        app.config.globalProperties.pages?.push(page);
+      });
+      module.install(app);
+    },
+  };
+};

package/core/plugins/moment/humanize.ts

@@ -1,10 +1,7 @@
 import _ from "lodash";
 import { default as moment, Duration, RelativeTimeKey } from "moment";
 
-type momentUnit = Extract<
-  moment.RelativeTimeKey,
-  "s" | "m" | "h" | "d" | "w" | "M" | "y"
->;
+type momentUnit = Extract<moment.RelativeTimeKey, "s" | "m" | "h" | "d" | "w" | "M" | "y">;
 
 const momentUnits: momentUnit[] = ["s", "m", "h", "d", "w", "M", "y"];
 

package/core/plugins/validation/index.ts

@@ -1,2 +1,12 @@
+import { localize } from "@vee-validate/i18n";
+import en from "@vee-validate/i18n/dist/locale/en.json";
+import * as veeValidate from "vee-validate";
+
+veeValidate.configure({
+  generateMessage: localize({ en }),
+});
+
+/** @deprecated Use `useForm` directly from `vee-validate` */
+export const useForm = veeValidate.useForm;
+
 export * from "./rules";
-export { useForm } from "vee-validate";