@jeecg/online 1.0.1

package/QueryTable.js

@@ -0,0 +1,128 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = 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;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { defineComponent, ref, resolveComponent, openBlock, createBlock } from "vue";
+import { JVxeTypes } from "/@/components/jeecg/JVxeTable/types";
+import { u as useTableSync } from "./useTableSync.js";
+import { _ as _export_sfc } from "./index.js";
+import "./cgform.data.js";
+import "/@/utils/dict";
+import "/@/utils/dict/JDictSelectUtil";
+import "/@/utils/uuid";
+import "./pick.js";
+import "./isArray.js";
+import "./toString.js";
+import "./_arrayPush.js";
+import "/@/components/jeecg/OnLine/JPopupOnlReport.vue";
+import "/@/hooks/web/useMessage";
+import "vue-router";
+const _sfc_main = defineComponent({
+  name: "QueryTable",
+  emits: ["query"],
+  setup(_, { emit }) {
+    const columns = ref([
+      { title: "\u5B57\u6BB5\u540D\u79F0", key: "dbFieldName", width: 130 },
+      { title: "\u5B57\u6BB5\u5907\u6CE8", key: "dbFieldTxt", width: 130 },
+      {
+        title: "\u63A7\u4EF6\u7C7B\u578B",
+        key: "queryShowType",
+        width: 170,
+        type: JVxeTypes.select,
+        options: [
+          { title: "\u6587\u672C\u6846", value: "text" },
+          { title: "\u65E5\u671F(yyyy-MM-dd)", value: "date" },
+          { title: "\u65E5\u671F\uFF08yyyy-MM-dd HH:mm:ss\uFF09", value: "datetime" },
+          { title: "\u65F6\u95F4\uFF08HH:mm:ss\uFF09", value: "time" },
+          { title: "\u4E0B\u62C9\u6846", value: "list" },
+          { title: "\u4E0B\u62C9\u591A\u9009\u6846", value: "list_multi" },
+          { title: "\u4E0B\u62C9\u641C\u7D22\u6846", value: "sel_search" },
+          { title: "\u5206\u7C7B\u5B57\u5178\u6811", value: "cat_tree" },
+          { title: "Popup\u5F39\u6846", value: "popup" },
+          { title: "\u90E8\u95E8\u9009\u62E9", value: "sel_depart" },
+          { title: "\u7528\u6237\u9009\u62E9", value: "sel_user" },
+          { title: "\u7701\u5E02\u533A\u7EC4\u4EF6", value: "pca" },
+          { title: "\u81EA\u5B9A\u4E49\u6811\u63A7\u4EF6", value: "sel_tree" }
+        ],
+        defaultValue: "text",
+        placeholder: "\u8BF7\u9009\u62E9${title}"
+      },
+      {
+        title: "\u5B57\u5178Table",
+        key: "queryDictTable",
+        width: 130,
+        type: JVxeTypes.textarea,
+        defaultValue: ""
+      },
+      {
+        title: "\u5B57\u5178Code",
+        key: "queryDictField",
+        width: 130,
+        type: JVxeTypes.input,
+        defaultValue: ""
+      },
+      {
+        title: "\u5B57\u5178Text",
+        key: "queryDictText",
+        width: 130,
+        type: JVxeTypes.input,
+        defaultValue: ""
+      },
+      {
+        title: "\u9ED8\u8BA4\u503C",
+        key: "queryDefVal",
+        width: 130,
+        type: JVxeTypes.input,
+        defaultValue: ""
+      },
+      {
+        title: "\u662F\u5426\u542F\u7528",
+        key: "queryConfigFlag",
+        minWidth: 80,
+        type: JVxeTypes.checkbox,
+        customValue: ["1", "0"],
+        defaultChecked: false
+      }
+    ]);
+    const setup = useTableSync(columns);
+    function handleChange({ row, column, value }) {
+      if (column.key === "queryConfigFlag") {
+        if (value === "1") {
+          emit("query", row.id);
+        }
+      }
+    }
+    return __spreadProps(__spreadValues({}, setup), { columns, handleChange });
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_JVxeTable = resolveComponent("JVxeTable");
+  return openBlock(), createBlock(_component_JVxeTable, {
+    ref: "tableRef",
+    rowNumber: "",
+    keyboardEdit: "",
+    maxHeight: _ctx.tableHeight.noToolbar,
+    loading: _ctx.loading,
+    columns: _ctx.columns,
+    dataSource: _ctx.dataSource,
+    disabledRows: { dbFieldName: ["id", "has_child"] },
+    onValueChange: _ctx.handleChange
+  }, null, 8, ["maxHeight", "loading", "columns", "dataSource", "onValueChange"]);
+}
+var QueryTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { QueryTable as default };

package/README.md

@@ -0,0 +1,23 @@
+# jeecg online form vue3
+
+
+## Install
+
+```bash
+yarn add @jeecg/online
+```
+
+```javascript
+src/main.js
+
+require('@jeecg/antd-online-mini')
+require('@jeecg/antd-online-mini/dist/OnlineForm.css')
+```
+
+## Description
+
+```
+Jeecg Online UI
+ 1、低代码开发模块 
+ 2、在线建表功能
+```

package/_arrayPush.js

@@ -0,0 +1,276 @@
+import { b as baseGetTag, r as root, i as isObjectLike } from "./isArray.js";
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root["__core-js_shared__"];
+var coreJsData$1 = coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$4 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$4).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var defineProperty = function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+}();
+var defineProperty$1 = defineProperty;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty$1) {
+    defineProperty$1(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty$3.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag;
+}
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+var isArguments = baseIsArguments(function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments$1 = isArguments;
+var nativeCreate = getNative(Object, "create");
+var nativeCreate$1 = nativeCreate;
+function hashClear() {
+  this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate$1) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$1 ? void 0 : result;
+  }
+  return hasOwnProperty$1.call(data, key) ? data[key] : void 0;
+}
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+}
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate$1 && value === void 0 ? HASH_UNDEFINED : value;
+  return this;
+}
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+var Map = getNative(root, "Map");
+var Map$1 = Map;
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$1 || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+export { ListCache as L, Map$1 as M, assignValue as a, baseAssignValue as b, isLength as c, isFunction as d, isArguments$1 as e, isIndex as f, getNative as g, MapCache as h, isObject as i, arrayPush as j, defineProperty$1 as k, toSource as t };

package/auth.api.js

@@ -0,0 +1,43 @@
+import { defHttp } from "/@/utils/http/axios";
+const authFieldLoadData = (cgformId, params) => defHttp.get({ url: `${"/online/cgform/api/authColumn"}/${cgformId}`, params });
+const authFieldUpdateStatus = (params) => defHttp.put({ url: "/online/cgform/api/authColumn", params });
+const authFieldUpdateCheckbox = (params) => defHttp.post({ url: "/online/cgform/api/authColumn", params });
+const authButtonLoadData = (cgformId, params) => defHttp.get({ url: `${"/online/cgform/api/authButton"}/${cgformId}`, params });
+const authButtonEnable = (params) => defHttp.post({ url: "/online/cgform/api/authButton", params });
+const authButtonDisable = (id, params) => defHttp.put({ url: `${"/online/cgform/api/authButton"}/${id}`, params });
+const authDataLoadData = (cgformId, params) => defHttp.get({ url: `${"/online/cgform/api/authData"}/${cgformId}`, params });
+const authDataUpdateStatus = (params) => defHttp.put({ url: "/online/cgform/api/authData", params });
+const authDataSaveOrUpdate = (params, isUpdate) => {
+  if (isUpdate) {
+    return defHttp.put({ url: "/online/cgform/api/authData", params });
+  } else {
+    return defHttp.post({ url: "/online/cgform/api/authData", params });
+  }
+};
+const authDataDelete = (id, params) => defHttp.delete({ url: `${"/online/cgform/api/authData"}/${id}`, params });
+const authFieldLoadTree = (cgformId, authType, params) => {
+  let url = `${"/online/cgform/api/authPage"}/${cgformId}/${authType}`;
+  return defHttp.get({ url, params });
+};
+const authDataLoadTree = (cgformId, params) => {
+  let url = `${"/online/cgform/api/validAuthData"}/${cgformId}`;
+  return defHttp.get({ url, params });
+};
+const authButtonLoadTree = (cgformId, authType, params) => {
+  let url = `${"/online/cgform/api/authPage"}/${cgformId}/${authType}`;
+  return defHttp.get({ url, params });
+};
+const loadRoleAuthChecked = (params) => defHttp.get({ url: "/online/cgform/api/roleAuth", params });
+const saveAuthField = (roleId, cgformId, params) => {
+  let url = `${"/online/cgform/api/roleColumnAuth"}/${roleId}/${cgformId}`;
+  return defHttp.post({ url, params });
+};
+const saveAuthData = (roleId, cgformId, params) => {
+  let url = `${"/online/cgform/api/roleDataAuth"}/${roleId}/${cgformId}`;
+  return defHttp.post({ url, params });
+};
+const saveAuthButton = (roleId, cgformId, params) => {
+  let url = `${"/online/cgform/api/roleButtonAuth"}/${roleId}/${cgformId}`;
+  return defHttp.post({ url, params });
+};
+export { authFieldLoadData as a, authFieldUpdateStatus as b, authFieldUpdateCheckbox as c, authButtonLoadData as d, authButtonEnable as e, authButtonDisable as f, authDataLoadData as g, authDataSaveOrUpdate as h, authDataUpdateStatus as i, authDataDelete as j, authFieldLoadTree as k, loadRoleAuthChecked as l, authButtonLoadTree as m, saveAuthButton as n, authDataLoadTree as o, saveAuthData as p, saveAuthField as s };

package/auth.data.js

@@ -0,0 +1,144 @@
+import { computed } from "vue";
+const authFieldColumns = [
+  {
+    title: "\u542F\u7528",
+    dataIndex: "switch",
+    width: 80,
+    align: "center",
+    slots: { customRender: "switch" }
+  },
+  {
+    title: "\u5B57\u6BB5\u540D\u79F0",
+    width: 200,
+    dataIndex: "code"
+  },
+  {
+    title: "\u5B57\u6BB5\u63CF\u8FF0",
+    dataIndex: "title"
+  },
+  {
+    title: "\u5217\u8868\u63A7\u5236",
+    dataIndex: "list",
+    width: 120,
+    slots: { customRender: "list" }
+  },
+  {
+    title: "\u8868\u5355\u63A7\u5236",
+    dataIndex: "form",
+    width: 180,
+    slots: { customRender: "form" }
+  }
+];
+const authButtonColumns = [
+  {
+    title: "\u542F\u7528",
+    dataIndex: "switch",
+    width: 80,
+    slots: { customRender: "switch" }
+  },
+  {
+    title: "\u540D\u79F0",
+    dataIndex: "title"
+  },
+  {
+    title: "\u7F16\u7801",
+    dataIndex: "code"
+  },
+  {
+    title: "\u6743\u9650\u63A7\u5236",
+    dataIndex: "control",
+    width: 180,
+    slots: { customRender: "control" }
+  }
+];
+const authButtonFixedList = [
+  { code: "add", title: "\u65B0\u589E", status: 0 },
+  { code: "update", title: "\u7F16\u8F91", status: 0 },
+  { code: "delete", title: "\u5220\u9664", status: 0 },
+  { code: "batch_delete", title: "\u6279\u91CF\u5220\u9664", status: 0 },
+  { code: "export", title: "\u5BFC\u51FA", status: 0 },
+  { code: "import", title: "\u5BFC\u5165", status: 0 },
+  { code: "bpm", title: "\u63D0\u4EA4\u6D41\u7A0B", status: 0 },
+  { code: "super_query", title: "\u9AD8\u7EA7\u67E5\u8BE2", status: 0 }
+];
+const USE_SQL_RULES = "USE_SQL_RULES";
+const authDataColumns = [
+  {
+    title: "\u542F\u7528",
+    dataIndex: "switch",
+    width: 80,
+    slots: { customRender: "switch" }
+  },
+  {
+    title: "\u89C4\u5219\u540D\u79F0",
+    dataIndex: "ruleName",
+    width: 130
+  },
+  {
+    title: "\u89C4\u5219\u63CF\u8FF0",
+    dataIndex: "description",
+    customRender({ record: { ruleOperator, ruleValue, ruleColumn } }) {
+      if (ruleOperator == USE_SQL_RULES) {
+        return `\u81EA\u5B9A\u4E49SQL: ${ruleValue}`;
+      } else {
+        return `${ruleColumn} ${ruleOperator} ${ruleValue}`;
+      }
+    }
+  }
+];
+function useAuthDataFormSchemas(props, methods) {
+  const formSchemas = computed(() => [
+    {
+      label: "\u89C4\u5219\u540D\u79F0",
+      field: "ruleName",
+      required: true,
+      component: "Input"
+    },
+    {
+      label: "\u89C4\u5219\u5B57\u6BB5",
+      field: "ruleColumn",
+      component: "JSearchSelect",
+      componentProps: {
+        dictOptions: props.authFields,
+        getPopupContainer: () => document.body
+      },
+      dynamicRules({ model }) {
+        return [
+          { required: model.ruleOperator != USE_SQL_RULES, message: "\u8BF7\u8F93\u5165\u89C4\u5219\u5B57\u6BB5" }
+        ];
+      },
+      show: ({ model }) => model.ruleOperator != USE_SQL_RULES
+    },
+    {
+      label: "\u6761\u4EF6\u89C4\u5219",
+      field: "ruleOperator",
+      required: true,
+      component: "JDictSelectTag",
+      componentProps: {
+        dictCode: "rule_conditions",
+        onChange: methods.onRuleOperatorChange
+      }
+    },
+    {
+      label: "\u89C4\u5219\u503C",
+      field: "ruleValue",
+      required: true,
+      component: "Input"
+    },
+    {
+      label: "\u72B6\u6001",
+      field: "status",
+      required: true,
+      component: "RadioButtonGroup",
+      componentProps: {
+        options: [
+          { label: "\u6709\u6548", value: 1 },
+          { label: "\u65E0\u6548", value: 0 }
+        ]
+      },
+      defaultValue: 1
+    }
+  ]);
+  return { formSchemas };
+}
+export { USE_SQL_RULES as U, authFieldColumns as a, authButtonColumns as b, authButtonFixedList as c, authDataColumns as d, useAuthDataFormSchemas as u };