@gct-paas/excel 0.1.0

package/dist/user-props-QOHxGObK.js

@@ -0,0 +1,93 @@
+import { defineComponent, ref, computed, resolveComponent, openBlock, createBlock, withCtx, createVNode, unref, createTextVNode, toDisplayString } from "vue";
+import { F as FormItem } from "./index-XHxr4hJa.js";
+import { FieldSysVarDefaultValueEnum } from "@gct-paas/excel-base";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "user-props",
+  props: {
+    widget: {},
+    disabled: { type: Boolean }
+  },
+  setup(__props) {
+    const formRef = ref(null);
+    const props = __props;
+    const formState = computed({
+      get() {
+        return props.widget;
+      },
+      set(v) {
+        Object.assign(props.widget, v);
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_a_input = resolveComponent("a-input");
+      const _component_a_select_option = resolveComponent("a-select-option");
+      const _component_a_select = resolveComponent("a-select");
+      const _component_a_form = resolveComponent("a-form");
+      return openBlock(), createBlock(_component_a_form, {
+        ref_key: "formRef",
+        ref: formRef,
+        model: formState.value
+      }, {
+        default: withCtx(() => [
+          createVNode(FormItem, {
+            label: `${_ctx.$t("sys.pageDesigner.fieldPlaceholder")}`,
+            inline: false
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_a_input, {
+                size: "small",
+                value: formState.value.placeholder,
+                "onUpdate:value": _cache[0] || (_cache[0] = ($event) => formState.value.placeholder = $event),
+                placeholder: _ctx.$t("sys.inputText"),
+                disabled: __props.disabled,
+                "show-count": "",
+                maxlength: 32
+              }, null, 8, ["value", "placeholder", "disabled"])
+            ]),
+            _: 1
+          }, 8, ["label"]),
+          createVNode(FormItem, {
+            label: `${_ctx.$t("sys.defaultValue")}`,
+            name: "defaultValue",
+            inline: false
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_a_select, {
+                size: "small",
+                value: formState.value.defaultValue,
+                "onUpdate:value": _cache[1] || (_cache[1] = ($event) => formState.value.defaultValue = $event),
+                placeholder: _ctx.$t("sys.chooseText"),
+                disabled: __props.disabled
+              }, {
+                default: withCtx(() => [
+                  createVNode(_component_a_select_option, {
+                    value: unref(FieldSysVarDefaultValueEnum).NULL
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(_ctx.$t("sys.none")), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["value"]),
+                  createVNode(_component_a_select_option, {
+                    value: unref(FieldSysVarDefaultValueEnum).CURRENT_USER
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(_ctx.$t("sys.sysCurrentUser")), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["value"])
+                ]),
+                _: 1
+              }, 8, ["value", "placeholder", "disabled"])
+            ]),
+            _: 1
+          }, 8, ["label"])
+        ]),
+        _: 1
+      }, 8, ["model"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/user-style-CvNqToP9.js

@@ -0,0 +1,33 @@
+import { defineComponent, computed, openBlock, createBlock } from "vue";
+import { B as BaseFontEditor } from "./base-font-editor-B5vjmXrI.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "user-style",
+  props: {
+    widget: {},
+    disabled: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const formState = computed({
+      get() {
+        return props.widget;
+      },
+      set(v) {
+        Object.assign(props.widget, v);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(BaseFontEditor, {
+        "font-size": formState.value.fontSize,
+        "onUpdate:fontSize": _cache[0] || (_cache[0] = ($event) => formState.value.fontSize = $event),
+        "letter-space": formState.value.letterSpace,
+        "onUpdate:letterSpace": _cache[1] || (_cache[1] = ($event) => formState.value.letterSpace = $event),
+        "no-letter-space": true,
+        disabled: __props.disabled
+      }, null, 8, ["font-size", "letter-space", "disabled"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/uuid-CvPXRkky.js

@@ -0,0 +1,534 @@
+import { computed, inject, getCurrentInstance, onMounted, nextTick, unref, getCurrentScope, onScopeDispose, watch } from "vue";
+import { isNil, keyBy, pick } from "lodash-es";
+var ASSIGNMENTSTRATEGY_ENUM = /* @__PURE__ */ ((ASSIGNMENTSTRATEGY_ENUM2) => {
+  ASSIGNMENTSTRATEGY_ENUM2["alwaysCover"] = "alwaysCover";
+  ASSIGNMENTSTRATEGY_ENUM2["notCovered"] = "notCovered";
+  return ASSIGNMENTSTRATEGY_ENUM2;
+})(ASSIGNMENTSTRATEGY_ENUM || {});
+var Dependency_ENUM = /* @__PURE__ */ ((Dependency_ENUM2) => {
+  Dependency_ENUM2["HIDDEN"] = "hidden";
+  Dependency_ENUM2["READONLY"] = "readonly";
+  Dependency_ENUM2["DISABLED"] = "disabled";
+  Dependency_ENUM2["REQUIRED"] = "required";
+  Dependency_ENUM2["ASSIGNMENT"] = "assignment";
+  return Dependency_ENUM2;
+})(Dependency_ENUM || {});
+var FormDesignEnum = /* @__PURE__ */ ((FormDesignEnum2) => {
+  FormDesignEnum2["ONLINE_FORM"] = "online_form_module";
+  FormDesignEnum2["EDHR"] = "edhr_module";
+  return FormDesignEnum2;
+})(FormDesignEnum || {});
+var FormulaRuleFieldKeyEnum = /* @__PURE__ */ ((FormulaRuleFieldKeyEnum2) => {
+  FormulaRuleFieldKeyEnum2["INPUT"] = "formulaRuleInput";
+  FormulaRuleFieldKeyEnum2["PARAM1"] = "formulaRuleParam1";
+  FormulaRuleFieldKeyEnum2["PARAM2"] = "formulaRuleParam2";
+  FormulaRuleFieldKeyEnum2["PARAM3"] = "formulaRuleParam3";
+  FormulaRuleFieldKeyEnum2["PARAM4"] = "formulaRuleParam4";
+  FormulaRuleFieldKeyEnum2["PARAM5"] = "formulaRuleParam5";
+  FormulaRuleFieldKeyEnum2["PARAM6"] = "formulaRuleParam6";
+  FormulaRuleFieldKeyEnum2["PARAM7"] = "formulaRuleParam7";
+  FormulaRuleFieldKeyEnum2["PARAM8"] = "formulaRuleParam8";
+  FormulaRuleFieldKeyEnum2["PARAM9"] = "formulaRuleParam9";
+  FormulaRuleFieldKeyEnum2["PARAM10"] = "formulaRuleParam10";
+  return FormulaRuleFieldKeyEnum2;
+})(FormulaRuleFieldKeyEnum || {});
+const formulaRuleFieldI18nKeyMap = {
+  [
+    "formulaRuleInput"
+    /* INPUT */
+  ]: "sys.onlineForm.unitConversion.formulaRuleInput",
+  [
+    "formulaRuleParam1"
+    /* PARAM1 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam1",
+  [
+    "formulaRuleParam2"
+    /* PARAM2 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam2",
+  [
+    "formulaRuleParam3"
+    /* PARAM3 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam3",
+  [
+    "formulaRuleParam4"
+    /* PARAM4 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam4",
+  [
+    "formulaRuleParam5"
+    /* PARAM5 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam5",
+  [
+    "formulaRuleParam6"
+    /* PARAM6 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam6",
+  [
+    "formulaRuleParam7"
+    /* PARAM7 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam7",
+  [
+    "formulaRuleParam8"
+    /* PARAM8 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam8",
+  [
+    "formulaRuleParam9"
+    /* PARAM9 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam9",
+  [
+    "formulaRuleParam10"
+    /* PARAM10 */
+  ]: "sys.onlineForm.unitConversion.formulaRuleParam10"
+};
+const formulaRuleFieldDict = computed(() => {
+  return Object.values(FormulaRuleFieldKeyEnum).reduce(
+    (acc, id) => {
+      acc[id] = $t(formulaRuleFieldI18nKeyMap[id]);
+      return acc;
+    },
+    {}
+  );
+});
+var ExpressionModeEnum = /* @__PURE__ */ ((ExpressionModeEnum2) => {
+  ExpressionModeEnum2[ExpressionModeEnum2["SEARCH"] = 0] = "SEARCH";
+  ExpressionModeEnum2[ExpressionModeEnum2["FIELD_DISPLAY"] = 1] = "FIELD_DISPLAY";
+  ExpressionModeEnum2[ExpressionModeEnum2["EXPORT_TEMPLATE"] = 2] = "EXPORT_TEMPLATE";
+  ExpressionModeEnum2[ExpressionModeEnum2["DISPLAY_RULE"] = 3] = "DISPLAY_RULE";
+  ExpressionModeEnum2[ExpressionModeEnum2["PROCESS_TITLE"] = 4] = "PROCESS_TITLE";
+  ExpressionModeEnum2[ExpressionModeEnum2["GATEWAY_RULE"] = 5] = "GATEWAY_RULE";
+  ExpressionModeEnum2[ExpressionModeEnum2["CREATE_FIELD"] = 6] = "CREATE_FIELD";
+  ExpressionModeEnum2[ExpressionModeEnum2["PAAS_CREATE_FIELD"] = 7] = "PAAS_CREATE_FIELD";
+  ExpressionModeEnum2[ExpressionModeEnum2["ENTITY_FORMULA"] = 8] = "ENTITY_FORMULA";
+  ExpressionModeEnum2[ExpressionModeEnum2["IPAAS_BACK"] = 9] = "IPAAS_BACK";
+  ExpressionModeEnum2[ExpressionModeEnum2["LABEL_PRINT"] = 10] = "LABEL_PRINT";
+  ExpressionModeEnum2[ExpressionModeEnum2["NOCODE_BPMN_RULE"] = 11] = "NOCODE_BPMN_RULE";
+  ExpressionModeEnum2[ExpressionModeEnum2["PAAS_BPMN_RULE"] = 12] = "PAAS_BPMN_RULE";
+  ExpressionModeEnum2[ExpressionModeEnum2["ONLINE_FORM_FIELD_FORMULA"] = 13] = "ONLINE_FORM_FIELD_FORMULA";
+  ExpressionModeEnum2[ExpressionModeEnum2["MEDPRO_BUSINESSFLOW"] = 14] = "MEDPRO_BUSINESSFLOW";
+  ExpressionModeEnum2[ExpressionModeEnum2["RUN_FORMULA"] = 15] = "RUN_FORMULA";
+  ExpressionModeEnum2[ExpressionModeEnum2["BI_FORMULA"] = 16] = "BI_FORMULA";
+  ExpressionModeEnum2[ExpressionModeEnum2["DATA_SET_FORMULA"] = 17] = "DATA_SET_FORMULA";
+  ExpressionModeEnum2[ExpressionModeEnum2["EDHR_LABEL_PRINT"] = 18] = "EDHR_LABEL_PRINT";
+  return ExpressionModeEnum2;
+})(ExpressionModeEnum || {});
+var ExpressionTabEnum = /* @__PURE__ */ ((ExpressionTabEnum2) => {
+  ExpressionTabEnum2["FUNCTION"] = "function";
+  ExpressionTabEnum2["FORM"] = "form";
+  ExpressionTabEnum2["FIELD"] = "field";
+  ExpressionTabEnum2["VARIABLE"] = "variable";
+  ExpressionTabEnum2["NODE"] = "node";
+  ExpressionTabEnum2["OPERATOR"] = "operator";
+  ExpressionTabEnum2["PARAMS"] = "params";
+  return ExpressionTabEnum2;
+})(ExpressionTabEnum || {});
+var ReturnTypeEnum = /* @__PURE__ */ ((ReturnTypeEnum2) => {
+  ReturnTypeEnum2["String"] = "string";
+  ReturnTypeEnum2["Number"] = "number";
+  ReturnTypeEnum2["Boolean"] = "boolean";
+  return ReturnTypeEnum2;
+})(ReturnTypeEnum || {});
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      var isInstance = false;
+      try {
+        isInstance = this instanceof a2;
+      } catch {
+      }
+      if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+function useModal(ok) {
+  const modal = inject("modal");
+  if (modal) {
+    if (ok) {
+      modal.ok = ok;
+    }
+  }
+  return modal;
+}
+const defaultNamespace = "gct";
+const statePrefix = "is-";
+function _bem(namespace, block, blockSuffix, element, modifier) {
+  let cls = `${namespace}-${block}`;
+  if (blockSuffix) {
+    cls += `-${blockSuffix}`;
+  }
+  if (element) {
+    cls += `__${element}`;
+  }
+  if (modifier) {
+    cls += `--${modifier}`;
+  }
+  return cls;
+}
+class Namespace {
+  constructor(block, namespace) {
+    this.block = block;
+    this.namespace = namespace || defaultNamespace;
+  }
+  block;
+  namespace;
+  b(blockSuffix = "") {
+    return _bem(this.namespace, this.block, blockSuffix, "", "");
+  }
+  e(element) {
+    return element ? _bem(this.namespace, this.block, "", element, "") : "";
+  }
+  m(modifier) {
+    return modifier ? _bem(this.namespace, this.block, "", "", modifier) : "";
+  }
+  be(blockSuffix, element) {
+    return blockSuffix && element ? _bem(this.namespace, this.block, blockSuffix, element, "") : "";
+  }
+  em(element, modifier) {
+    return element && modifier ? _bem(this.namespace, this.block, "", element, modifier) : "";
+  }
+  bm(blockSuffix, modifier) {
+    return blockSuffix && modifier ? _bem(this.namespace, this.block, blockSuffix, "", modifier) : "";
+  }
+  bem(blockSuffix, element, modifier) {
+    return blockSuffix && element && modifier ? _bem(this.namespace, this.block, blockSuffix, element, modifier) : "";
+  }
+  is(name, state) {
+    return name && state ? `${statePrefix}${name}` : "";
+  }
+  cssVar(object) {
+    const styles = {};
+    for (const key in object) {
+      if (object[key]) {
+        styles[this.cssVarName(key)] = object[key];
+      }
+    }
+    return styles;
+  }
+  cssVarBlock(object) {
+    const styles = {};
+    for (const key in object) {
+      if (object[key]) {
+        styles[this.cssVarBlockName(key)] = object[key];
+      }
+    }
+    return styles;
+  }
+  cssVarName(name) {
+    return `--${this.namespace}-${name}`;
+  }
+  cssVarBlockName(name) {
+    return `--${this.namespace}-${this.block}-${name}`;
+  }
+}
+function useNamespace(block) {
+  return new Namespace(block, "gct");
+}
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+var _a;
+const isClient = typeof window !== "undefined";
+const isString = (val) => typeof val === "string";
+const noop = () => {
+};
+const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
+};
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = noop;
+  const _clearTimeout = (timer2) => {
+    clearTimeout(timer2);
+    lastRejector();
+    lastRejector = noop;
+  };
+  const filter = (invoke) => {
+    const duration = resolveUnref(ms);
+    const maxDuration = resolveUnref(options.maxWait);
+    if (timer)
+      _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      return Promise.resolve(invoke());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      if (maxDuration && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          if (timer)
+            _clearTimeout(timer);
+          maxTimer = null;
+          resolve(invoke());
+        }, maxDuration);
+      }
+      timer = setTimeout(() => {
+        if (maxTimer)
+          _clearTimeout(maxTimer);
+        maxTimer = null;
+        resolve(invoke());
+      }, duration);
+    });
+  };
+  return filter;
+}
+function throttleFilter(ms, trailing = true, leading = true, rejectOnCancel = false) {
+  let lastExec = 0;
+  let timer;
+  let isLeading = true;
+  let lastRejector = noop;
+  let lastValue;
+  const clear = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+      lastRejector();
+      lastRejector = noop;
+    }
+  };
+  const filter = (_invoke) => {
+    const duration = resolveUnref(ms);
+    const elapsed = Date.now() - lastExec;
+    const invoke = () => {
+      return lastValue = _invoke();
+    };
+    clear();
+    if (duration <= 0) {
+      lastExec = Date.now();
+      return invoke();
+    }
+    if (elapsed > duration && (leading || !isLeading)) {
+      lastExec = Date.now();
+      invoke();
+    } else if (trailing) {
+      lastValue = new Promise((resolve, reject) => {
+        lastRejector = rejectOnCancel ? reject : resolve;
+        timer = setTimeout(() => {
+          lastExec = Date.now();
+          isLeading = true;
+          resolve(invoke());
+          clear();
+        }, Math.max(0, duration - elapsed));
+      });
+    }
+    if (!leading && !timer)
+      timer = setTimeout(() => isLeading = true, duration);
+    isLeading = false;
+    return lastValue;
+  };
+  return filter;
+}
+function identity(arg) {
+  return arg;
+}
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
+  return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
+}
+function tryOnMounted(fn, sync = true) {
+  if (getCurrentInstance())
+    onMounted(fn);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchWithFilter(source, cb, options = {}) {
+  const _a2 = options, {
+    eventFilter = bypassFilter
+  } = _a2, watchOptions = __objRest$5(_a2, [
+    "eventFilter"
+  ]);
+  return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+var __defProp$4 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchDebounced(source, cb, options = {}) {
+  const _a2 = options, {
+    debounce = 0,
+    maxWait = void 0
+  } = _a2, watchOptions = __objRest$3(_a2, [
+    "debounce",
+    "maxWait"
+  ]);
+  return watchWithFilter(source, cb, __spreadProps$4(__spreadValues$4({}, watchOptions), {
+    eventFilter: debounceFilter(debounce, { maxWait })
+  }));
+}
+const uuid2 = (len, radix) => {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
+  let uuid = [], i;
+  radix = radix || chars.length;
+  if (len) {
+    for (i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * radix];
+  } else {
+    let r;
+    uuid[8] = uuid[13] = uuid[18] = uuid[23] = "-";
+    uuid[14] = "4";
+    for (i = 0; i < 36; i++) {
+      if (!uuid[i]) {
+        r = 0 | Math.random() * 16;
+        uuid[i] = chars[i == 19 ? r & 3 | 8 : r];
+      }
+    }
+  }
+  return uuid.join("");
+};
+const normalizeToArray = (val) => Array.isArray(val) ? val.filter((v) => !isNil(v)) : !isNil(val) ? [val] : [];
+const safeParseArray = (str) => {
+  try {
+    if (!str) return [];
+    const v = JSON.parse(str);
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+};
+const mergeByMultiKey = (A, B, {
+  keyFields = ["type", "isCustom"],
+  fieldsToMerge = ["alias", "enable"],
+  isAllowMerge = true,
+  isConcat = false
+} = {}) => {
+  if (!Array.isArray(A)) return [];
+  if (!isAllowMerge || !Array.isArray(B) || B.length === 0) return [...A];
+  if (isConcat && Array.isArray(A) && A.length === 0) return [...B];
+  const keyFn = (item) => keyFields.map((k) => {
+    const v = item?.[k];
+    if (typeof v === "boolean") return String(v);
+    return v == null ? "" : String(v);
+  }).join("::");
+  const bMap = keyBy(B, keyFn);
+  const result = A.map((a) => {
+    const info = bMap[keyFn(a)];
+    return info ? { ...a, ...pick(info, fieldsToMerge) } : { ...a };
+  });
+  return result;
+};
+const getRowId = (row) => {
+  if (!row) return "";
+  if (!isNil(row.id_)) return row.id_;
+  const ROW_UID_KEY = "__gct_rv_uid";
+  if (!row[ROW_UID_KEY]) {
+    row[ROW_UID_KEY] = `r_${Date.now()}_${uuid2(8)}`;
+  }
+  return row[ROW_UID_KEY];
+};
+export {
+  ASSIGNMENTSTRATEGY_ENUM as A,
+  Dependency_ENUM as D,
+  ExpressionModeEnum as E,
+  FormDesignEnum as F,
+  ReturnTypeEnum as R,
+  _export_sfc as _,
+  useNamespace as a,
+  useThrottleFn as b,
+  commonjsGlobal as c,
+  ExpressionTabEnum as d,
+  getAugmentedNamespace as e,
+  FormulaRuleFieldKeyEnum as f,
+  getDefaultExportFromCjs as g,
+  formulaRuleFieldDict as h,
+  isIOS as i,
+  uuid2 as j,
+  normalizeToArray as k,
+  getRowId as l,
+  mergeByMultiKey as m,
+  noop as n,
+  isClient as o,
+  isString as p,
+  tryOnScopeDispose as q,
+  resolveUnref as r,
+  safeParseArray as s,
+  tryOnMounted as t,
+  useModal as u,
+  identity as v,
+  watchDebounced as w
+};