@vc-shell/framework 1.0.120 → 1.0.122

package/core/composables/useApiClient/index.ts

@@ -17,7 +17,8 @@ export function useApiClient<ApiClient extends IAuthApiBase>(
 
   async function getApiClient() {
     const client = new c();
-    client.setAuthToken(await getAccessToken());
+    const token = await getAccessToken();
+    if (token) client.setAuthToken(token);
     return client;
   }
 

package/core/composables/useAsync/index.ts

@@ -1,7 +1,7 @@
 import { readonly, ref } from "vue";
 import { HasLoading } from "../useLoading";
 
-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>;
@@ -12,10 +12,10 @@ export function useAsync<Payload = void, Result = void>(
 ): UseAsync<Payload, Result> {
   const loading = ref(false);
 
-  async function action(payload: Payload): Promise<Result> {
+  async function action(payload?: Payload): Promise<Result> {
     loading.value = true;
     try {
-      return await innerAction(payload);
+      return await innerAction(payload ?? ({} as Payload));
     } catch (e) {
       console.error(e);
       throw e;

package/core/composables/useErrorHandler/index.ts

@@ -1,12 +1,12 @@
 import { onErrorCaptured, getCurrentInstance, ref, Ref } from "vue";
 
 interface IUseErrorHandler {
-  error: Ref<string>;
+  error: Ref<string | null>;
   reset(): void;
 }
 
 export function useErrorHandler(capture?: boolean): IUseErrorHandler {
-  const error = ref<string>(null);
+  const error = ref<string | null>(null);
   const instance = getCurrentInstance();
 
   function reset() {

package/core/composables/useFunctions/debounce.ts

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

package/core/composables/useNotifications/index.ts

@@ -95,11 +95,10 @@ export function useNotifications(notifyType?: string | string[]): INotifications
 
   const moduleNotifications = computed(
     () =>
-      (notifyType &&
-        pushNotifications.value.filter(
-          (item: PushNotification) => item.isNew && notifyType.includes(item.notifyType)
-        )) ??
-      []
+      pushNotifications.value.filter(
+        (item: PushNotification) =>
+          item.isNew && !!item.notifyType && !!notifyType && notifyType.includes(item.notifyType)
+      ) ?? []
   );
 
   return {

package/core/composables/usePermissions/index.ts

@@ -1,30 +1,26 @@
-import { Ref, onMounted, ref } from "vue";
+import { Ref, ref } from "vue";
 import { useUser } from "./../useUser";
 
 interface IUsePermissions {
-  hasAccess(permissions: string | string[]): boolean;
+  hasAccess(permissions: string | string[] | undefined): boolean;
 }
 const userPermissions: Ref<string[]> = ref([]);
 export function usePermissions(): IUsePermissions {
   const { user } = useUser();
 
   if (user.value) {
-    userPermissions.value = user.value?.permissions;
+    userPermissions.value = user.value?.permissions ?? [];
   }
 
   function hasAccess(permissions: string | string[] | undefined) {
     if (!permissions) {
       return true;
-    } else if (permissions || (permissions && permissions instanceof Array)) {
-      if (typeof permissions === "string") {
-        return userPermissions.value?.includes(permissions);
-      } else if (permissions.length > 0) {
-        return userPermissions.value?.some((role) => {
-          return permissions.includes(role);
-        });
-      }
+    } else if (Array.isArray(permissions)) {
+      return permissions.some((permission) => userPermissions.value.includes(permission));
+    } else if (typeof permissions === "string") {
+      return userPermissions.value.includes(permissions);
     } else {
-      throw new Error("Permissions must be a string or strings array");
+      throw new Error("Permissions must be a string or an array of strings");
     }
   }
 

package/core/composables/useSettings/index.ts

@@ -24,7 +24,7 @@ export function useSettings(): IUseSettings {
 
   async function getApiClient() {
     const client = new SettingClient();
-    client.setAuthToken(await getAccessToken());
+    client.setAuthToken((await getAccessToken()) ?? "");
     return client;
   }
 

package/core/composables/useUser/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { computed, Ref, ref, ComputedRef } from "vue";
 import ClientOAuth2 from "client-oauth2";
 import {
@@ -19,9 +20,9 @@ import { useLocalStorage } from "@vueuse/core";
 //and the user application that is hosted in the same domain as the sub application.
 const VC_AUTH_DATA_KEY = "ls.authenticationData";
 
-const user: Ref<UserDetail> = ref();
+const user: Ref<UserDetail | undefined> = ref();
 const loading: Ref<boolean> = ref(false);
-const authData: Ref<AuthData> = ref();
+const authData: Ref<AuthData | undefined> = ref();
 const authClient = new ClientOAuth2({
   accessTokenUri: `/connect/token`,
   scopes: ["offline_access"],
@@ -29,10 +30,10 @@ const authClient = new ClientOAuth2({
 const securityClient = new SecurityClient();
 
 interface IUseUser {
-  user: ComputedRef<UserDetail | null>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
-  isAdministrator: ComputedRef<boolean>;
-  getAccessToken: () => Promise<string | null>;
+  isAdministrator: ComputedRef<boolean | undefined>;
+  getAccessToken: () => Promise<string | undefined>;
   loadUser: () => Promise<UserDetail>;
   signIn: (username: string, password: string) => Promise<SignInResults>;
   signOut: () => Promise<void>;
@@ -40,8 +41,8 @@ interface IUseUser {
   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>;
-  getExternalLoginProviders: () => Promise<ExternalSignInProviderInfo[]>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
+  getExternalLoginProviders: () => Promise<ExternalSignInProviderInfo[] | undefined>;
   externalSignIn: (authenticationType?: string | undefined, returnUrl?: string | undefined) => void;
   getLoginType: () => Promise<LoginType[]>;
   isAuthenticated: () => Promise<boolean>;
@@ -50,7 +51,9 @@ interface IUseUser {
 export function useUser(): IUseUser {
   const base = window.location.origin + "/";
   const externalSecurityClient = new ExternalSignInClient(base);
-  const externalSignInStorage = useLocalStorage<{ providerType: string }>("externalSignIn", { providerType: null });
+  const externalSignInStorage = useLocalStorage<{ providerType: string | undefined }>("externalSignIn", {
+    providerType: undefined,
+  });
 
   const isAuthenticated = async () => {
     return !!((externalSignInStorage.value && externalSignInStorage.value.providerType) ?? (await getAccessToken()));
@@ -143,7 +146,7 @@ export function useUser(): IUseUser {
     return { ...user.value } as UserDetail;
   }
 
-  async function getAccessToken(): Promise<string | null> {
+  async function getAccessToken(): Promise<string | undefined> {
     console.debug(`[@vc-shell/framework#useUser:getAccessToken] - Entry point`);
     if (!authData.value || Object.keys(authData.value).length === 0) {
       authData.value = await readAuthData();
@@ -202,7 +205,7 @@ export function useUser(): IUseUser {
     }
   }
 
-  async function changeUserPassword(oldPassword: string, newPassword: string): Promise<SecurityResult> {
+  async function changeUserPassword(oldPassword: string, newPassword: string): Promise<SecurityResult | undefined> {
     const token = await getAccessToken();
     let result;
 
@@ -215,7 +218,7 @@ export function useUser(): IUseUser {
         });
 
         result = await securityClient.changeCurrentUserPassword(command);
-      } catch (e) {
+      } catch (e: any) {
         return { succeeded: false, errors: [e.message] } as SecurityResult;
       } finally {
         loading.value = false;
@@ -225,8 +228,8 @@ export function useUser(): IUseUser {
     return result;
   }
 
-  async function getLoginType(): Promise<LoginType[]> {
-    let result = null as LoginType[];
+  async function getLoginType() {
+    let result: LoginType[] | null = null;
     try {
       result = await securityClient.getLoginTypes();
     } catch (e) {
@@ -237,18 +240,19 @@ export function useUser(): IUseUser {
     return result;
   }
 
-  async function getExternalLoginProviders(): Promise<ExternalSignInProviderInfo[]> {
-    let result = null as ExternalSignInProviderInfo[];
+  async function getExternalLoginProviders() {
+    let result: ExternalSignInProviderInfo[] | undefined = undefined;
     try {
       result = await externalSecurityClient.getExternalLoginProviders();
     } catch (e) {
       console.error(e);
+      // TODO check error in app!!!
     }
 
     return result;
   }
 
-  async function externalSignIn(authenticationType: string, returnUrl: string) {
+  async function externalSignIn(authenticationType: string | undefined, returnUrl: string | undefined) {
     try {
       let url_ = base + "externalsignin?";
 
@@ -288,7 +292,7 @@ export function useUser(): IUseUser {
   return {
     user: computed(() => user.value),
     loading: computed(() => loading.value),
-    isAdministrator: computed(() => user.value.isAdministrator),
+    isAdministrator: computed(() => user.value?.isAdministrator),
     isAuthenticated,
     getAccessToken,
     loadUser,

package/core/plugins/modularity/index.ts

@@ -1,10 +1,14 @@
 import { App, Component } from "vue";
 import { i18n } from "./../i18n";
 import { Router } from "vue-router";
-import { BladeConstructor } from "./../../../shared/components/blade-navigation/types";
+import { BladeInstanceConstructor } from "./../../../shared/components/blade-navigation/types";
 import { kebabToPascal } from "./../../utilities";
 
-export const createModule = (components: unknown, locales?: unknown, isBladeComponent?: boolean) => ({
+export const createModule = (
+  components: { [key: string]: BladeInstanceConstructor },
+  locales?: unknown,
+  isBladeComponent?: boolean
+) => ({
   install(app: App): void {
     // Register components
     Object.entries(components).forEach(([componentName, component]) => {
@@ -21,7 +25,7 @@ export const createModule = (components: unknown, locales?: unknown, isBladeComp
 });
 
 export const createAppModule = (
-  pages: { [key: string]: BladeConstructor },
+  pages: { [key: string]: BladeInstanceConstructor },
   locales?: { [key: string]: object },
   notificationTemplates?: { [key: string]: Component },
   moduleComponents?: { [key: string]: Component }

package/core/plugins/moment/humanize.ts

@@ -21,7 +21,7 @@ const getIntlNumberFormat = (unit: momentUnit) => {
 
 // Workaround because of lacking precise (1 hour 42 minutes 35 seconds)
 // duration formatting in moment and Intl
-export function humanize(this: Duration & number, withSuffix: boolean): string {
+export function humanize(this: Duration & number, withSuffix?: boolean): string {
   const localeData = moment.localeData();
 
   const units = _.clone(momentUnits);
@@ -50,8 +50,8 @@ export function humanize(this: Duration & number, withSuffix: boolean): string {
   }));
   // add value of last unit as double-precision float, if it's greater than 0
   map.push({
-    unit: lastUnit,
-    value: this.get(lastUnit) > 0 ? this.as(lastUnit) : 0,
+    unit: lastUnit as momentUnit,
+    value: this.get(lastUnit as momentUnit) > 0 ? this.as(lastUnit as momentUnit) : 0,
   });
 
   // drop zero values from the beginning and the end of the array

package/core/plugins/moment/moment.ts

@@ -1,4 +1,4 @@
-import { default as moment } from "moment";
+import { Duration, default as moment, argAccuracy } from "moment";
 import { humanize } from "./humanize";
 
 declare module "moment" {
@@ -20,10 +20,10 @@ declare module "moment" {
 const humanizeOriginal = moment.duration.fn.humanize;
 moment.duration.fn.humanize = function (...args: unknown[]): string {
   if (args.includes("precise")) {
-    return humanize.apply(this, args);
+    return humanize.apply(this as Duration & number, args as [withSuffix?: boolean | undefined]);
   }
 
-  return humanizeOriginal.apply(this, args);
+  return humanizeOriginal.apply(this, args as [argAccuracy?: argAccuracy | undefined]);
 };
 
 export default moment;

package/core/plugins/validation/rules.ts

@@ -113,7 +113,7 @@ const compare = (
     second_date = new Date(target);
   }
 
-  if (first_date?.getTime() > 0 && second_date?.getTime() > 0) {
+  if (first_date?.getTime && first_date?.getTime() > 0 && second_date?.getTime && second_date?.getTime() > 0) {
     if (comparer(second_date.getTime(), first_date.getTime())) {
       return errorMessage;
     }

package/core/types/index.ts

@@ -1,11 +1,6 @@
-import { ComponentPublicInstance, ComputedRef, Ref } from "vue";
-import {
-  CoreBladeExposed,
-  BladeConstructor,
-  ExtractedBladeOptions,
-  ComponentInstanceConstructor,
-  BladeInstanceConstructor,
-} from "./../../shared";
+import { ComponentPublicInstance, ComputedRef, DefineComponent, Ref, UnwrapRef, Component } from "vue";
+import { CoreBladeExposed, ExtractedBladeOptions, BladeInstanceConstructor } from "./../../shared";
+import { ComponentPublicInstanceConstructor } from "../../shared/utilities/vueUtils";
 
 // Type instead of interface here is workaround for:
 // https://github.com/microsoft/TypeScript/issues/15300
@@ -55,15 +50,15 @@ export interface IBladeDropdownItem {
   clickHandler?(): void;
 }
 
-export interface BladeMenu<T extends ComponentPublicInstance = ComponentPublicInstance> {
+export interface BladeMenu<T extends Component = Component> {
   title?: string | Ref<string>;
   icon?: string;
   isVisible?: boolean | Ref<boolean>;
-  component?: BladeConstructor<T>;
+  component?: BladeInstanceConstructor<T>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  clickHandler?(app?: Record<string, any> | CoreBladeExposed): void;
+  clickHandler?(app?: Record<string, any> | CoreBladeExposed | null): void;
   children?: BladeMenu<T>[];
-  options?: ExtractedBladeOptions<InstanceType<BladeConstructor<T>>["$props"], "options">;
+  options?: ExtractedBladeOptions<InstanceType<BladeInstanceConstructor<T>>["$props"], "options">;
 }
 
 export interface IBladeToolbar<T extends ComponentPublicInstance = ComponentPublicInstance>
@@ -71,10 +66,10 @@ export interface IBladeToolbar<T extends ComponentPublicInstance = ComponentPubl
   id?: string;
   icon?: string | (() => string);
   isAccent?: boolean | ComputedRef<boolean>;
-  component?: ComponentInstanceConstructor<T>;
-  disabled?: boolean | ComputedRef<boolean>;
+  component?: ComponentPublicInstanceConstructor<T>;
+  disabled?: boolean | ComputedRef<boolean | undefined>;
   dropdownItems?: IBladeDropdownItem[];
-  options?: InstanceType<ComponentInstanceConstructor<T>>["$props"];
+  options?: InstanceType<ComponentPublicInstanceConstructor<T>>["$props"];
 }
 
 export type NavigationMenu<T> = T extends {
@@ -94,15 +89,15 @@ export type NavigationMenu<T> = T extends {
   : T & { component?: BladeInstanceConstructor };
 
 export type ToolbarMenu<T> = T extends {
-  component?: infer C extends ComponentInstanceConstructor;
+  component?: infer C extends ComponentPublicInstanceConstructor;
 }
   ? {
       component?: C;
       options?: InstanceType<C>["$props"];
     } & IBladeToolbar
-  : T & { component?: ComponentInstanceConstructor };
+  : T & { component?: ComponentPublicInstanceConstructor };
 
-export type NotificationTemplateConstructor = ComponentInstanceConstructor & {
+export type NotificationTemplateConstructor = ComponentPublicInstanceConstructor & {
   notifyType: string;
 };
 
@@ -115,13 +110,13 @@ export interface IActionBuilderResult<T = {}> {
   clickHandler(item?: T): void;
 }
 
-export interface AssetsHandler<T, A> {
-  loading: Ref<boolean>;
-  upload: (files: FileList, assetArr: T[], uploadCatalog: string, uploadFolder: string) => Promise<T[]>;
-  edit: (assetsArr: T[], asset: A) => Promise<T[]>;
-  editBulk: (assets: A[]) => T[];
-  remove: (assetArr: T[], asset: A) => Promise<T[]>;
-  removeBulk: (assetArr: T[], assetsArrEdited: T[]) => Promise<T[]>;
+export interface AssetsHandler<T> {
+  loading?: Ref<boolean>;
+  upload?: (files: FileList, assetArr: T[], uploadCatalog: string, uploadFolder: string) => Promise<T[] | void> | void;
+  edit?: (assetsArr: T[], asset: T) => Promise<T[] | void> | void;
+  editBulk?: (assets: T[]) => T[];
+  remove?: (assetArr: T[], asset: T) => Promise<T[] | void> | void;
+  removeBulk?: (assetArr: T[], assetsArrEdited: T[]) => Promise<T[] | void> | void;
 }
 
 export interface IImage {

package/dist/core/api/platform.d.ts

@@ -84,11 +84,11 @@ export declare class ChangeLogClient extends AuthApiBase {
     resetPlatformCache(): Promise<void>;
     protected processResetPlatformCache(response: Response): Promise<void>;
     /**
-     * Get last modified date for given scope
-    Used for signal of what something changed and for cache invalidation in external platform clients
-     * @param scope (optional)
-     * @return Success
-     */
+       * Get last modified date for given scope
+      Used for signal of what something changed and for cache invalidation in external platform clients
+       * @param scope (optional)
+       * @return Success
+       */
     getLastModifiedDate(scope?: string | undefined): Promise<LastModifiedResponse>;
     protected processGetLastModifiedDate(response: Response): Promise<LastModifiedResponse>;
     /**