@olenbetong/appframe-core 1.3.7 → 2.0.0

package/dist/iife/af.common.js

@@ -26,18 +26,12 @@ var af;
     UserSession: () => UserSession,
     downloadBlob: () => downloadBlob,
     downloadRequest: () => downloadRequest,
-    exportOptionsFromDataObject: () => exportOptionsFromDataObject,
     expose: () => expose,
-    formDataToDataObjectRecord: () => formDataToDataObjectRecord,
-    formDataToObject: () => formDataToObject,
-    formDataToProcedureParameters: () => formDataToProcedureParameters,
-    getDataObjectReportRequest: () => getDataObjectReportRequest,
     getLocalizedString: () => getLocalizedString,
     getSettings: () => getSettings,
     has: () => has,
     localStorage: () => localStorage_default,
     mitt: () => mitt_default,
-    openDataObjectReport: () => openDataObjectReport,
     saveSettings: () => saveSettings,
     version: () => version
   });
@@ -83,223 +77,6 @@ var af;
     } };
   }
 
-  // src/downloadBlob.ts
-  function downloadBlob(blob, fileName) {
-    return new Promise(function(resolve, reject) {
-      try {
-        const url = URL.createObjectURL(blob);
-        const parent = document.body;
-        const anchor = document.createElement("a");
-        anchor.setAttribute("download", fileName);
-        anchor.href = url;
-        parent.append(anchor);
-        anchor.click();
-        parent.removeChild(anchor);
-        setTimeout(function() {
-          URL.revokeObjectURL(url);
-          resolve();
-        }, 250);
-      } catch (ex) {
-        reject(ex);
-      }
-    });
-  }
-
-  // src/downloadRequest.ts
-  async function downloadRequest(request, { fileName, signal, onProgress }) {
-    function reportProgress(progress) {
-      if (typeof onProgress === "function") {
-        onProgress({ ...progress });
-      }
-    }
-    let bytesReceived = 0;
-    reportProgress({ status: "requested" });
-    try {
-      let response = await fetch(request);
-      if (!response.ok || !response.body) {
-        if (response.headers.get("content-type")?.includes("application/json")) {
-          let data = await response.json();
-          if (data.error) {
-            throw new Error(data.error);
-          }
-        }
-        throw new Error(`${response.status} ${response.statusText}`);
-      }
-      try {
-        const reader = response.body.getReader();
-        const stream = new ReadableStream({
-          start: function(controller) {
-            function pump() {
-              return reader.read().then(function(read) {
-                if (read.done) {
-                  controller.close();
-                  return;
-                }
-                bytesReceived += read.value.length;
-                reportProgress({ bytesReceived, status: "downloading" });
-                controller.enqueue(read.value);
-                return pump();
-              });
-            }
-            return pump();
-          }
-        });
-        response = new Response(stream);
-      } catch (error) {
-        console.warn("Failed to replace response stream to log download progress.");
-      }
-      const blob = await response.blob();
-      reportProgress({ bytesReceived, status: "downloaded" });
-      await downloadBlob(blob, fileName);
-      reportProgress({ bytesReceived, status: "completed" });
-    } catch (err) {
-      if (signal?.aborted) {
-        reportProgress({ status: "cancelled" });
-      } else {
-        reportProgress({ error: err.message, status: "error" });
-      }
-    }
-  }
-
-  // src/exportDataObject.ts
-  function exportOptionsFromDataObject(dataObject, specifiedOptions) {
-    return {
-      columns: dataObject.getFields().map((field) => ({ name: field.name })),
-      distinctRows: dataObject.getParameter("distinctRows"),
-      filterObject: dataObject.getParameter("filterObject"),
-      filterString: dataObject.getParameter("filterString"),
-      maxRecords: dataObject.getParameter("maxRecords"),
-      sortOrder: dataObject.getParameter("sortOrder"),
-      whereClause: dataObject.getParameter("whereClause"),
-      whereObject: dataObject.getParameter("whereObject"),
-      ...specifiedOptions
-    };
-  }
-  var defaultOptions = {
-    columns: [],
-    distinctRows: false,
-    filterObject: null,
-    filterString: "",
-    maxRecords: -1,
-    sortOrder: [],
-    whereClause: "",
-    whereObject: null
-  };
-  function getDataObjectReportRequest(params) {
-    const { articleId, dataObject, format, options } = params;
-    const reportOptions = options ? Object.assign({}, defaultOptions, options) : defaultOptions;
-    const body = "data=" + encodeURIComponent(JSON.stringify(reportOptions));
-    const requestUrl = `/api/data-object/export/${articleId}/${dataObject}/${format}`;
-    const controller = params.controller ?? new AbortController();
-    return {
-      controller,
-      request: new Request(requestUrl, {
-        body,
-        credentials: "same-origin",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        method: "POST",
-        signal: controller.signal
-      })
-    };
-  }
-  function openDataObjectReport(params) {
-    const { dataObject, fileName, format } = params;
-    const { request } = getDataObjectReportRequest(params);
-    return downloadRequest(request, {
-      fileName: `${fileName || dataObject}.${format}`
-    });
-  }
-
-  // src/has.ts
-  function has(obj, key2) {
-    return Object.prototype.hasOwnProperty.call(obj, key2);
-  }
-
-  // src/parseFunc.ts
-  var funcRegex = /^function(?:\s+([a-zA-Z$_][a-zA-Z0-9$_]*))?\s*\(((?:(?:\s*[a-zA-Z$_][a-zA-Z0-9$_]*)(?:\s*,\s*[a-zA-Z$_][a-zA-Z0-9$_]*)*)?)\s*\)\s*\{((?:.|\n|\r)*)\}$/;
-  function parseFunc(func) {
-    var match = func.toString().match(funcRegex);
-    if (match === null) {
-      throw new TypeError("Unable to parse function!");
-    }
-    return { name: match[1], args: match[2].split(","), body: match[3] };
-  }
-
-  // src/Namespace.ts
-  function Namespace() {
-  }
-  Namespace.prototype = /* @__PURE__ */ Object.create(null);
-  var Namespace_default = Namespace;
-
-  // src/requireNamespace.ts
-  function requireNamespace(root, namespace) {
-    if (typeof root === "object") {
-      if (typeof namespace === "string") {
-        let path = namespace.split(".");
-        return requireNamespace(root, path);
-      } else if (Array.isArray(namespace)) {
-        let current = root;
-        for (let i = 0; i < namespace.length; i++) {
-          current = current[namespace[i]] = current[namespace[i]] || new Namespace_default();
-        }
-        return current;
-      } else {
-        throw new TypeError("Invalid type of parameter 'namespace'");
-      }
-    } else {
-      throw new TypeError("Invalid type of parameter 'root'");
-    }
-  }
-
-  // src/warn.ts
-  function warn(message, fallbackToAlert) {
-    console.warn(message);
-  }
-
-  // src/expose.ts
-  function expose(name, value) {
-    if (arguments.length !== 2) {
-      throw new Error("Incorrect number of arguments passed to the expose function!");
-    }
-    if (Array.isArray(value)) {
-      for (let func of value) {
-        const { name: funcName } = parseFunc(func);
-        if (funcName) {
-          expose(name, func);
-        } else {
-          throw new Error(
-            "Unable to detect name of function! Name it, or only supply one function and include name in first parameter."
-          );
-        }
-      }
-    } else {
-      let keyName;
-      let namespace;
-      if (typeof value === "function") {
-        keyName = parseFunc(value).name;
-      }
-      if (typeof name === "string") {
-        let pathParts = name.split(".");
-        if (!keyName) {
-          keyName = pathParts[pathParts.length - 1];
-          pathParts = pathParts.slice(0, pathParts.length - 1);
-        }
-        namespace = requireNamespace(window, pathParts);
-      } else if (keyName && (typeof name === "object" || typeof name === "function")) {
-        namespace = name;
-      } else {
-        throw new TypeError("Invalid typeof parameter 'name', or unable to parse pValue!");
-      }
-      if (has(namespace, keyName)) {
-        warn([name, keyName].join(".") + " is already defined!");
-      } else {
-        namespace[keyName] = value;
-      }
-    }
-  }
-
   // src/getLocalizedString.ts
   async function getLocalizedStringAsync(string) {
     try {
@@ -421,48 +198,6 @@ return s;
     return localized;
   }
 
-  // src/localStorage.ts
-  function getLocalKey(key2) {
-    return [af?.article?.id || "", "common", key2].join(".");
-  }
-  var LocalStorage = class {
-    isPersisted() {
-      return true;
-    }
-    getLocalStorageKey(key2, global) {
-      return global ? ["common", key2].join(".") : getLocalKey(key2);
-    }
-    get(key2, defaultValue, global) {
-      const lsKey = this.getLocalStorageKey(key2, global);
-      const value = localStorage.getItem(lsKey);
-      return value !== null ? JSON.parse(value) : defaultValue;
-    }
-    set(key2, value, global) {
-      localStorage.setItem(
-        this.getLocalStorageKey(key2, global),
-        JSON.stringify(value)
-      );
-    }
-    remove(key2, global) {
-      const lsKey = this.getLocalStorageKey(key2, global);
-      if (localStorage.getItem(lsKey) !== null) {
-        localStorage.removeItem(lsKey);
-        return true;
-      } else {
-        return false;
-      }
-    }
-    clear() {
-      const baseKey = getLocalKey("");
-      for (let key2 in localStorage) {
-        if (key2.slice(0, baseKey.length) === baseKey) {
-          localStorage.removeItem(key2);
-        }
-      }
-    }
-  };
-  var localStorage_default = new LocalStorage();
-
   // src/SessionHandler.ts
   var _SessionHandler = class {
     constructor() {
@@ -612,61 +347,226 @@ return s;
     constructor(userData) {
       super();
       this.decimalSeparator = ".";
+      this.domain = "OB";
       this.groupSeparator = null;
       this.shortDateFormat = "dd.MM.yyyy";
-      this.login = null;
+      this.login = "";
       this.isDeveloper = false;
+      this.culture = "en-GB";
+      this.uiculture = "en-GB";
+      this.expired = () => null;
       this.formats = {};
       Object.assign(this, userData);
     }
   };
 
-  // src/formDataToObject.ts
-  function getFormValue(value, type) {
-    if (value === "") {
-      return null;
-    } else if (type === "number") {
-      let numValue = Number(value.replaceAll(",", ".").replaceAll(/\s+/g, ""));
-      return isNaN(numValue) ? void 0 : numValue;
-    } else if (["date", "datetime", "time"].includes(type)) {
-      let dateValue = new Date(value);
-      return isNaN(dateValue.getTime()) ? void 0 : dateValue;
-    } else if (type === "boolean") {
-      return value.toLowerCase() === "true";
-    } else if (type === "bigint") {
-      return BigInt(value);
+  // src/downloadBlob.ts
+  function downloadBlob(blob, fileName) {
+    return new Promise(function(resolve, reject) {
+      try {
+        const url = URL.createObjectURL(blob);
+        const parent = document.body;
+        const anchor = document.createElement("a");
+        anchor.setAttribute("download", fileName);
+        anchor.href = url;
+        parent.append(anchor);
+        anchor.click();
+        parent.removeChild(anchor);
+        setTimeout(function() {
+          URL.revokeObjectURL(url);
+          resolve();
+        }, 250);
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  }
+
+  // src/downloadRequest.ts
+  async function downloadRequest(request, { fileName, signal, onProgress }) {
+    function reportProgress(progress) {
+      if (typeof onProgress === "function") {
+        onProgress({ ...progress });
+      }
+    }
+    let bytesReceived = 0;
+    reportProgress({ status: "requested" });
+    try {
+      let response = await fetch(request);
+      if (!response.ok || !response.body) {
+        if (response.headers.get("content-type")?.includes("application/json")) {
+          let data = await response.json();
+          if (data.error) {
+            throw new Error(data.error);
+          }
+        }
+        throw new Error(`${response.status} ${response.statusText}`);
+      }
+      try {
+        const reader = response.body.getReader();
+        const stream = new ReadableStream({
+          start: function(controller) {
+            function pump() {
+              return reader.read().then(function(read) {
+                if (read.done) {
+                  controller.close();
+                  return;
+                }
+                bytesReceived += read.value.length;
+                reportProgress({ bytesReceived, status: "downloading" });
+                controller.enqueue(read.value);
+                return pump();
+              });
+            }
+            return pump();
+          }
+        });
+        response = new Response(stream);
+      } catch (error) {
+        console.warn("Failed to replace response stream to log download progress.");
+      }
+      const blob = await response.blob();
+      reportProgress({ bytesReceived, status: "downloaded" });
+      await downloadBlob(blob, fileName);
+      reportProgress({ bytesReceived, status: "completed" });
+    } catch (err) {
+      if (signal?.aborted) {
+        reportProgress({ status: "cancelled" });
+      } else {
+        reportProgress({ error: err.message, status: "error" });
+      }
     }
-    return value;
   }
-  function formDataToObject(form, typeMap = {}) {
-    let formData = new FormData(form);
-    let result = {};
-    for (let entry of formData.entries()) {
-      let field = entry[0];
-      let type = typeMap?.[field] ?? "string";
-      let value = getFormValue(entry[1], type);
-      if (result.hasOwnProperty(field)) {
-        if (Array.isArray(result[field])) {
-          result[field].push(value);
-        } else {
-          result[field] = [result[field], value];
+
+  // src/has.ts
+  function has(obj, key2) {
+    return Object.prototype.hasOwnProperty.call(obj, key2);
+  }
+
+  // src/parseFunc.ts
+  var funcRegex = /^function(?:\s+([a-zA-Z$_][a-zA-Z0-9$_]*))?\s*\(((?:(?:\s*[a-zA-Z$_][a-zA-Z0-9$_]*)(?:\s*,\s*[a-zA-Z$_][a-zA-Z0-9$_]*)*)?)\s*\)\s*\{((?:.|\n|\r)*)\}$/;
+  function parseFunc(func) {
+    var match = func.toString().match(funcRegex);
+    if (match === null) {
+      throw new TypeError("Unable to parse function!");
+    }
+    return { name: match[1], args: match[2].split(","), body: match[3] };
+  }
+
+  // src/Namespace.ts
+  function Namespace() {
+  }
+  Namespace.prototype = /* @__PURE__ */ Object.create(null);
+  var Namespace_default = Namespace;
+
+  // src/requireNamespace.ts
+  function requireNamespace(root, namespace) {
+    if (typeof root === "object") {
+      if (typeof namespace === "string") {
+        let path = namespace.split(".");
+        return requireNamespace(root, path);
+      } else if (Array.isArray(namespace)) {
+        let current = root;
+        for (let i = 0; i < namespace.length; i++) {
+          current = current[namespace[i]] = current[namespace[i]] || new Namespace_default();
         }
+        return current;
       } else {
-        result[field] = value;
+        throw new TypeError("Invalid type of parameter 'namespace'");
       }
+    } else {
+      throw new TypeError("Invalid type of parameter 'root'");
     }
-    return result;
   }
-  function formDataToDataObjectRecord(form, dataObject) {
-    let fields = dataObject.getFields();
-    let types = Object.fromEntries(fields.map((field) => [field.name, field.type]));
-    return formDataToObject(form, types);
+
+  // src/warn.ts
+  function warn(message, fallbackToAlert) {
+    console.warn(message);
+  }
+
+  // src/expose.ts
+  function expose(name, value) {
+    if (arguments.length !== 2) {
+      throw new Error("Incorrect number of arguments passed to the expose function!");
+    }
+    if (Array.isArray(value)) {
+      for (let func of value) {
+        const { name: funcName } = parseFunc(func);
+        if (funcName) {
+          expose(name, func);
+        } else {
+          throw new Error(
+            "Unable to detect name of function! Name it, or only supply one function and include name in first parameter."
+          );
+        }
+      }
+    } else {
+      let keyName;
+      let namespace;
+      if (typeof value === "function") {
+        keyName = parseFunc(value).name;
+      }
+      if (typeof name === "string") {
+        let pathParts = name.split(".");
+        if (!keyName) {
+          keyName = pathParts[pathParts.length - 1];
+          pathParts = pathParts.slice(0, pathParts.length - 1);
+        }
+        namespace = requireNamespace(window, pathParts);
+      } else if (keyName && (typeof name === "object" || typeof name === "function")) {
+        namespace = name;
+      } else {
+        throw new TypeError("Invalid typeof parameter 'name', or unable to parse pValue!");
+      }
+      if (has(namespace, keyName)) {
+        warn([name, keyName].join(".") + " is already defined!");
+      } else {
+        namespace[keyName] = value;
+      }
+    }
   }
-  function formDataToProcedureParameters(form, procedure) {
-    let parameters = procedure.getParameters();
-    let types = Object.fromEntries(parameters.map((param) => [param.name, param.type]));
-    return formDataToObject(form, types);
+
+  // src/localStorage.ts
+  function getLocalKey(key2) {
+    return [af?.article?.id || "", "common", key2].join(".");
   }
+  var LocalStorage = class {
+    isPersisted() {
+      return true;
+    }
+    getLocalStorageKey(key2, global) {
+      return global ? ["common", key2].join(".") : getLocalKey(key2);
+    }
+    get(key2, defaultValue, global) {
+      const lsKey = this.getLocalStorageKey(key2, global);
+      const value = localStorage.getItem(lsKey);
+      return value !== null ? JSON.parse(value) : defaultValue;
+    }
+    set(key2, value, global) {
+      localStorage.setItem(
+        this.getLocalStorageKey(key2, global),
+        JSON.stringify(value)
+      );
+    }
+    remove(key2, global) {
+      const lsKey = this.getLocalStorageKey(key2, global);
+      if (localStorage.getItem(lsKey) !== null) {
+        localStorage.removeItem(lsKey);
+        return true;
+      } else {
+        return false;
+      }
+    }
+    clear() {
+      const baseKey = getLocalKey("");
+      for (let key2 in localStorage) {
+        if (key2.slice(0, baseKey.length) === baseKey) {
+          localStorage.removeItem(key2);
+        }
+      }
+    }
+  };
+  var localStorage_default = new LocalStorage();
 
   // src/settings.ts
   function getKey(article) {
@@ -697,6 +597,6 @@ return s;
   }
 
   // src/index.ts
-  var version = "1.3.7";
+  var version = "2.0.0";
   return __toCommonJS(src_exports);
 })();