@opentinyvue/vue-renderless 3.21.0

package/common/array.js

@@ -0,0 +1,115 @@
+import {
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+import { SORT } from "./index";
+import { isSame } from "./type";
+import { getObj } from "./object";
+const indexOf = (arr, data, predicate = isSame) => {
+  if (Array.isArray(arr) && typeof predicate === "function") {
+    for (let i = 0, len = arr.length; i < len; i++) {
+      if (predicate(arr[i], data)) {
+        return i;
+      }
+    }
+  }
+  return -1;
+};
+const find = (arr, predicate) => {
+  const index = indexOf(arr, void 0, predicate);
+  return index !== -1 ? arr[index] : void 0;
+};
+const remove = (arr, data, count = 1) => {
+  if (Array.isArray(arr) && arr.length) {
+    const index = indexOf(arr, data);
+    if (index > -1) {
+      arr.splice(index, count);
+    }
+  }
+  return arr;
+};
+const sort = (arr, field, sort2 = SORT.Asc) => {
+  if (Array.isArray(arr) && arr.length > 1) {
+    arr.sort((x, y) => {
+      const compare = sort2 === SORT.Asc ? [1, -1] : [-1, 1];
+      const xField = getObj(x, field);
+      const yField = getObj(y, field);
+      if (isNaN(xField)) {
+        return sort2 === SORT.Asc ? 1 : -1;
+      } else if (isNaN(yField)) {
+        return -1;
+      }
+      return xField > yField ? compare[0] : compare[1];
+    });
+  }
+  return arr;
+};
+const push = (arr, data) => {
+  if (Array.isArray(arr) && !arr.some((value) => isSame(value, data))) {
+    arr.push(data);
+  }
+  return arr;
+};
+const unique = (arr) => {
+  if (Array.isArray(arr)) {
+    const array = [];
+    for (let i = 0, len = arr.length; i < len; i++) {
+      const value = arr[i];
+      if (indexOf(array, value) === -1) {
+        array.push(value);
+      }
+    }
+    return array;
+  }
+  return arr;
+};
+const extend = (to, _from) => {
+  Object.keys(_from).forEach((key) => to[key] = _from[key]);
+  return to;
+};
+const toObject = (arr) => {
+  const res = {};
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i]) {
+      extend(res, arr[i]);
+    }
+  }
+  return res;
+};
+const transformPidToChildren = (data, pidName = "pId", childrenName = "children", idName = "id") => {
+  const result = [];
+  Array.isArray(data) && data.forEach((item) => {
+    if (item[pidName] == "0") {
+      result.push(item);
+    } else {
+      const parent = find(data, (i) => i[idName] == item[pidName]);
+      if (!parent) {
+        return;
+      }
+      if (!parent[childrenName]) {
+        parent[childrenName] = [];
+      }
+      parent[childrenName].push(item);
+    }
+    delete item[pidName];
+  });
+  return result;
+};
+const transformTreeData = (data, key = "id", parentKey = "pId") => {
+  if (!Array.isArray(data)) {
+    data = [data];
+  }
+  data = data.map((item) => __spreadValues({}, item));
+  const treeData = transformPidToChildren(data, parentKey, "children", key);
+  return treeData;
+};
+export {
+  find,
+  indexOf,
+  push,
+  remove,
+  sort,
+  toObject,
+  transformPidToChildren,
+  transformTreeData,
+  unique
+};

package/common/bigInt.js

@@ -0,0 +1,315 @@
+import "../chunk-G2ADBYYC.js";
+import { fillChar } from "./string";
+import { isBrowser } from "./browser";
+const BigInt = isBrowser ? window.BigInt : global.BigInt;
+function supportBigInt() {
+  return typeof BigInt === "function";
+}
+function trimNumber(numStr) {
+  let string = numStr.toString().trim();
+  let negative = string.startsWith("-");
+  if (negative) {
+    string = string.slice(1);
+  }
+  string = string.replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, "");
+  if (string.startsWith(".")) {
+    string = "0".concat(string);
+  }
+  let trimStr = string || "0";
+  let splitNumber = trimStr.split(".");
+  let integerStr = splitNumber[0] || "0";
+  let decimalStr = splitNumber[1] || "0";
+  if (integerStr === "0" && decimalStr === "0") {
+    negative = false;
+  }
+  let negativeStr = negative ? "-" : "";
+  return {
+    negative,
+    negativeStr,
+    trimStr,
+    integerStr,
+    decimalStr,
+    fullStr: "".concat(negativeStr).concat(trimStr)
+  };
+}
+function isE(number) {
+  let str = String(number);
+  return !isNaN(Number(str)) && ~str.indexOf("e");
+}
+function validateNumber(num) {
+  if (typeof num === "number") {
+    return !isNaN(num);
+  }
+  if (!num) {
+    return false;
+  }
+  return (
+    // Normal type: 11.28
+    /^\s*-?\d+(\.\d+)?\s*$/.test(num) || // Pre-number: 1.
+    /^\s*-?\d+\.\s*$/.test(num) || // Post-number: .1
+    /^\s*-?\.\d+\s*$/.test(num)
+  );
+}
+function getNumberPrecision(number) {
+  let numStr = String(number);
+  if (isE(number)) {
+    let precision = Number(numStr.slice(numStr.indexOf("e-") + 2));
+    let decimalMatch = numStr.match(/\.(\d+)/);
+    if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) {
+      precision += decimalMatch[1].length;
+    }
+    return precision;
+  }
+  return ~numStr.indexOf(".") && validateNumber(numStr) ? numStr.length - numStr.indexOf(".") - 1 : 0;
+}
+function num2str(number) {
+  let numStr = String(number);
+  if (isE(number)) {
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
+    }
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
+    }
+    numStr = number.toFixed(getNumberPrecision(numStr));
+  }
+  return trimNumber(numStr).fullStr;
+}
+function pluginDecimal(decimal) {
+  if (!decimal.add) {
+    Object.assign(decimal, {
+      add: decimal.plus,
+      lessEquals: decimal.isLessThan,
+      equals: decimal.isEqualTo
+    });
+  }
+  return decimal;
+}
+const DecimalCls = {
+  CLS: null
+};
+let setDecimalClass;
+function getMiniDecimal(value, decimal) {
+  if (!DecimalCls.CLS) {
+    setDecimalClass(decimal);
+  }
+  return pluginDecimal(new DecimalCls.CLS(value));
+}
+class BigIntDecimal {
+  constructor(value) {
+    if (!value && value !== 0 || !String(value).trim()) {
+      this.empty = true;
+      return;
+    }
+    this.origin = String(value);
+    this.negative = void 0;
+    this.integer = void 0;
+    this.decimal = void 0;
+    this.decimalLen = void 0;
+    this.empty = void 0;
+    this.nan = void 0;
+    if (value === "-") {
+      this.nan = true;
+      return;
+    }
+    let mergedValue = isE(value) ? Number(value) : value;
+    if (typeof mergedValue !== "string") {
+      num2str(mergedValue);
+    }
+    const f = Function;
+    const convertBigInt = (str) => {
+      const validStr = str.replace(/^0+/, "") || "0";
+      return f(`return BigInt('${validStr}')`)();
+    };
+    if (validateNumber(mergedValue)) {
+      const trimRet = trimNumber(mergedValue);
+      this.negative = trimRet.negative;
+      const numbers = trimRet.trimStr.split(".");
+      this.integer = !numbers[0].includes("e") ? BigInt(numbers[0]) : numbers[0];
+      const decimalStr = numbers[1] || "0";
+      this.decimal = decimalStr.includes("e") ? convertBigInt(decimalStr) : BigInt(decimalStr);
+      this.decimalLen = decimalStr.length;
+    } else {
+      this.nan = true;
+    }
+  }
+  getDecimalStr() {
+    return this.decimal.toString().padStart(this.decimalLen, "0");
+  }
+  getIntegerStr() {
+    return this.integer.toString();
+  }
+  getMark() {
+    return this.negative ? "-" : "";
+  }
+  /**
+   * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
+   * This is used for add function only.
+   */
+  alignDecimal(decimalLength) {
+    const string = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(decimalLength, "0")}`;
+    return BigInt(string);
+  }
+  add(value) {
+    if (this.isInvalidate()) {
+      return new BigIntDecimal(value);
+    }
+    const offsetObj = new BigIntDecimal(value);
+    if (offsetObj.isInvalidate()) {
+      return this;
+    }
+    const maxDecimalLength = Math.max(this.getDecimalStr().length, offsetObj.getDecimalStr().length);
+    const offsetAlignedDecimal = offsetObj.alignDecimal(maxDecimalLength);
+    const myAlignedDecimal = this.alignDecimal(maxDecimalLength);
+    const valueStr = `${myAlignedDecimal + offsetAlignedDecimal}`;
+    const { negativeStr: str, trimStr } = trimNumber(valueStr);
+    const hydrateValueStr = `${str}${trimStr.padStart(maxDecimalLength + 1, "0")}`;
+    return getMiniDecimal(`${hydrateValueStr.slice(0, -maxDecimalLength)}.${hydrateValueStr.slice(-maxDecimalLength)}`);
+  }
+  negate() {
+    const clone = new BigIntDecimal(this.toString());
+    clone.negative = !clone.negative;
+    return clone;
+  }
+  isNaN() {
+    return this.nan;
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  lessEquals(target) {
+    return this.add(target.negate().toString()).toNumber() <= 0;
+  }
+  equals(target) {
+    return this.toString() === (target && target.toString());
+  }
+  toNumber() {
+    if (this.isNaN()) {
+      return NaN;
+    }
+    return Number(this.toString());
+  }
+  toString(safe = true) {
+    if (!safe) {
+      return this.origin;
+    }
+    if (this.isInvalidate()) {
+      return "";
+    }
+    return trimNumber(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr;
+  }
+}
+class NumberDecimal {
+  constructor(value = "") {
+    if (!value && value !== 0 || !String(value).trim()) {
+      this.empty = true;
+      return;
+    }
+    this.origin = "";
+    this.number = void 0;
+    this.empty = void 0;
+    this.origin = String(value);
+    this.number = Number(value);
+  }
+  negate() {
+    return new NumberDecimal(-this.toNumber());
+  }
+  add(value) {
+    if (this.isInvalidate()) {
+      return new NumberDecimal(value);
+    }
+    const target = Number(value);
+    if (isNaN(target)) {
+      return this;
+    }
+    const number = this.number + target;
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MIN_SAFE_INTEGER);
+    }
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MAX_SAFE_INTEGER);
+    }
+    const maxPrecision = Math.max(getNumberPrecision(target), getNumberPrecision(this.number));
+    return new NumberDecimal(number.toFixed(maxPrecision));
+  }
+  isNaN() {
+    return isNaN(this.number);
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  equals(target) {
+    return this.toNumber() === (target && target.toNumber());
+  }
+  lessEquals(target) {
+    return this.add(target.negate().toString()).toNumber() <= 0;
+  }
+  toNumber() {
+    return this.number;
+  }
+  toString(safe = true) {
+    if (!safe) {
+      return this.origin;
+    }
+    if (this.isInvalidate()) {
+      return "";
+    }
+    return num2str(this.number);
+  }
+}
+setDecimalClass = function(decimaljs) {
+  DecimalCls.CLS = supportBigInt() ? BigIntDecimal : typeof decimaljs === "function" ? decimaljs : NumberDecimal;
+};
+function lessEquals(value1, value2) {
+  return getMiniDecimal(value1).lessEquals(getMiniDecimal(value2));
+}
+function equalsDecimal(value1, value2) {
+  return getMiniDecimal(value1).equals(getMiniDecimal(value2));
+}
+function toFixed(numStr, precision, rounding = 5) {
+  if (numStr === "") {
+    return "";
+  }
+  const separatorStr = ".";
+  const { negativeStr, integerStr, decimalStr } = trimNumber(numStr);
+  const precisionDecimalStr = `${separatorStr}${decimalStr}`;
+  const numberWithoutDecimal = `${negativeStr}${integerStr}`;
+  if (precision >= 0) {
+    const advancedNum = Number(decimalStr[precision]);
+    if (advancedNum >= rounding && rounding !== 0) {
+      const advancedDecimal = getMiniDecimal(`${integerStr}${separatorStr}${decimalStr}`).add(
+        `0.${fillChar("", precision, true)}${10 - advancedNum}`
+      );
+      return toFixed(negativeStr + advancedDecimal.toString(), precision, 0);
+    }
+    if (precision === 0) {
+      return numberWithoutDecimal;
+    }
+    return `${numberWithoutDecimal}${separatorStr}${fillChar(decimalStr, precision, true).slice(0, precision)}`;
+  }
+  if (precisionDecimalStr === ".0") {
+    return numberWithoutDecimal;
+  }
+  return `${numberWithoutDecimal}${precisionDecimalStr}`;
+}
+export {
+  BigIntDecimal,
+  NumberDecimal,
+  equalsDecimal,
+  getMiniDecimal,
+  getNumberPrecision,
+  isE,
+  lessEquals,
+  num2str,
+  setDecimalClass,
+  supportBigInt,
+  toFixed,
+  trimNumber,
+  validateNumber
+};

package/common/browser.js

@@ -0,0 +1,81 @@
+import "../chunk-G2ADBYYC.js";
+const getIEVersion = () => {
+  let version = 8;
+  if (!!document.addEventListener && !!window.performance) {
+    version = 9;
+    if (!!window.atob && !!window.matchMedia) {
+      version = 10;
+      if (!window.attachEvent && !document.all) {
+        version = 11;
+      }
+    }
+  }
+  return version;
+};
+const isEdge = (browser) => {
+  if (browser.chrome && ~navigator.userAgent.indexOf("Edg")) {
+    browser.name = "edge";
+    browser.edge = true;
+    delete browser.chrome;
+  } else if (!document.documentMode && !!window.StyleMedia) {
+    browser.name = "edge";
+    browser.edge = true;
+  }
+};
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && window.document === document;
+const globalEnvironment = isBrowser ? window : global;
+var browser_default = (() => {
+  const browser = {
+    name: void 0,
+    version: void 0,
+    isDoc: typeof document !== "undefined",
+    isMobile: false,
+    isPC: true,
+    isNode: typeof window === "undefined"
+  };
+  if (isBrowser) {
+    const isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
+    browser.isMobile = isMobile;
+    browser.isPC = !isMobile;
+    let matches;
+    if (!!window.chrome && (!!window.chrome.webstore || /^Google\b/.test(window.navigator.vendor))) {
+      browser.name = "chrome";
+      browser.chrome = true;
+      matches = navigator.userAgent.match(/chrome\/(\d+)/i);
+      browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
+      matches = void 0;
+    } else if (!!document.all || !!document.documentMode) {
+      browser.name = "ie";
+      browser.version = getIEVersion();
+      browser.ie = true;
+    } else if (typeof window.InstallTrigger !== "undefined") {
+      browser.name = "firefox";
+      browser.firefox = true;
+    } else if (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") > 0) {
+      browser.name = "safari";
+      browser.safari = true;
+    } else if (!!window.opr && !!window.opr.addons || !!window.opera) {
+      browser.name = "opera";
+      browser.opera = true;
+    }
+    isEdge(browser);
+    if (!~["ie", "chrome"].indexOf(browser.name)) {
+      const reg = browser.name + "/(\\d+)";
+      matches = navigator.userAgent.match(new RegExp(reg, "i"));
+      browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
+      matches = void 0;
+    }
+    if (browser.isDoc) {
+      const bodyEl = document.body || document.documentElement;
+      ["webkit", "khtml", "moz", "ms", "o"].forEach((core) => {
+        browser["-" + core] = !!bodyEl[core + "MatchesSelector"];
+      });
+    }
+  }
+  return browser;
+})();
+export {
+  browser_default as default,
+  globalEnvironment,
+  isBrowser
+};

package/common/calendar/calendar.js

@@ -0,0 +1,97 @@
+import "../../chunk-G2ADBYYC.js";
+import { isLeapYear } from "../date";
+const getDays = (year, month) => {
+  return [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+};
+const getWeek = (year, month, day) => (/* @__PURE__ */ new Date(`${year}/${month}/${day}`)).getDay();
+const lastMonth = (year, month) => {
+  year = +year;
+  month = +month;
+  if (month === 1) {
+    year--;
+    month = 12;
+  } else {
+    month--;
+  }
+  return { year, month };
+};
+const nextMonth = (year, month) => {
+  year = +year;
+  month = +month;
+  if (month === 12) {
+    year++;
+    month = 1;
+  } else {
+    month++;
+  }
+  return { year, month };
+};
+const getCalendar = (year, month) => {
+  if (year && month && month <= 12) {
+    const days = getDays(year, month);
+    const firstWeek = getWeek(year, month, 1);
+    const lastWeek = getWeek(year, month, days);
+    const last = lastMonth(year, month);
+    const next = nextMonth(year, month);
+    const lastDays = getDays(last.year, last.month);
+    let remainDays = 0;
+    const totalDays = days + firstWeek + 7 - lastWeek - 1;
+    if (totalDays / 7 < 6 && totalDays / 7 >= 5) {
+      remainDays = 6 * 7 - totalDays;
+    }
+    return {
+      last: {
+        year: last.year,
+        month: last.month,
+        start: lastDays - (firstWeek - 1),
+        end: lastDays
+      },
+      current: {
+        year,
+        month,
+        start: 1,
+        end: days
+      },
+      next: {
+        year: next.year,
+        month: next.month,
+        start: 1,
+        end: 7 - lastWeek - 1 + remainDays
+      }
+    };
+  }
+};
+const transformArray = (array) => {
+  const result = [];
+  let index = 0;
+  if (array && array.length) {
+    const length = array.length / 7;
+    for (let i = 0; i < length; i++) {
+      result[i] = [];
+      for (let j = 0; j < 7; j++) {
+        result[i][j] = array[index++];
+      }
+    }
+  }
+  return result;
+};
+const parseDate = (time) => {
+  const date = new Date(time && typeof time === "number" ? time : 0);
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate(),
+    hours: date.getHours(),
+    minutes: date.getMinutes(),
+    seconds: date.getSeconds()
+  };
+};
+export {
+  getCalendar,
+  getDays,
+  getWeek,
+  lastMonth,
+  nextMonth,
+  parseDate,
+  transformArray
+};

package/common/dataset/index.js

@@ -0,0 +1,99 @@
+import {
+  __objRest,
+  __spreadValues
+} from "../../chunk-G2ADBYYC.js";
+import { format } from "../string";
+import { isObject } from "../type";
+import { transformTreeData } from "../array";
+const getFilterStr = (filters) => {
+  const filterArr = {};
+  Object.keys(filters).forEach((property) => {
+    const { type, value } = filters[property];
+    if (type === "enum") {
+      filterArr[property] = { type: value.map(() => 0), value };
+      if (value.length > 1) {
+        filters[property].relation = "or";
+      }
+    }
+    if (type === "input") {
+      const { relation, text } = value;
+      filterArr[property] = {
+        type: [relation === "startwith" ? 8 : relation === "equals" ? 0 : 6],
+        value: text
+      };
+    }
+  });
+  return JSON.stringify(filterArr);
+};
+const getNsObj = (obj, names) => {
+  const arr = Array.isArray(names) ? names : names.split(".");
+  const curkey = arr.shift();
+  const curObj = obj[curkey];
+  if (isObject(curObj) && arr.length) {
+    return getNsObj(curObj, arr);
+  }
+  return curObj;
+};
+const handlerArgs = (options, args) => {
+  if (args) {
+    const { page, sort, filters } = args;
+    const { currentPage, pageSize } = page || {};
+    const filterStr = getFilterStr(filters || {});
+    const orderBy = sort && sort.property ? sort.property + " " + sort.order : "";
+    options.url = format(options.url, {
+      curPage: currentPage,
+      pageSize,
+      filterStr,
+      orderBy
+    });
+  }
+};
+const transForm = (response, tree) => {
+  const { result, pageVO } = response;
+  const { key = "id", parentKey } = tree || {};
+  let data = result || response;
+  if (parentKey) {
+    data = transformTreeData(data, key, parentKey);
+  }
+  return pageVO ? { result: data, page: { total: pageVO.totalRows } } : data;
+};
+const getDataset = ({ dataset, service, tree }, args) => new Promise((resolve, reject) => {
+  const { source, value, api } = dataset || {};
+  const $service = service || dataset && dataset.service;
+  if (Array.isArray(dataset)) {
+    return resolve(transForm(dataset, tree));
+  }
+  if (Array.isArray(value)) {
+    return resolve(transForm(value, tree));
+  }
+  if (!$service) {
+    return resolve([]);
+  }
+  if (isObject(source) && source.url) {
+    const _a = source, { type = "GET", data, beforeRequest, afterRequest, success, hideErr, url, method } = _a, options = __objRest(_a, ["type", "data", "beforeRequest", "afterRequest", "success", "hideErr", "url", "method"]);
+    options.url = url;
+    options.method = method || type.toLocaleLowerCase();
+    const mergeTarget = options.method === "get" ? "params" : "data";
+    options[mergeTarget] = data || {};
+    const afterRequestFn = afterRequest || success;
+    const config = __spreadValues({}, options);
+    handlerArgs(config, args);
+    beforeRequest && beforeRequest(config, args);
+    $service.network.request(config).then((response) => {
+      afterRequestFn && afterRequestFn(response.data);
+      resolve(transForm(response.data, tree));
+    }).catch((error) => {
+      hideErr || reject(error);
+    });
+  } else if (api) {
+    const fetchFn = getNsObj($service, api.name);
+    fetchFn && fetchFn(__spreadValues(__spreadValues({}, api.data), args)).then((response) => {
+      resolve(transForm(response, tree));
+    }).catch((error) => {
+      reject(error);
+    });
+  }
+});
+export {
+  getDataset
+};