@progressive-development/pd-spa-helper 0.9.2 → 1.0.0

package/dist/service-provider/firebase/firestorage-client.d.ts

@@ -0,0 +1,22 @@
+import { FirebaseApp } from 'firebase/app';
+import { UploadResult } from 'firebase/storage';
+import { FileStorageConfig, StorageDocument, UploadFile } from '../service-provider-model.js';
+/**
+ * During start/load application, initialize functions.
+ *
+ * @param {*} app - initialized app.
+ */
+export declare const initFirestorage: (app: FirebaseApp, defaultStorage?: string, storageConfig?: FileStorageConfig) => void;
+export declare const getFirestorageConf: () => FileStorageConfig | undefined;
+export declare const uploadFirestorageFile: (file: UploadFile) => Promise<UploadResult>;
+export declare const getFirestorageFile: (storageName: string, refKey: string, storageURI: string, includeMetaData?: boolean) => Promise<StorageDocument>;
+export declare const getFirestorageFileList: (storageName: string, refKey: string, subFolder?: string, includeMetaData?: boolean) => Promise<StorageDocument[]>;
+export declare const downloadFileFirestorage: (file: StorageDocument) => Promise<string>;
+/**
+ * Löscht eine Datei in Firebase Storage basierend auf den Informationen im StorageDocument.
+ *
+ * @param deleteFile - Das StorageDocument-Objekt, das die zu löschende Datei beschreibt.
+ * @returns Ein Promise, das erfüllt wird, wenn die Datei gelöscht wurde, oder abgelehnt wird, wenn ein Fehler auftritt.
+ */
+export declare function deleteFirestorageDocument(deleteFile: StorageDocument): Promise<void>;
+//# sourceMappingURL=firestorage-client.d.ts.map

package/dist/service-provider/firebase/firestorage-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestorage-client.d.ts","sourceRoot":"","sources":["../../../src/service-provider/firebase/firestorage-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAKL,YAAY,EAQb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,UAAU,EACX,MAAM,8BAA8B,CAAC;AAqBtC;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,WAAW,EAChB,iBAAiB,MAAM,EACvB,gBAAgB,iBAAiB,SAkClC,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAO,iBAAiB,GAAG,SAC7C,CAAC;AAEd,eAAO,MAAM,qBAAqB,GAChC,MAAM,UAAU,KACf,OAAO,CAAC,YAAY,CA8CtB,CAAC;AAsFF,eAAO,MAAM,kBAAkB,GAC7B,aAAa,MAAM,EACnB,QAAQ,MAAM,EACd,YAAY,MAAM,EAClB,yBAAuB,KACtB,OAAO,CAAC,eAAe,CA2CzB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,EACnB,QAAQ,MAAM,EACd,YAAY,MAAM,EAClB,kBAAkB,OAAO,KACxB,OAAO,CAAC,eAAe,EAAE,CAoC3B,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,MAAM,eAAe,oBAY5D,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,IAAI,CAAC,CAsBf"}

package/dist/service-provider/firebase/firestorage-client.js

@@ -0,0 +1,226 @@
+import { getStorage, ref, uploadString, getMetadata, getDownloadURL, deleteObject, listAll } from 'firebase/storage';
+import { getUser } from '../service-provider-impl.js';
+import { createLogger } from '../../helper/logger.js';
+
+const storageLogger = createLogger("PdStorage");
+const DEFAULT_STORAGE = "default_storage";
+let storageConf;
+const storageMap = /* @__PURE__ */ new Map();
+const initFirestorage = (app, defaultStorage, storageConfig) => {
+  try {
+    storageConf = storageConfig;
+    if (defaultStorage) {
+      storageMap.set(DEFAULT_STORAGE, {
+        storage: getStorage(app)
+      });
+    }
+    storageConfig?.storage.forEach((storeConfig) => {
+      const storage = getStorage(app, storeConfig.name);
+      const storageRootRef = ref(storage);
+      storageMap.set(storeConfig.name, {
+        storage,
+        references: [
+          {
+            key: "ROOT",
+            storageRef: storageRootRef
+          },
+          ...storeConfig.references.map((refConfigString) => ({
+            key: refConfigString,
+            storageRef: ref(storageRootRef, refConfigString)
+          }))
+        ]
+      });
+    });
+  } catch (error) {
+    storageLogger.error("Init error", error);
+  }
+};
+const getFirestorageConf = () => storageConf;
+const uploadFirestorageFile = (file) => {
+  if (!storageMap || storageMap.size === 0) {
+    throw new Error("No storage is configured");
+  }
+  const { storageName, referenceKey, subFolderName, fileName } = file;
+  const storageConf2 = storageMap.get(storageName || DEFAULT_STORAGE);
+  if (!storageConf2) {
+    throw new Error(`Invalid storage name: ${storageName || DEFAULT_STORAGE}`);
+  }
+  if (!storageConf2.references || storageConf2.references.length === 0) {
+    throw new Error(
+      `No references configured for storage: ${storageName || DEFAULT_STORAGE}`
+    );
+  }
+  const uploadRefConf = referenceKey ? storageConf2.references.filter(
+    (filterRef) => filterRef.key === referenceKey
+  )[0] : storageConf2.references[0];
+  if (!uploadRefConf || !uploadRefConf.storageRef) {
+    throw new Error(`No valid reference for key: ${referenceKey}`);
+  }
+  const fileRef = ref(
+    uploadRefConf.storageRef,
+    subFolderName ? `${subFolderName}/${fileName}` : fileName
+  );
+  const metadata = {
+    customMetadata: {
+      creator: getUser()?.displayName,
+      comment: file.description,
+      name: file.descriptionName,
+      readonly: file.readonly ? "true" : "false"
+    }
+  };
+  return uploadString(fileRef, file.base64DataURL, "data_url", metadata);
+};
+const fetchItemsAndFolders = async (usedRef, storageName, refKey, includeMetaData = false, includeFolder = false) => {
+  try {
+    const itemRefs = [];
+    const metaPromises = [];
+    const res = await listAll(usedRef);
+    const processMetadata = (item, metadata) => ({
+      ...item,
+      creation: new Date(metadata.timeCreated),
+      documentType: metadata.contentType,
+      creator: metadata.customMetadata?.creator,
+      descriptionName: metadata.customMetadata?.name,
+      description: metadata.customMetadata?.comment,
+      size: metadata.size,
+      readonly: metadata.customMetadata?.readonly === "true",
+      metaData: metadata
+    });
+    res.items.forEach((itemRef) => {
+      itemRefs.push({
+        fileName: itemRef.name,
+        filePath: itemRef.fullPath,
+        storageName,
+        refKey
+      });
+      if (includeMetaData) {
+        metaPromises.push(getMetadata(itemRef));
+      }
+    });
+    if (includeFolder) {
+      await Promise.all(
+        res.prefixes.map(async (folderRef) => {
+          const folderRes = await listAll(folderRef);
+          folderRes.items.forEach((subItemRef) => {
+            itemRefs.push({
+              fileName: subItemRef.name,
+              filePath: subItemRef.fullPath,
+              storageName,
+              refKey,
+              subFolderName: folderRef.name
+            });
+            if (includeMetaData) {
+              metaPromises.push(getMetadata(subItemRef));
+            }
+          });
+        })
+      );
+    }
+    if (includeMetaData) {
+      const metaResults = await Promise.all(metaPromises);
+      return itemRefs.map(
+        (item, index) => processMetadata(item, metaResults[index])
+      );
+    }
+    return itemRefs;
+  } catch (error) {
+    storageLogger.error("Error during file and folder listing:", error);
+    throw error;
+  }
+};
+const getFirestorageFile = async (storageName, refKey, storageURI, includeMetaData = false) => {
+  try {
+    if (!storageMap || storageMap.size === 0) {
+      throw new Error("No storage is configured");
+    }
+    const storageConf2 = storageMap.get(storageName);
+    if (!storageConf2) {
+      throw new Error(`Invalid storage name: ${storageName}`);
+    }
+    const storageRef = ref(storageConf2.storage, storageURI);
+    const storageDocument = {
+      fileName: storageRef.name,
+      filePath: storageRef.fullPath,
+      storageName,
+      refKey
+    };
+    if (includeMetaData) {
+      const metadata = await getMetadata(storageRef);
+      return {
+        ...storageDocument,
+        creation: new Date(metadata.timeCreated),
+        documentType: metadata.contentType,
+        creator: metadata.customMetadata?.creator,
+        descriptionName: metadata.customMetadata?.name,
+        description: metadata.customMetadata?.comment,
+        size: metadata.size,
+        readonly: metadata.customMetadata?.readonly === "true",
+        metaData: metadata
+      };
+    }
+    return storageDocument;
+  } catch (error) {
+    storageLogger.error("Error creating StorageDocument:", error);
+    throw error;
+  }
+};
+const getFirestorageFileList = (storageName, refKey, subFolder, includeMetaData) => {
+  if (!storageMap || storageMap.size === 0) {
+    throw new Error("No storage is configured");
+  }
+  const storageConf2 = storageMap.get(storageName);
+  if (!storageConf2) {
+    throw new Error(`Invalid storage name: ${storageName}`);
+  }
+  if (!storageConf2.references || storageConf2.references.length === 0) {
+    throw new Error(
+      `No references configured for storage: ${storageName || DEFAULT_STORAGE}`
+    );
+  }
+  const storageRef = storageConf2.references.filter(
+    (refIt) => refIt.key === refKey
+  )[0];
+  if (!storageRef) {
+    throw new Error(
+      `No reference available for storage: ${storageName || DEFAULT_STORAGE} and ref: ${refKey}`
+    );
+  }
+  const usedRef = subFolder ? ref(storageRef.storageRef, subFolder) : storageRef.storageRef;
+  return fetchItemsAndFolders(
+    usedRef,
+    storageName,
+    refKey,
+    includeMetaData,
+    true
+  );
+};
+const downloadFileFirestorage = (file) => {
+  if (!storageMap || storageMap.size === 0) {
+    throw new Error("No storage is configured");
+  }
+  const storageConf2 = storageMap.get(file.storageName);
+  if (!storageConf2) {
+    throw new Error(`Invalid storage name: ${file.storageName}`);
+  }
+  const usedRef = ref(storageConf2.storage, file.filePath);
+  return getDownloadURL(usedRef);
+};
+async function deleteFirestorageDocument(deleteFile) {
+  if (!deleteFile.filePath) {
+    throw new Error("File path is required to delete a document.");
+  }
+  const storageConf2 = storageMap.get(deleteFile.storageName);
+  if (!storageConf2) {
+    throw new Error(`Invalid storage name: ${deleteFile.storageName}`);
+  }
+  const deleteRef = ref(storageConf2.storage, deleteFile.filePath);
+  try {
+    await deleteObject(deleteRef);
+    storageLogger.info(`File ${deleteFile.fileName} successfully deleted.`);
+  } catch (error) {
+    storageLogger.error("Error deleting file:", error);
+    throw error;
+  }
+}
+
+export { deleteFirestorageDocument, downloadFileFirestorage, getFirestorageConf, getFirestorageFile, getFirestorageFileList, initFirestorage, uploadFirestorageFile };

package/dist/service-provider/firebase/firestore-client.d.ts

@@ -0,0 +1,12 @@
+import { FirebaseApp } from 'firebase/app';
+import { Firestore } from 'firebase/firestore';
+import { CollectionContraint } from '../service-provider-model';
+/**
+ * During start/load application, initialize functions.
+ *
+ * @param {*} app - initialized app.
+ */
+export declare const initFirestore: (app: FirebaseApp) => void;
+export declare const getDB: () => Firestore;
+export declare const getFirebaseCollectionListener: (callback: (query: any) => void, col: string, constraints?: CollectionContraint[]) => import('firebase/firestore').Unsubscribe;
+//# sourceMappingURL=firestore-client.d.ts.map

package/dist/service-provider/firebase/firestore-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore-client.d.ts","sourceRoot":"","sources":["../../../src/service-provider/firebase/firestore-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAEL,SAAS,EAMV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAMhE;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,WAAW,SAO7C,CAAC;AAEF,eAAO,MAAM,KAAK,QAAO,SAAe,CAAC;AAEzC,eAAO,MAAM,6BAA6B,GACxC,UAAU,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,EAC9B,KAAK,MAAM,EACX,cAAc,mBAAmB,EAAE,6CAYpC,CAAC"}

package/dist/service-provider/firebase/firestore-client.js

@@ -0,0 +1,25 @@
+import { getFirestore, where, query, collection, onSnapshot } from 'firebase/firestore';
+import { defaultLogger } from '../../helper/logger.js';
+
+let db;
+const initFirestore = (app) => {
+  try {
+    db = getFirestore(app);
+  } catch (error) {
+    defaultLogger.error("Error during firestore init", error);
+  }
+};
+const getFirebaseCollectionListener = (callback, col, constraints) => {
+  const queryConstraints = (constraints || []).map(
+    (constraint) => {
+      if (constraint.type === "where") {
+        return where(constraint.field, constraint.operator, constraint.value);
+      }
+      throw new Error(`Unkown constraint type: ${constraint.type}`);
+    }
+  );
+  const q = query(collection(db, col), ...queryConstraints);
+  return onSnapshot(q, (querySnapshot) => callback(querySnapshot));
+};
+
+export { getFirebaseCollectionListener, initFirestore };

package/dist/service-provider/firebase/functions-client.d.ts

@@ -0,0 +1,10 @@
+import { FirebaseApp } from 'firebase/app';
+import { FunctionDefinition, FunctionResult, FunctionsConfig } from '../service-provider-model.js';
+/**
+ * During start/load application, initialize functions.
+ *
+ * @param {*} app - initialized app.
+ */
+export declare const initFunctions: (app: FirebaseApp, functionsConfig: FunctionsConfig) => void;
+export declare const callFunction: (def: FunctionDefinition, functionInput: any) => Promise<FunctionResult>;
+//# sourceMappingURL=functions-client.d.ts.map

package/dist/service-provider/firebase/functions-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions-client.d.ts","sourceRoot":"","sources":["../../../src/service-provider/firebase/functions-client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3C,OAAO,EAEL,kBAAkB,EAClB,cAAc,EACd,eAAe,EAEhB,MAAM,8BAA8B,CAAC;AAUtC;;;;GAIG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,WAAW,EAChB,iBAAiB,eAAe,SAajC,CAAC;AAgGF,eAAO,MAAM,YAAY,GACvB,KAAK,kBAAkB,EACvB,eAAe,GAAG,KACjB,OAAO,CAAC,cAAc,CAA6C,CAAC"}

package/dist/service-provider/firebase/functions-client.js

@@ -0,0 +1,63 @@
+import { msg } from '@lit/localize';
+import { getFunctions, httpsCallable } from 'firebase/functions';
+import { SC_INVALID_USER, BusinessError } from '../service-provider-model.js';
+import { pdStore } from '../../store/mini-rx.store.js';
+import { toastAction } from '../../store/spa-app-actions.js';
+import { createLogger } from '../../helper/logger.js';
+
+const functionLogger = createLogger("PdFunctions");
+const functionMap = /* @__PURE__ */ new Map();
+const initFunctions = (app, functionsConfig) => {
+  try {
+    const functions = getFunctions(app, functionsConfig.region);
+    functionsConfig.functions.forEach((func) => {
+      functionMap.set(func, httpsCallable(functions, func.name));
+    });
+  } catch (error) {
+    functionLogger.error("error during function result", error);
+  }
+};
+const internalCallFunction = async (def, functionInput) => {
+  const funcRef = functionMap.get(def);
+  if (!funcRef) {
+    functionLogger.error("No function available for ", def.name);
+    throw new Error("Illegal state, no function available");
+  }
+  try {
+    const funcResult = await funcRef(functionInput);
+    if (!funcResult || !funcResult.data) {
+      throw new Error("Illegal state, no valid response received");
+    }
+    const { statusCode, resultData } = funcResult.data;
+    if (def.successCodes.includes(statusCode)) {
+      return funcResult.data;
+    }
+    if (statusCode === SC_INVALID_USER) {
+      handleInvalidUser();
+      throw new BusinessError("Unauthorized access", statusCode);
+    }
+    if (statusCode && resultData) {
+      throw new BusinessError(resultData, statusCode);
+    }
+    throw new Error(`Unexpected error: ${statusCode} - ${resultData}`);
+  } catch (error) {
+    functionLogger.error("Error in internalCallFunction:", error);
+    throw error;
+  }
+};
+const handleInvalidUser = () => {
+  pdStore().dispatch(
+    toastAction({
+      txt: msg(
+        "Sie haben nicht die erforderlichen Berechtigungen, um diese Aktion auszuführen. Wenden Sie sich an Ihren Administrator.",
+        { id: "spaH.toast.error.user.invalid" }
+      ),
+      isError: true,
+      isSuccess: false,
+      duration: -1
+    })
+  );
+};
+const callFunction = async (def, functionInput) => internalCallFunction(def, functionInput);
+
+export { callFunction, initFunctions };

package/dist/service-provider/firebase/messagingFirebaseClient.d.ts

@@ -0,0 +1,9 @@
+import { FirebaseApp } from 'firebase/app';
+import { Messaging } from 'firebase/messaging';
+import { MessagingConfig } from '../service-provider-model.js';
+export declare const NOTIFICATION_TOKEN = "pd.spa.helper.notification.token";
+export declare function prepareMessaging(app: FirebaseApp, messageConfig: MessagingConfig): void;
+export declare const activateTokenChangeHandler: (appName: string) => void;
+export declare const registerDevice: (registration: ServiceWorkerRegistration) => Promise<void>;
+export declare const getFirebaseMessaging: () => Messaging;
+//# sourceMappingURL=messagingFirebaseClient.d.ts.map

package/dist/service-provider/firebase/messagingFirebaseClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messagingFirebaseClient.d.ts","sourceRoot":"","sources":["../../../src/service-provider/firebase/messagingFirebaseClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAA0B,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAQ/D,eAAO,MAAM,kBAAkB,qCAAqC,CAAC;AAOrE,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,aAAa,EAAE,eAAe,QAI/B;AAED,eAAO,MAAM,0BAA0B,GAAI,SAAS,MAAM,SAczD,CAAC;AA8BF,eAAO,MAAM,cAAc,GACzB,cAAc,yBAAyB,kBAoBxC,CAAC;AAEF,eAAO,MAAM,oBAAoB,iBAAkB,CAAC"}

package/dist/service-provider/firebase/messagingFirebaseClient.js

@@ -0,0 +1,69 @@
+import { getMessaging, getToken } from 'firebase/messaging';
+import { update, USER_COLLECTION } from '../../store/indexDB.js';
+import { pdStore } from '../../store/mini-rx.store.js';
+import { updateNewNotificationToken } from '../../store/spa-app-actions.js';
+import { authIdTokenStateChanged } from './auth.js';
+import { createLogger } from '../../helper/logger.js';
+
+const NOTIFICATION_TOKEN = "pd.spa.helper.notification.token";
+const messagingLogger = createLogger("PdMessaging");
+let messaging;
+let firebaseMessagingAppConfigKey;
+function prepareMessaging(app, messageConfig) {
+  messaging = getMessaging(app);
+  firebaseMessagingAppConfigKey = messageConfig;
+}
+const activateTokenChangeHandler = (appName) => {
+  authIdTokenStateChanged(async (user) => {
+    if (user) {
+      const token = await user.getIdToken();
+      if (token) {
+        await update(USER_COLLECTION, {
+          id: appName,
+          userNameToken: user.displayName,
+          userIdToken: token
+        });
+        messagingLogger.info("UserToken stored in local db");
+      }
+    }
+  });
+};
+const initMessageToken = async (registration) => {
+  if (!messaging || !firebaseMessagingAppConfigKey || !registration) {
+    throw new Error("Messaging, Registration or Key not available");
+  }
+  const currentToken = await getToken(messaging, {
+    vapidKey: firebaseMessagingAppConfigKey.apidKey,
+    serviceWorkerRegistration: registration
+  });
+  if (currentToken) {
+    const storedToken = localStorage.getItem(NOTIFICATION_TOKEN);
+    if (storedToken !== currentToken) {
+      messagingLogger.info("Update new token in Backend");
+      pdStore().dispatch(
+        updateNewNotificationToken({
+          messagingToken: currentToken
+        })
+      );
+    } else {
+      messagingLogger.info("RegisterDevice: Stored token is valid");
+    }
+  } else {
+    messagingLogger.warn("No token received - no new token was generated.");
+  }
+};
+const registerDevice = async (registration) => {
+  messagingLogger.info("Start registering app for messages and notifications");
+  if (Notification.permission === "default") {
+    await Notification.requestPermission();
+  }
+  if (Notification.permission === "granted") {
+    await initMessageToken(registration);
+  }
+  if (Notification.permission === "denied") {
+    messagingLogger.warn("Messaging not possible, missing rights");
+  }
+};
+const getFirebaseMessaging = () => messaging;
+
+export { NOTIFICATION_TOKEN, activateTokenChangeHandler, getFirebaseMessaging, prepareMessaging, registerDevice };

package/dist/service-provider/mock/auth.d.ts

@@ -0,0 +1,6 @@
+export declare const logoutMock: () => Promise<boolean>;
+export declare const isAuthenticatedMock: () => boolean;
+export declare const getAuthUserMock: () => unknown;
+export declare const authStateChangedMock: (callback: (user: any) => void) => void;
+export declare const loginMock: (user: string, sec: string) => Promise<unknown>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/service-provider/mock/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/service-provider/mock/auth.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,UAAU,QAAa,OAAO,CAAC,OAAO,CAOlD,CAAC;AAEF,eAAO,MAAM,mBAAmB,QAAO,OAMtC,CAAC;AAEF,eAAO,MAAM,eAAe,QAAO,OAMpB,CAAC;AAGhB,eAAO,MAAM,oBAAoB,GAAI,UAAU,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,SAMjE,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,MAAM,MAAM,EACZ,KAAK,MAAM,KACV,OAAO,CAAC,OAAO,CA2BjB,CAAC"}

package/dist/service-provider/mock/auth.js

@@ -0,0 +1,60 @@
+const LOCALSTORE_ITEM_KEY = "pdUserLogin";
+const HARDCODED_USER = "mock@pd-spa-helper.com";
+const HARDCODED_PWD = "mock";
+let loginAvailable;
+const checkLocalStore = () => {
+  const userItem = localStorage.getItem(LOCALSTORE_ITEM_KEY);
+  return userItem === "true";
+};
+const logoutMock = async () => {
+  console.log("Do MOCK logout");
+  loginAvailable = void 0;
+  {
+    localStorage.removeItem(LOCALSTORE_ITEM_KEY);
+  }
+  return Promise.resolve(true);
+};
+const isAuthenticatedMock = () => {
+  if (loginAvailable === void 0) {
+    console.log("MOCK: check authentication");
+    loginAvailable = checkLocalStore() ;
+  }
+  return loginAvailable;
+};
+const getAuthUserMock = () => isAuthenticatedMock() ? {
+  uid: "34234234",
+  displayName: "userMockName"
+} : void 0;
+let callbackLogin;
+const authStateChangedMock = (callback) => {
+  callbackLogin = callback;
+  console.log("Not implemented for MOCK, do call once if authenticated");
+  if (isAuthenticatedMock()) {
+    callbackLogin(getAuthUserMock());
+  }
+};
+const loginMock = async (user, sec) => {
+  console.log("MOCK: do authentication for user: ", user);
+  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  let valid = false;
+  if (user === HARDCODED_USER && sec === HARDCODED_PWD) {
+    {
+      localStorage.setItem(LOCALSTORE_ITEM_KEY, "true");
+    }
+    valid = true;
+    loginAvailable = true;
+  }
+  if (valid) {
+    const userMock = getAuthUserMock();
+    if (callbackLogin) {
+      callbackLogin(userMock);
+    }
+    return user;
+  }
+  const err = new Error("Invalid login");
+  const error = err;
+  error.code = "auth/wrong-password";
+  throw error;
+};
+
+export { authStateChangedMock, getAuthUserMock, isAuthenticatedMock, loginMock, logoutMock };

package/dist/service-provider/mock/function-client.d.ts

@@ -0,0 +1,7 @@
+import { FunctionDefinition, FunctionResult } from '../service-provider-model.js';
+export declare const callFunctionMock: (def: FunctionDefinition, functionInput: any) => Promise<FunctionResult>;
+export declare const initMockResponse: (mock?: {
+    mockResponse?: Map<string, (functionInput: any) => FunctionResult>;
+    mockWaitTime?: number;
+}) => void;
+//# sourceMappingURL=function-client.d.ts.map

package/dist/service-provider/mock/function-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-client.d.ts","sourceRoot":"","sources":["../../../src/service-provider/mock/function-client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,cAAc,EACf,MAAM,8BAA8B,CAAC;AAOtC,eAAO,MAAM,gBAAgB,GAC3B,KAAK,kBAAkB,EACvB,eAAe,GAAG,KACjB,OAAO,CAAC,cAAc,CAwBxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO;IACtC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,aAAa,EAAE,GAAG,KAAK,cAAc,CAAC,CAAC;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,SAGA,CAAC"}

package/dist/service-provider/mock/function-client.js

@@ -0,0 +1,30 @@
+const DEFAULT_TIMEOUT = 2e3;
+let mockResponse;
+let mockTimeout = DEFAULT_TIMEOUT;
+const callFunctionMock = async (def, functionInput) => {
+  let key;
+  if (functionInput?.detailsId) {
+    key = `${def.name}_${functionInput?.object}_detailsId`;
+  } else if (functionInput?.type) {
+    key = `${def.name}_${functionInput.object}_${functionInput.type}`;
+  } else {
+    key = `${def.name}_${functionInput?.object}`;
+  }
+  console.log("Mock function call", def, functionInput, key);
+  const timeout = () => new Promise((resolve) => {
+    window.setTimeout(() => {
+      resolve("Done");
+    }, mockTimeout);
+  });
+  await timeout();
+  if (mockResponse && mockResponse.has(key)) {
+    return Promise.resolve(mockResponse.get(key)(functionInput));
+  }
+  throw new Error("No data with right state available");
+};
+const initMockResponse = (mock) => {
+  mockResponse = mock?.mockResponse || /* @__PURE__ */ new Map();
+  mockTimeout = mock?.mockWaitTime || DEFAULT_TIMEOUT;
+};
+
+export { callFunctionMock, initMockResponse };

package/dist/service-provider/mock/storage-client.d.ts

@@ -0,0 +1,11 @@
+import { FileStorageConfig, StorageDocument, UploadFile } from '../service-provider-model.js';
+/**
+ * During start/load application, initialize functions.
+ *
+ * @param {*} app - initialized app.
+ */
+export declare const initStorageMock: (defaultStorage?: string, storageConfig?: FileStorageConfig) => void;
+export declare const uploadStorageFileMock: (file: UploadFile) => Promise<any>;
+export declare const downloadFileMock: (file: StorageDocument) => Promise<string>;
+export declare const getMockFileList: (storageName: string, refKey: string, subFolder?: string, includeMetadata?: boolean) => Promise<StorageDocument[]>;
+//# sourceMappingURL=storage-client.d.ts.map

package/dist/service-provider/mock/storage-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-client.d.ts","sourceRoot":"","sources":["../../../src/service-provider/mock/storage-client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,UAAU,EACX,MAAM,8BAA8B,CAAC;AAmDtC;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,iBAAiB,MAAM,EACvB,gBAAgB,iBAAiB,SAiClC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,MAAM,UAAU,KAAG,OAAO,CAAC,GAAG,CA8BnE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,eAAe,oBAGrD,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,aAAa,MAAM,EACnB,QAAQ,MAAM,EACd,YAAY,MAAM,EAClB,kBAAkB,OAAO,KACxB,OAAO,CAAC,eAAe,EAAE,CAiB3B,CAAC"}