@olenbetong/appframe-core 1.3.7 → 2.0.0

package/dist/esm/af.common.js

@@ -39,223 +39,6 @@ function mitt_default(n) {
   } };
 }
 
-// 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 {
@@ -377,48 +160,6 @@ function getLocalizedString(string) {
   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() {
@@ -568,61 +309,226 @@ var UserSession = class extends SessionHandler {
   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) {
@@ -653,24 +559,18 @@ function saveSettings(setting, value, article) {
 }
 
 // src/index.ts
-var version = "1.3.7";
+var version = "2.0.0";
 export {
   SessionHandler,
   UserSession,
   downloadBlob,
   downloadRequest,
-  exportOptionsFromDataObject,
   expose,
-  formDataToDataObjectRecord,
-  formDataToObject,
-  formDataToProcedureParameters,
-  getDataObjectReportRequest,
   getLocalizedString,
   getSettings,
   has,
   localStorage_default as localStorage,
   mitt_default as mitt,
-  openDataObjectReport,
   saveSettings,
   version
 };