@olenbetong/appframe-core 1.3.1 → 1.3.4

package/dist/esm/af.common.legacy.js

@@ -0,0 +1,698 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/errorHandler.ts
+window.addEventListener("error", (event) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  try {
+    const data = {
+      error: (_c = (_b = (_a = event.error) == null ? void 0 : _a.message) != null ? _b : event.message) != null ? _c : null,
+      file: event.filename,
+      line: (_d = event.lineno) != null ? _d : 0,
+      column: (_e = event.colno) != null ? _e : 0,
+      stack: (_g = (_f = event.error) == null ? void 0 : _f.stack) != null ? _g : null
+    };
+    fetch("/data/Logger/LogError", {
+      body: JSON.stringify(data),
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json; charset=utf-8",
+        "X-Requested-With": "XMLHttpRequest"
+      },
+      method: "POST"
+    });
+  } catch (ex) {
+  }
+});
+
+// ../../node_modules/mitt/dist/mitt.mjs
+function mitt_default(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+
+// 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 }) {
+  var _a;
+  function reportProgress(progress) {
+    if (typeof onProgress === "function") {
+      onProgress(__spreadValues({}, progress));
+    }
+  }
+  let bytesReceived = 0;
+  reportProgress({ status: "requested" });
+  try {
+    let response = await fetch(request);
+    if (!response.ok || !response.body) {
+      if ((_a = response.headers.get("content-type")) == null ? void 0 : _a.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 == null ? void 0 : signal.aborted) {
+      reportProgress({ status: "cancelled" });
+    } else {
+      reportProgress({ error: err.message, status: "error" });
+    }
+  }
+}
+
+// src/exportDataObject.ts
+function exportOptionsFromDataObject(dataObject, specifiedOptions) {
+  return __spreadValues({
+    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) {
+  var _a;
+  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 = (_a = params.controller) != null ? _a : 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 {
+    let response = await fetch("/api/user/localize", {
+      body: JSON.stringify({ string }),
+      headers: {
+        Accept: "application/json; */*",
+        "Content-Type": "application/json",
+        "X-Requested-With": "XMLHttpRequest"
+      },
+      method: "POST"
+    });
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch (error) {
+  }
+  return string;
+}
+function afGetLocalizedString(string, wait) {
+  var _a;
+  if (((_a = af == null ? void 0 : af.article) == null ? void 0 : _a.i18n) !== void 0) {
+    if (!Object.prototype.hasOwnProperty.call(af.article.i18n, string)) {
+      af.article.i18n[string] = string;
+      let promise = getLocalizedStringAsync(string).then((text) => {
+        af.article.i18n[string] = text;
+        return text;
+      });
+      if (wait) {
+        return promise;
+      }
+    }
+    return af.article.i18n[string];
+  } else {
+    return string;
+  }
+}
+var key = "__UNLOCALIZED_STRINGS__";
+var localizeSet = window[key] || /* @__PURE__ */ new Set();
+if (!window[key]) {
+  window[key] = localizeSet;
+}
+function handleReadyStateChange() {
+  if (document.readyState !== "loading") {
+    addDeveloperUtils();
+    document.removeEventListener("readystatechange", handleReadyStateChange);
+  }
+}
+if (document.readyState !== "loading") {
+  addDeveloperUtils();
+} else {
+  document.addEventListener("readystatechange", handleReadyStateChange);
+}
+function isDeveloper() {
+  const { af: af2 } = window;
+  return af2 && af2.userSession && af2.userSession.isDeveloper;
+}
+function addDeveloperUtils() {
+  if (isDeveloper()) {
+    if (typeof window.__doNothingWithStrings === "function") {
+      const addedStrings = window.__doNothingWithStrings();
+      for (let string of Object.keys(addedStrings)) {
+        localizeSet.add(string);
+      }
+    }
+    if (!window[key]) {
+      window[key] = localizeSet;
+    }
+    if (!window.__getUnlocalizedStrings) {
+      window.__getUnlocalizedStrings = function(forCustomRoute) {
+        const strings = [];
+        for (let string of localizeSet) {
+          if (string) {
+            const escaped = string.replace(/'/g, "\\'");
+            if (forCustomRoute) {
+              const localized = afGetLocalizedString(string).replaceAll(
+                /'/g,
+                "\\'"
+              );
+              strings.push(`'${escaped}': '${localized}',`);
+            } else {
+              strings.push(
+                `s['${escaped}'] = @Html(@context.AddLocalizableString("${string.replaceAll(
+                  '"',
+                  '\\"'
+                )}"));`
+              );
+            }
+          }
+        }
+        if (forCustomRoute) {
+          return `// Localization hack, since it AddLocalizableString doesn't work properly when custom routes is used
+if (af.userSession.uiculture === 'nb-NO') {
+	const strings = {
+		${strings.join("\n		")}
+	};
+	af.article.i18n = af.article.i18n || {};
+	Object.assign(af.article.i18n, strings);
+}`;
+        }
+        return `<script type="text/javascript">
+function __doNothingWithStrings() {
+@{
+	var context = @Appframe.Web.Context.RequestContext.Current;
+}
+let s = {};
+${strings.join("\n")}
+return s;
+}
+<\/script>`;
+      };
+    }
+  }
+}
+function getLocalizedString(string) {
+  const localized = afGetLocalizedString(string);
+  if (localized === string && !localizeSet.has(string)) {
+    localizeSet.add(string);
+  }
+  return localized;
+}
+
+// src/localStorage.ts
+function getLocalKey(key2) {
+  var _a;
+  return [((_a = af == null ? void 0 : af.article) == null ? void 0 : _a.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() {
+    this.eventHandler = mitt_default();
+    this.showingDialog = false;
+    this.dialog = null;
+  }
+  expired(callback) {
+    af.userSession = af.userSession || {
+      login: null
+    };
+    if (typeof callback !== "function") {
+      throw new TypeError("Parameter pCallback passed to the expired function must be a function!");
+    }
+    const once = () => {
+      this.detachEvent("onAuthenticated", once);
+      callback();
+    };
+    this.attachEvent("onAuthenticated", once);
+    if (this.showingDialog !== true) {
+      this.showingDialog = true;
+      const contentContainer = document.createElement("div");
+      contentContainer.className = "session-expired-container";
+      contentContainer.innerHTML = `
+<div class="session-expired-log-in" style="margin-top: 20px;">
+  <div class="row">
+    <div class="sessionExpired">
+      <h4 class="message">Frakoblet - tidsavbrudd</h4>
+      <div class="form-group">
+        <label for="username">${getLocalizedString("Username")}</label>
+        <input type="text" class="form-control" id="username" autofocus>
+      </div>
+      <div class="form-group">
+        <label for="password">${getLocalizedString("Password")}</label>
+        <input type="password" autocomplete="password" class="form-control" id="password" >
+      </div>
+      <div class="form-group">
+        <div>
+          <button type="submit" class="btn btn-default sign-in">
+            ${getLocalizedString("Log in")}
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+  <div class="row">
+    <div class="" style="display:none; margin: 0px 30px;">
+      <div class="alert alert-warning" role="alert" style="margin-top:10px;"></div> 
+    </div>
+  </div>
+</div>
+`;
+      const message = af.userSession.login ? _SessionHandler.messages.relog : _SessionHandler.messages.login;
+      const messageElem = contentContainer.querySelector(".message");
+      const statusElem = contentContainer.querySelector(".alert-warning");
+      const userElem = contentContainer.querySelector("input[type=text]");
+      const signInElem = contentContainer.querySelector(".sign-in");
+      const passwordElem = contentContainer.querySelector("input[type=password]");
+      if (messageElem !== null && userElem !== null && statusElem !== null && userElem !== null && signInElem !== null && passwordElem !== null) {
+        messageElem.innerText = getLocalizedString(message);
+        userElem.value = af.userSession.login || "";
+        userElem.disabled = !!af.userSession.login;
+        userElem.readOnly = !!af.userSession.login;
+        document.body.appendChild(contentContainer);
+        const doLogin = async () => {
+          passwordElem.disabled = true;
+          const request = new Request("/login", {
+            body: JSON.stringify({
+              username: userElem.value,
+              password: passwordElem.value,
+              remember: false
+            }),
+            headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json; charset=utf-8",
+              "X-Requested-With": "XMLHttpRequest"
+            },
+            method: "POST"
+          });
+          try {
+            const response = await fetch(request);
+            const json = await response.json();
+            if (json.success) {
+              document.body.removeChild(contentContainer);
+              this.showingDialog = false;
+              this.eventHandler.emit("onAuthenticated");
+              if (statusElem.parentNode) {
+                statusElem.parentNode.style.display = "none";
+              }
+            } else {
+              throw new Error(json.error);
+            }
+          } catch (err) {
+            if (err && typeof err === "object") {
+              let error = err;
+              passwordElem.disabled = false;
+              passwordElem.classList.toggle("invalid", true);
+              passwordElem.value = "";
+              passwordElem.focus();
+              statusElem.innerText = error.message ? error.message : String(error);
+              if (statusElem.parentNode) {
+                statusElem.parentNode.style.display = "initial";
+              }
+            }
+          }
+        };
+        signInElem.addEventListener("click", doLogin);
+        passwordElem.addEventListener("keyup", (evt) => {
+          if (evt.key === "Enter") {
+            doLogin();
+          }
+        });
+        passwordElem.addEventListener("change", (evt) => {
+          if (evt.key === "Enter") {
+            doLogin();
+          }
+        });
+        userElem.addEventListener("keyup", (evt) => {
+          if (evt.key === "Enter") {
+            doLogin();
+          }
+        });
+        userElem.addEventListener("change", (evt) => {
+          if (evt.key === "Enter") {
+            doLogin();
+          }
+        });
+        passwordElem.focus();
+      }
+    }
+  }
+  attachEvent(eventName, handler) {
+    return this.eventHandler.on(eventName, handler);
+  }
+  detachEvent(eventName, handler) {
+    return this.eventHandler.off(eventName, handler);
+  }
+};
+var SessionHandler = _SessionHandler;
+SessionHandler.messages = {
+  login: "Log in",
+  relog: "Session expired - log in"
+};
+
+// src/UserSession.ts
+var UserSession = class extends SessionHandler {
+  constructor(userData) {
+    super();
+    this.decimalSeparator = ".";
+    this.groupSeparator = null;
+    this.shortDateFormat = "dd.MM.yyyy";
+    this.login = null;
+    this.isDeveloper = false;
+    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);
+    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);
+  }
+  return value;
+}
+function formDataToObject(form, typeMap = {}) {
+  var _a;
+  let formData = new FormData(form);
+  let result = {};
+  for (let entry of formData.entries()) {
+    let field = entry[0];
+    let type = (_a = typeMap == null ? void 0 : typeMap[field]) != null ? _a : "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];
+      }
+    } else {
+      result[field] = value;
+    }
+  }
+  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);
+}
+function formDataToProcedureParameters(form, procedure) {
+  let parameters = procedure.getParameters();
+  let types = Object.fromEntries(parameters.map((param) => [param.name, param.type]));
+  return formDataToObject(form, types);
+}
+
+// src/settings.ts
+function getKey(article) {
+  const articleKey = article || af.article.id;
+  return `${articleKey}.${af.userSession.login}`;
+}
+function getSettings(setting, article) {
+  if (!(af == null ? void 0 : af.userSession))
+    return null;
+  const key2 = getKey(article);
+  const settings = JSON.parse(localStorage.getItem(key2) || "{}");
+  if (setting) {
+    return settings[setting] || null;
+  }
+  return settings;
+}
+function saveSettings(setting, value, article) {
+  if (!(af == null ? void 0 : af.userSession))
+    return;
+  const key2 = getKey(article);
+  let userSettings = JSON.parse(localStorage.getItem(key2) || "{}");
+  if (typeof value !== "undefined") {
+    userSettings[setting] = value;
+  } else {
+    userSettings = setting;
+  }
+  localStorage.setItem(key2, JSON.stringify(userSettings));
+}
+
+// src/index.ts
+var version = "1.3.4";
+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
+};