@epxing/utils 0.0.0-stage → 5.3.0-beta.2

package/dist/src/date-helper.js

@@ -0,0 +1,60 @@
+function isDate(date) {
+  if (date === null || date === void 0) return false;
+  if (isNaN(new Date(date).getTime())) return false;
+  if (Array.isArray(date)) return false;
+  return true;
+}
+function getDayCountOfMonth(year, month) {
+  if (isNaN(+month)) return 31;
+  return new Date(year, +month + 1, 0).getDate();
+}
+function getDayCountOfYear(year) {
+  const isLeapYear = year % 400 === 0 || year % 100 !== 0 && year % 4 === 0;
+  return isLeapYear ? 366 : 365;
+}
+function nextDate(date, amount = 1) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + amount);
+}
+function changeYearMonthAndClampDate(date, year, month) {
+  const monthDate = Math.min(date.getDate(), getDayCountOfMonth(year, month));
+  return modifyDate(date, year, month, monthDate);
+}
+function nextMonth(date) {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  return month === 11 ? changeYearMonthAndClampDate(date, year + 1, 0) : changeYearMonthAndClampDate(date, year, month + 1);
+}
+function prevYear(date, amount = 1) {
+  return changeYearMonthAndClampDate(date, date.getFullYear() - amount, date.getMonth());
+}
+function nextYear(date, amount = 1) {
+  return changeYearMonthAndClampDate(date, date.getFullYear() + amount, date.getMonth());
+}
+function range(n) {
+  return Array.apply(null, { length: n }).map((_, i) => i);
+}
+function modifyDate(date, y, m, d) {
+  return new Date(y, m, d, date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+}
+function modifyTime(date, h, m, s) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), h, m, s, date.getMilliseconds());
+}
+function modifyWithTimeString(date, time) {
+  if (date == null || !time) return date;
+  const m = /^(\d{1,2}):(\d{1,2}):(\d{1,2})/.exec(String(time));
+  if (!m) return date;
+  return modifyTime(date, Number(m[1]), Number(m[2]), Number(m[3]));
+}
+export {
+  getDayCountOfMonth,
+  getDayCountOfYear,
+  isDate,
+  modifyDate,
+  modifyTime,
+  modifyWithTimeString,
+  nextDate,
+  nextMonth,
+  nextYear,
+  prevYear,
+  range
+};

package/dist/src/dom-helper.js

@@ -0,0 +1,22 @@
+function hasClass(el, cls) {
+  if (!el || !cls) return false;
+  if (cls.indexOf(" ") !== -1) throw new Error("className should not contain space.");
+  if (el.classList) return el.classList.contains(cls);
+  return (" " + el.className + " ").indexOf(" " + cls + " ") > -1;
+}
+function arrayFindIndex(arr, pred) {
+  for (let i = 0; i !== arr.length; ++i) {
+    if (pred(arr[i])) return i;
+  }
+  return -1;
+}
+function coerceTruthyValueToArray(val) {
+  if (Array.isArray(val)) return val;
+  if (val) return [val];
+  return [];
+}
+export {
+  arrayFindIndex,
+  coerceTruthyValueToArray,
+  hasClass
+};

package/dist/src/eval-with.js

@@ -0,0 +1,14 @@
+const cache = /* @__PURE__ */ new Map();
+function evalWith(expr, scope = {}, thisArg) {
+  const names = Object.keys(scope);
+  const key = names.join(",");
+  let fn = cache.get(key);
+  if (!fn) {
+    fn = new Function(...names, "__expr__", "return eval(__expr__)");
+    cache.set(key, fn);
+  }
+  return fn.call(thisArg, ...names.map((name) => scope[name]), expr);
+}
+export {
+  evalWith
+};

package/dist/src/fieldFactory.js

@@ -0,0 +1,5 @@
+export * from "@epxing/core/src/runtime-utils/fieldFactory";
+import { default as default2 } from "@epxing/core/src/runtime-utils/fieldFactory";
+export {
+  default2 as default
+};

package/dist/src/formula.js

@@ -0,0 +1,365 @@
+import { createMoment as momentCompat } from "./moment-compat.js";
+import { every, filter, find, get, map, nth, orderBy, set, size, some } from "lodash-es";
+const EQ = (v1, v2) => v1 === v2;
+const NE = (v1, v2) => v1 !== v2;
+const LT = (v1, v2, type) => {
+  if (type === "date") {
+    return momentCompat(v1).isBefore(v2);
+  } else {
+    return v1 < v2;
+  }
+};
+const LE = (v1, v2, type) => {
+  if (type === "date") {
+    return momentCompat(v1).isSameOrBefore(v2);
+  } else {
+    return v1 <= v2;
+  }
+};
+const GT = (v1, v2, type) => {
+  if (type === "date") {
+    return momentCompat(v1).isAfter(v2);
+  } else {
+    return v1 > v2;
+  }
+};
+const GE = (v1, v2, type) => {
+  if (type === "date") {
+    return momentCompat(v1).isSameOrAfter(v2);
+  } else {
+    return v1 >= v2;
+  }
+};
+const AND = (...logical) => {
+  return logical.every((item) => item);
+};
+const OR = (...logical) => {
+  return logical.some((item) => item);
+};
+const NOT = (logical) => {
+  return !logical;
+};
+const IN = (v1, ...v2) => {
+  if (v2.length === 0) return false;
+  if (v2.length > 1) {
+    return v2.includes(v1);
+  } else {
+    return v2[0].split(",").includes(v1);
+  }
+};
+const IN_TEXT = (v1, v2) => {
+  return v2.includes(v1);
+};
+const IF = (v1, v2, v3) => {
+  return v1 ? v2 : v3;
+};
+const ISEMPTY = (v1) => {
+  return v1 === "" || v1 === null || v1 === void 0;
+};
+const SUM = (v1, v2) => {
+  return v1 + v2;
+};
+const SUBTRACT = (v1, v2) => {
+  return v1 - v2;
+};
+const PRODUCT = (v1, v2) => {
+  return v1 * v2;
+};
+const DIVIDED = (v1, v2) => {
+  return v1 / v2;
+};
+const MOD = (v1, v2) => {
+  return v1 % v2;
+};
+const POW = (v1, v2) => {
+  return Math.pow(v1, v2);
+};
+const MAX = (...v1) => {
+  return Math.max(...v1);
+};
+const MIN = (...v1) => {
+  return Math.min(...v1);
+};
+const ABS = (v1) => {
+  return Math.abs(v1);
+};
+const FLOOR = (v1) => {
+  return Math.floor(v1);
+};
+const CEIL = (v1) => {
+  return Math.ceil(v1);
+};
+const ROUND = (v1) => {
+  return Math.round(v1);
+};
+const RANDOM = (v1, v2) => {
+  return Math.floor(Math.random() * (v2 - v1 + 1) + v1);
+};
+const AVERAGE = (...v1) => {
+  return v1.reduce((a, b) => a + b) / v1.length;
+};
+const DATE_SUBTRACT = (v1, v2, unit = "days") => {
+  return momentCompat(v1).subtract(v2, unit);
+};
+const DATE_ADD = (v1, v2, unit = "days") => {
+  return momentCompat(v1).add(v2, unit);
+};
+const DATE_FORMAT = (v1, format = "YYYY-MM-DD") => {
+  return momentCompat(v1).format(format);
+};
+const FORMAT_DATE = (v1, format = "YYYY-MM-DD") => {
+  return momentCompat(v1).format(format);
+};
+const DATEDIF = (v1, v2, unit = "days") => {
+  return momentCompat(v1).diff(v2, unit);
+};
+const NOW = (format = "YYYY-MM-DD HH:mm:ss") => {
+  return momentCompat().format(format);
+};
+const GET_DATE = (v1, unit) => {
+  return momentCompat(v1).get(unit);
+};
+const CONCATENATE = (...v1) => {
+  return v1.join("");
+};
+const VALUE = (v1) => {
+  return Number(v1);
+};
+const LEN = (v1) => {
+  return v1.length;
+};
+const REPLACE_STR = (v1, v2, v3) => {
+  return v1.replace(v2, v3);
+};
+const SUBSTRING = (v1, v2, v3) => {
+  return v1.substr(v2, v3);
+};
+const UPPER = (v1) => {
+  return v1.toUpperCase();
+};
+const LOWER = (v1) => {
+  return v1.toLowerCase();
+};
+const TRIM = (v1) => {
+  return v1.trim();
+};
+const TEXT = (v1) => {
+  return v1.toString();
+};
+const REPLACE = (v1, v2, v3, newtext) => {
+  const startPart = v1.slice(0, v2);
+  const endPart = v1.slice(v2 + v3);
+  return startPart + newtext + endPart;
+};
+const GET = (object, path, defaultValue) => {
+  return get(object, path, defaultValue || "");
+};
+const SET = (object, path, defaultValue) => {
+  return set(object, path, defaultValue || "");
+};
+const KEYS = (object) => {
+  return Object.keys(object);
+};
+const VALUES = (object) => {
+  return Object.values(object);
+};
+const CONDITION_EXPRESSION_RE = /[=<>!&|(]/;
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const IDENTIFIER_ALL_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+const RESERVED_WORDS = ["true", "false", "null", "undefined", "NaN", "Infinity", "this", "typeof", "instanceof", "in", "of", "new", "delete", "void", "function", "return", "var", "let", "const", "if", "else", "do", "while", "for", "break", "continue", "switch", "case", "default", "try", "catch", "finally", "throw", "class", "super", "yield", "await", "item"];
+const conditionCache = {};
+const conditionErrorLogged = {};
+let conditionHelpers = null;
+const getConditionHelpers = () => {
+  if (!conditionHelpers) {
+    const library = {
+      EQ,
+      NE,
+      LT,
+      LE,
+      GT,
+      GE,
+      AND,
+      OR,
+      NOT,
+      IN,
+      IN_TEXT,
+      IF,
+      ISEMPTY,
+      ABS,
+      MAX,
+      MIN,
+      ROUND,
+      FLOOR,
+      CEIL,
+      MOD,
+      POW,
+      SUM,
+      SUBTRACT,
+      PRODUCT,
+      DIVIDED,
+      AVERAGE,
+      VALUE,
+      CONCATENATE,
+      LEN,
+      TEXT,
+      UPPER,
+      LOWER,
+      TRIM,
+      SUBSTRING,
+      REPLACE_STR,
+      NOW,
+      DATE_FORMAT,
+      FORMAT_DATE,
+      DATEDIF,
+      DATE_ADD,
+      DATE_SUBTRACT,
+      GET_DATE,
+      GET,
+      KEYS,
+      VALUES,
+      SIZE,
+      MAP,
+      JOIN,
+      NTH,
+      FILTER,
+      FIND,
+      EVERY,
+      SOME
+    };
+    conditionHelpers = { names: Object.keys(library), values: Object.values(library) };
+  }
+  return conditionHelpers;
+};
+const compileCondition = (cacheKey, expression, fields) => {
+  if (!conditionCache[cacheKey]) {
+    const helpers = getConditionHelpers();
+    const missing = (expression.match(IDENTIFIER_ALL_RE) || []).filter((name) => {
+      return !fields.includes(name) && !helpers.names.includes(name) && !RESERVED_WORDS.includes(name);
+    });
+    const placeholders = missing.filter((name, index) => missing.indexOf(name) === index);
+    try {
+      conditionCache[cacheKey] = new Function(...helpers.names, ...placeholders, "item", ...fields, `return (${expression})`);
+      conditionCache[cacheKey].placeholderCount = placeholders.length;
+    } catch (e) {
+      console.error(`[formula] 条件表达式有语法错误：${expression}`, e);
+      const invalid = () => false;
+      invalid.placeholderCount = 0;
+      conditionCache[cacheKey] = invalid;
+    }
+  }
+  return conditionCache[cacheKey];
+};
+const toIteratee = (iteratee) => {
+  if (typeof iteratee !== "string" || !CONDITION_EXPRESSION_RE.test(iteratee)) return iteratee;
+  return (item) => {
+    const source = item && typeof item === "object" ? item : {};
+    const fields = Object.keys(source).filter((key) => IDENTIFIER_RE.test(key));
+    const cacheKey = `${iteratee}
+${fields.join(",")}`;
+    const compiled = compileCondition(cacheKey, iteratee, fields);
+    const helpers = getConditionHelpers();
+    const placeholders = new Array(compiled.placeholderCount || 0).fill(void 0);
+    try {
+      return !!compiled(...helpers.values, ...placeholders, item, ...fields.map((key) => source[key]));
+    } catch (e) {
+      if (!conditionErrorLogged[cacheKey]) {
+        conditionErrorLogged[cacheKey] = true;
+        console.error(`[formula] 条件表达式执行出错：${iteratee}`, e);
+      }
+      return false;
+    }
+  };
+};
+const MAP = (array, iteratee) => {
+  return map(array, iteratee);
+};
+const SIZE = (array) => {
+  return size(array);
+};
+const JOIN = (array, separator = ",") => {
+  return array.join(separator);
+};
+const ORDER_BY = (array, iteratee, orders) => {
+  if (typeof iteratee === "string") {
+    iteratee = [iteratee];
+  }
+  if (typeof orders === "string") {
+    orders = [orders];
+  }
+  return orderBy(array, iteratee, orders);
+};
+const FILTER = (array, iteratee) => {
+  return filter(array, toIteratee(iteratee));
+};
+const FIND = (array, iteratee) => {
+  return find(array, toIteratee(iteratee));
+};
+const NTH = (array, n) => {
+  return nth(array, n);
+};
+const EVERY = (array, iteratee) => {
+  return every(array, toIteratee(iteratee));
+};
+const SOME = (array, iteratee) => {
+  return some(array, toIteratee(iteratee));
+};
+export {
+  ABS,
+  AND,
+  AVERAGE,
+  CEIL,
+  CONCATENATE,
+  DATEDIF,
+  DATE_ADD,
+  DATE_FORMAT,
+  DATE_SUBTRACT,
+  DIVIDED,
+  EQ,
+  EVERY,
+  FILTER,
+  FIND,
+  FLOOR,
+  FORMAT_DATE,
+  GE,
+  GET,
+  GET_DATE,
+  GT,
+  IF,
+  IN,
+  IN_TEXT,
+  ISEMPTY,
+  JOIN,
+  KEYS,
+  LE,
+  LEN,
+  LOWER,
+  LT,
+  MAP,
+  MAX,
+  MIN,
+  MOD,
+  NE,
+  NOT,
+  NOW,
+  NTH,
+  OR,
+  ORDER_BY,
+  POW,
+  PRODUCT,
+  RANDOM,
+  REPLACE,
+  REPLACE_STR,
+  ROUND,
+  SET,
+  SIZE,
+  SOME,
+  SUBSTRING,
+  SUBTRACT,
+  SUM,
+  TEXT,
+  TRIM,
+  UPPER,
+  VALUE,
+  VALUES
+};

package/dist/src/hljs-lite.js

@@ -0,0 +1,29 @@
+import hljs from "highlight.js/lib/core";
+import { default as default2 } from "highlight.js/lib/core";
+import json from "highlight.js/lib/languages/json";
+import javascript from "highlight.js/lib/languages/javascript";
+import typescript from "highlight.js/lib/languages/typescript";
+import xml from "highlight.js/lib/languages/xml";
+import css from "highlight.js/lib/languages/css";
+import sql from "highlight.js/lib/languages/sql";
+import java from "highlight.js/lib/languages/java";
+import python from "highlight.js/lib/languages/python";
+import bash from "highlight.js/lib/languages/bash";
+import yaml from "highlight.js/lib/languages/yaml";
+import markdown from "highlight.js/lib/languages/markdown";
+hljs.registerLanguage("json", json);
+hljs.registerLanguage("javascript", javascript);
+hljs.registerLanguage("typescript", typescript);
+hljs.registerLanguage("xml", xml);
+hljs.registerLanguage("html", xml);
+hljs.registerLanguage("css", css);
+hljs.registerLanguage("sql", sql);
+hljs.registerLanguage("java", java);
+hljs.registerLanguage("python", python);
+hljs.registerLanguage("bash", bash);
+hljs.registerLanguage("shell", bash);
+hljs.registerLanguage("yaml", yaml);
+hljs.registerLanguage("markdown", markdown);
+export {
+  default2 as default
+};

package/dist/src/index.js

@@ -0,0 +1,24 @@
+import { pdfViewer } from "./legacy.js";
+import { default as default2 } from "./Config.js";
+import { default as default3 } from "./page.js";
+import { default as default4 } from "@epxing/core/src/runtime-utils/fieldFactory";
+import { default as default5 } from "@epxing/core/src/runtime-utils/meta";
+import { default as default6 } from "@epxing/core/src/runtime-utils/pdf.viewer";
+import { default as default7 } from "@epxing/core/src/axios";
+import { default as default8 } from "@epxing/core/src/api";
+import { default as default9 } from "@epxing/core/src/mixins/global";
+import { default as default10 } from "./placeholder.js";
+import { default as default11 } from "@epxing/core/src/runtime-utils/util";
+export {
+  default2 as Config,
+  default4 as FieldFactory,
+  default5 as Meta,
+  default3 as Page,
+  default6 as PdfViewer,
+  default7 as axios,
+  default8 as http,
+  default9 as mixin,
+  pdfViewer,
+  default10 as placeholder,
+  default11 as util
+};

package/dist/src/lazy-jsencrypt.js

@@ -0,0 +1,13 @@
+import { __vitePreload as __epxPackagePreload } from "../_virtual/preload-helper.js";
+let pending = null;
+function loadJSEncrypt() {
+  if (pending) return pending;
+  pending = __epxPackagePreload(() => import("../_virtual/jsencrypt.min.js").then((n) => n.j), true ? [] : void 0, import.meta.url).then((mod) => mod.default || mod.JSEncrypt || mod).catch((err) => {
+    pending = null;
+    throw err;
+  });
+  return pending;
+}
+export {
+  loadJSEncrypt as default
+};

package/dist/src/legacy.js

@@ -0,0 +1,25 @@
+import { default as default2 } from "@epxing/core/src/runtime-utils/util";
+import { default as default3 } from "@epxing/core/src/axios";
+import { default as default4 } from "./Config.js";
+import { default as default5 } from "@epxing/core/src/runtime-utils/fieldFactory";
+import { default as default6 } from "@epxing/core/src/runtime-utils/meta";
+import { default as default7 } from "./page.js";
+import { default as default8 } from "@epxing/core/src/api";
+import { default as default9 } from "@epxing/core/src/mixins/global";
+import PdfViewer from "@epxing/core/src/runtime-utils/pdf.viewer";
+import { default as default10 } from "@epxing/core/src/runtime-utils/pdf.viewer";
+import { default as default11 } from "./placeholder.js";
+const pdfViewer = new PdfViewer();
+export {
+  default4 as Config,
+  default5 as FieldFactory,
+  default6 as Meta,
+  default7 as Page,
+  default10 as PdfViewer,
+  default3 as axios,
+  default8 as http,
+  default9 as mixin,
+  pdfViewer,
+  default11 as placeholder,
+  default2 as util
+};

package/dist/src/locale.js

@@ -0,0 +1,88 @@
+import storage from "./storage.js";
+const STANDARD_SEGMENT = /^[A-Za-z0-9_]+$/;
+const LEGACY_LOCALES = {
+  "010": "zh-CN",
+  "011": "en-US"
+};
+function normalizeLocale(locale) {
+  return LEGACY_LOCALES[locale] || locale;
+}
+function languagePreferenceKey(clientCode) {
+  return `${clientCode || ""}-language`;
+}
+function configuredLocales(clientConfig = {}) {
+  const languages = String(clientConfig.LANGUAGES || "").split(",").map((value) => normalizeLocale(value.trim())).filter(Boolean);
+  const defaultLocale = normalizeLocale(clientConfig.LANGUAGE_DEFAULT || "zh-CN");
+  const supportedLocales = languages.length > 0 ? languages : [defaultLocale];
+  return {
+    enabled: clientConfig.LANGUAGE_FLAG === "1",
+    defaultLocale,
+    supportedLocales
+  };
+}
+function resolveCurrentLocale(clientConfig = {}, userInfo = {}) {
+  const clientCode = clientConfig.CODE || "";
+  const configuration = configuredLocales(clientConfig);
+  if (!configuration.enabled) return configuration.defaultLocale;
+  const preferred = normalizeLocale(storage.get(languagePreferenceKey(clientCode)) || userInfo.LANGUAGE);
+  const matched = configuration.supportedLocales.find((locale) => locale.toLowerCase() === String(preferred || "").toLowerCase());
+  return matched || configuration.defaultLocale;
+}
+function utf8Hex(value) {
+  return Array.from(new TextEncoder().encode(value)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function resourceSegment(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) throw new Error("国际化消息名称不能为空");
+  return STANDARD_SEGMENT.test(normalized) ? normalized.toLowerCase() : `x_${utf8Hex(normalized)}`;
+}
+function uiMessageResourceKey(messageName, systemId) {
+  const raw = String(messageName || "").trim().split(".");
+  while (raw.length > 0 && raw[raw.length - 1] === "") raw.pop();
+  const start = raw[0] && raw[0].toLowerCase() === "frame" ? 1 : 0;
+  const segments = raw.slice(start).map(resourceSegment);
+  if (segments.length === 1) segments.unshift(resourceSegment(systemId));
+  if (segments.length < 2) throw new Error(`国际化消息名称缺少有效语义段：${messageName}`);
+  return `page.${segments.join(".")}`;
+}
+function createUiMessageCatalog(rows = [], systemId) {
+  const fallbackMessages = {};
+  const aliases = {};
+  rows.forEach((row) => {
+    const name = String(row.NAME || "").trim();
+    if (!name) return;
+    const resourceKey = uiMessageResourceKey(name, systemId);
+    fallbackMessages[name] = row.CONTENT;
+    fallbackMessages[resourceKey] = row.CONTENT;
+    const keys = aliases[resourceKey] || (aliases[resourceKey] = []);
+    keys.push(name);
+    const source = String(row.CONTENT || "").trim();
+    if (source && source !== name && !Object.prototype.hasOwnProperty.call(fallbackMessages, source)) {
+      fallbackMessages[source] = row.CONTENT;
+      keys.push(source);
+    }
+  });
+  return { fallbackMessages, aliases };
+}
+function createRuntimeMessages(publishedMessages = {}, catalog = {}) {
+  const messages = { ...publishedMessages };
+  const aliases = catalog.aliases || {};
+  Object.keys(aliases).forEach((resourceKey) => {
+    if (!Object.prototype.hasOwnProperty.call(publishedMessages, resourceKey)) return;
+    aliases[resourceKey].forEach((key) => {
+      if (!Object.prototype.hasOwnProperty.call(messages, key)) {
+        messages[key] = publishedMessages[resourceKey];
+      }
+    });
+  });
+  return messages;
+}
+export {
+  configuredLocales,
+  createRuntimeMessages,
+  createUiMessageCatalog,
+  languagePreferenceKey,
+  normalizeLocale,
+  resolveCurrentLocale,
+  uiMessageResourceKey
+};

package/dist/src/menu-open.js

@@ -0,0 +1,43 @@
+const EXTERNAL_OPEN_TYPES = ["6", "7"];
+function isExternalMenu(module) {
+  return !!module && EXTERNAL_OPEN_TYPES.indexOf(module.OPEN_TYPE) > -1;
+}
+function openExternalMenu(module, vm) {
+  if (!isExternalMenu(module)) return false;
+  if (module.OPEN_TYPE === "6") {
+    if (module.LINK_URL) window.open(module.LINK_URL);
+    return true;
+  }
+  if (!module.REFERENCE_APP) {
+    vm.$message.error("该菜单未配置目标应用");
+    return true;
+  }
+  const win = window.open("", "_blank");
+  vm.$http.get({
+    entityId: "FM_SERVICE",
+    id: module.REFERENCE_APP,
+    link: "system,system|client"
+  }).then((res) => {
+    const app = res && res.data || {};
+    const clientCode = app["SYSTEM|CLIENT|CODE"];
+    const systemCode = app["SYSTEM|CODE"];
+    if (!app.CODE || !systemCode || !clientCode) {
+      if (win) win.close();
+      vm.$message.error("没有找到该应用");
+      return;
+    }
+    const url = `${vm.$util.getRootPath()}/app/${clientCode}/${systemCode}/${app.CODE}`;
+    if (win) {
+      win.location = url;
+    } else {
+      window.open(url);
+    }
+  }).catch(() => {
+    if (win) win.close();
+  });
+  return true;
+}
+export {
+  isExternalMenu,
+  openExternalMenu
+};