@gct-paas/excel 0.1.0

package/dist/text-style-DUtxGMF_.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: "text-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/throttle-Cpk1LoGk-BE-DFShS.js

@@ -0,0 +1,226 @@
+import { g as getScrollDimension } from "./viewport.helpers-CoCAvmZs-D_JddDC6.js";
+import { a6 as isObject, l as debounce } from "./index-CfpMuCWW.js";
+const initialParams = {
+  contentSize: 0,
+  clientSize: 0,
+  virtualSize: 0,
+  maxSize: 0
+};
+const NO_COORDINATE = -1;
+function getContentSize(contentSize, clientSize, virtualSize = 0) {
+  return getScrollDimension({
+    contentSize,
+    clientSize,
+    virtualSize
+  }).physicalContentSize;
+}
+class LocalScrollService {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.preventArtificialScroll = {
+      rgRow: null,
+      rgCol: null
+    };
+    this.previousScroll = {
+      rgRow: NO_COORDINATE,
+      rgCol: NO_COORDINATE
+    };
+    this.previousLogicalScroll = {
+      rgRow: 0,
+      rgCol: 0
+    };
+    this.params = {
+      rgRow: Object.assign({}, initialParams),
+      rgCol: Object.assign({}, initialParams)
+    };
+  }
+  setParams(params, dimension) {
+    const scrollDimension = getScrollDimension(params);
+    const virtualContentSize = scrollDimension.physicalContentSize;
+    this.params[dimension] = Object.assign(Object.assign({}, params), {
+      maxSize: virtualContentSize - params.clientSize,
+      virtualContentSize,
+      scrollDimension
+    });
+  }
+  // apply scroll values after scroll done
+  async setScroll(e) {
+    this.cancelScroll(e.dimension);
+    const frameAnimation = new Promise((resolve, reject) => {
+      if (this.cfg.skipAnimationFrame) {
+        return resolve();
+      }
+      const animationId = window.requestAnimationFrame(() => {
+        resolve();
+      });
+      this.preventArtificialScroll[e.dimension] = reject.bind(null, animationId);
+    });
+    try {
+      await frameAnimation;
+      const params = this.getParams(e.dimension);
+      e.coordinate = Math.ceil(e.coordinate);
+      this.previousLogicalScroll[e.dimension] = this.wrapLogicalCoordinate(e.coordinate, params);
+      const physicalCoordinate = this.toPhysicalCoordinate(e.coordinate, params);
+      this.previousScroll[e.dimension] = this.wrapPhysicalCoordinate(physicalCoordinate, params);
+      this.preventArtificialScroll[e.dimension] = null;
+      this.cfg.applyScroll(Object.assign(Object.assign({}, e), { coordinate: physicalCoordinate }));
+    } catch (id) {
+      window.cancelAnimationFrame(id);
+    }
+  }
+  async setScrollByDelta(e, currentPhysicalCoordinate) {
+    var _a;
+    const params = this.getParams(e.dimension);
+    const baseCoordinate = this.previousScroll[e.dimension] === NO_COORDINATE ? this.toLogicalCoordinate(currentPhysicalCoordinate, params) : this.previousLogicalScroll[e.dimension];
+    const coordinate = this.wrapLogicalCoordinate(baseCoordinate + ((_a = e.delta) !== null && _a !== void 0 ? _a : 0), params);
+    const nextEvent = Object.assign(Object.assign({}, e), { coordinate });
+    await this.setScroll(nextEvent);
+    return nextEvent;
+  }
+  /**
+   * On scroll event started
+   */
+  scroll(coordinate, dimension, force = false, delta, outside = false) {
+    this.cancelScroll(dimension);
+    if (!force && this.previousScroll[dimension] === coordinate) {
+      this.previousScroll[dimension] = NO_COORDINATE;
+      return;
+    }
+    const param = this.getParams(dimension);
+    const logicalCoordinate = this.toLogicalScrollCoordinate(coordinate, dimension, param, delta);
+    this.cfg.runScroll({
+      dimension,
+      coordinate: logicalCoordinate,
+      delta,
+      outside
+    });
+    this.previousLogicalScroll[dimension] = logicalCoordinate;
+  }
+  getParams(dimension) {
+    return this.params[dimension];
+  }
+  // check if scroll outside of region to avoid looping
+  wrapPhysicalCoordinate(c, param) {
+    if (c < 0) {
+      return NO_COORDINATE;
+    }
+    if (typeof param.maxSize === "number" && c > param.maxSize) {
+      return param.maxSize;
+    }
+    return c;
+  }
+  wrapLogicalCoordinate(c, param) {
+    var _a, _b;
+    if (c < 0) {
+      return 0;
+    }
+    return Math.min(c, (_b = (_a = param.scrollDimension) === null || _a === void 0 ? void 0 : _a.logicalScrollSize) !== null && _b !== void 0 ? _b : c);
+  }
+  // prevent already started scroll, performance optimization
+  cancelScroll(dimension) {
+    var _a, _b;
+    (_b = (_a = this.preventArtificialScroll)[dimension]) === null || _b === void 0 ? void 0 : _b.call(_a);
+    this.preventArtificialScroll[dimension] = null;
+  }
+  toLogicalScrollCoordinate(coordinate, dimension, param, delta) {
+    const scrollDimension = param.scrollDimension;
+    if (!scrollDimension) {
+      return coordinate;
+    }
+    if (typeof delta === "number" && scrollDimension.isCompressed) {
+      const base = this.previousScroll[dimension] === NO_COORDINATE ? scrollDimension.toLogicalCoordinate(coordinate - delta) : this.previousLogicalScroll[dimension];
+      return scrollDimension.toLogicalCoordinate(scrollDimension.toPhysicalCoordinate(base + delta));
+    }
+    return scrollDimension.toLogicalCoordinate(coordinate);
+  }
+  toPhysicalCoordinate(coordinate, param) {
+    var _a, _b;
+    return (_b = (_a = param.scrollDimension) === null || _a === void 0 ? void 0 : _a.toPhysicalCoordinate(coordinate)) !== null && _b !== void 0 ? _b : coordinate;
+  }
+  toLogicalCoordinate(coordinate, param) {
+    var _a, _b;
+    return (_b = (_a = param.scrollDimension) === null || _a === void 0 ? void 0 : _a.toLogicalCoordinate(coordinate)) !== null && _b !== void 0 ? _b : coordinate;
+  }
+}
+class LocalScrollTimer {
+  constructor(scrollThrottling = 10) {
+    this.scrollThrottling = scrollThrottling;
+    this.mouseWheelScrollTimestamp = {
+      rgCol: 0,
+      rgRow: 0
+    };
+    this.lastKnownScrollCoordinate = {
+      rgCol: 0,
+      rgRow: 0
+    };
+    this.lastScrollUpdateCallbacks = {};
+  }
+  setCoordinate(e) {
+    this.lastKnownScrollCoordinate[e.dimension] = e.coordinate;
+  }
+  setCoordinateFromScroll(e) {
+    this.setCoordinate(e);
+    this.mouseWheelScrollTimestamp[e.dimension] = 0;
+  }
+  /**
+   * Remember last mw event time
+   */
+  latestScrollUpdate(dimension) {
+    this.mouseWheelScrollTimestamp[dimension] = (/* @__PURE__ */ new Date()).getTime();
+  }
+  isReady(type, coordinate) {
+    if (this.lastScrollUpdateCallbacks[type]) {
+      this.clearLastScrollUpdate(type);
+    }
+    return this.verifyChange(type, coordinate);
+  }
+  verifyChange(type, coordinate) {
+    const now = (/* @__PURE__ */ new Date()).getTime();
+    const change = now - this.mouseWheelScrollTimestamp[type];
+    return change > this.scrollThrottling && coordinate !== this.lastKnownScrollCoordinate[type];
+  }
+  clearLastScrollUpdate(type) {
+    var _a, _b;
+    clearTimeout((_b = (_a = this.lastScrollUpdateCallbacks[type]) === null || _a === void 0 ? void 0 : _a.timeout) !== null && _b !== void 0 ? _b : 0);
+    delete this.lastScrollUpdateCallbacks[type];
+  }
+  throttleLastScrollUpdate(type, coordinate, lastScrollUpdate) {
+    if (this.scrollThrottling) {
+      this.clearLastScrollUpdate(type);
+      const callback = this.lastScrollUpdateCallbacks[type] = {
+        callback: lastScrollUpdate,
+        timestamp: (/* @__PURE__ */ new Date()).getTime(),
+        coordinate,
+        timeout: 0
+      };
+      callback.timeout = setTimeout(() => {
+        this.clearLastScrollUpdate(type);
+        if (this.mouseWheelScrollTimestamp[type] < callback.timestamp && this.verifyChange(type, callback.coordinate)) {
+          callback.callback();
+        }
+      }, this.scrollThrottling + 50);
+    }
+  }
+}
+var FUNC_ERROR_TEXT = "Expected a function";
+function throttle(func, wait, options) {
+  var leading = true, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  if (isObject(options)) {
+    leading = "leading" in options ? !!options.leading : leading;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  return debounce(func, wait, {
+    "leading": leading,
+    "maxWait": wait,
+    "trailing": trailing
+  });
+}
+export {
+  LocalScrollTimer as L,
+  LocalScrollService as a,
+  getContentSize as g,
+  throttle as t
+};

package/dist/timediff-design-Bh2KjAqU.js

@@ -0,0 +1,16 @@
+import { defineComponent, openBlock, createElementBlock, toDisplayString, unref } from "vue";
+import { TimeDiffFormat } from "@gct-paas/excel-base";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "timediff-design",
+  props: {
+    widget: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", null, toDisplayString(_ctx.$t(`sys.onlineForm.timeDiffFormat.${__props.widget.format || unref(TimeDiffFormat).D_H_MIN_S}`)), 1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/trace-design-BfkLkVEr.js

@@ -0,0 +1,54 @@
+import { defineComponent, computed, resolveComponent, openBlock, createElementBlock, createBlock, unref } from "vue";
+import dayjs from "dayjs";
+import { _ as _export_sfc } from "./uuid-CvPXRkky.js";
+import { C as CellWidgetRenderComp } from "./index-XHxr4hJa.js";
+import { F as FIELD_TYPE } from "./Scrollbar-Bl_rv9eK.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "trace-design",
+  props: {
+    disabled: { type: Boolean },
+    fieldWidget: {},
+    fieldMeta: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const isTraceDate = computed(() => props.fieldMeta.fieldType === FIELD_TYPE.TRACE_DATE);
+    const defaultValue = computed(() => {
+      if (props.fieldWidget.defaultSystemDate) {
+        return dayjs();
+      }
+      return void 0;
+    });
+    return (_ctx, _cache) => {
+      const _component_a_date_picker = resolveComponent("a-date-picker");
+      const _component_a_input = resolveComponent("a-input");
+      const _component_a_textarea = resolveComponent("a-textarea");
+      return openBlock(), createElementBlock("div", null, [
+        isTraceDate.value ? (openBlock(), createBlock(_component_a_date_picker, {
+          key: 0,
+          value: defaultValue.value,
+          class: "w-full",
+          format: __props.fieldWidget.format,
+          placeholder: __props.fieldWidget.placeholder,
+          disabled: __props.disabled
+        }, null, 8, ["value", "format", "placeholder", "disabled"])) : __props.fieldWidget.renderComp === unref(CellWidgetRenderComp).Input ? (openBlock(), createBlock(_component_a_input, {
+          key: 1,
+          disabled: __props.disabled,
+          placeholder: __props.fieldWidget.placeholder,
+          value: __props.fieldWidget.defaultValue,
+          size: "small"
+        }, null, 8, ["disabled", "placeholder", "value"])) : (openBlock(), createBlock(_component_a_textarea, {
+          key: 2,
+          class: "cell-text-design-textarea-warp",
+          disabled: __props.disabled,
+          placeholder: __props.fieldWidget.placeholder,
+          value: __props.fieldWidget.defaultValue
+        }, null, 8, ["disabled", "placeholder", "value"]))
+      ]);
+    };
+  }
+});
+const traceDesign = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a9206828"]]);
+export {
+  traceDesign as default
+};

package/dist/trace-props-BGy27o42.js

@@ -0,0 +1,228 @@
+import { defineComponent, computed, ref, watch, onMounted, resolveComponent, openBlock, createElementBlock, Fragment, createBlock, withCtx, createVNode, createCommentVNode, createElementVNode, toDisplayString, unref, createTextVNode } from "vue";
+import { c as useSpreadSheet, d as useReverseModeling, F as FormItem, u as useModelFields } from "./index-XHxr4hJa.js";
+import { D as DateFormatEditor } from "./date-format-editor-dKlZ1BtF.js";
+import { _ as _sfc_main$1, R as RefAutofillEditor } from "./ref-autofill-editor-BrhHeEgk.js";
+import "./uuid-CvPXRkky.js";
+import { AddRuleBtn } from "@gct-paas/excel-web-render";
+import { F as FIELD_TYPE } from "./Scrollbar-Bl_rv9eK.js";
+const _hoisted_1 = { class: "mt-4px" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "trace-props",
+  props: {
+    fieldMeta: {},
+    widget: {},
+    fieldType: {},
+    readonly: { type: Boolean },
+    disabled: { type: Boolean }
+  },
+  setup(__props) {
+    const refRecordNoOptions = [
+      {
+        label: $t("sys.onlineForm.uniqueIdentifier"),
+        value: 0
+      },
+      {
+        label: $t("sys.onlineForm.linkIdentifier"),
+        value: 1
+      }
+    ];
+    const { getFieldMeta } = useModelFields();
+    const { isEasyEdition } = useSpreadSheet();
+    const { setFieldRefRecordNo, isStashedField } = useReverseModeling();
+    const props = __props;
+    const options = computed(() => {
+      const isSubModel = props.fieldMeta.subModelKey && props.fieldMeta.subFieldKey;
+      return refRecordNoOptions?.map((item) => {
+        return {
+          ...item,
+          disabled: isSubModel && item.value === 0 ? true : false
+        };
+      });
+    });
+    const formState = computed({
+      get() {
+        return props.widget;
+      },
+      set(v) {
+        Object.assign(props.widget, v);
+      }
+    });
+    const autofillRules = computed({
+      get() {
+        return formState.value.autofillRules ?? [];
+      },
+      set(v) {
+        formState.value.autofillRules = v;
+      }
+    });
+    const enableAutofill = computed({
+      get() {
+        return formState.value.enableAutofill;
+      },
+      set(v) {
+        formState.value.enableAutofill = v;
+      }
+    });
+    const isTraceDate = computed(() => props.fieldType === FIELD_TYPE.TRACE_DATE);
+    const isRecordNo = computed(() => props.fieldType === FIELD_TYPE.RECORD_NO);
+    const isDevice = computed(() => props.fieldType === FIELD_TYPE.DEVICE);
+    const fixedFieldType = computed(() => FIELD_TYPE.DATE);
+    const isRefType = computed(() => {
+      const bizType = props.fieldMeta.bizType;
+      if (bizType && [FIELD_TYPE.E_SOP].includes(bizType)) {
+        return true;
+      }
+      return [FIELD_TYPE.PRODUCT, FIELD_TYPE.DEVICE, FIELD_TYPE.MFG_ORDER].includes(props.fieldType);
+    });
+    const showParseRule = computed(
+      () => [FIELD_TYPE.PRODUCT, FIELD_TYPE.DEVICE].includes(props.fieldType)
+    );
+    const canEditDigits = computed(() => {
+      return isEasyEdition.value && isStashedField({ key: props.fieldMeta.field, modelKey: props.fieldMeta.model });
+    });
+    const _refRecordNo = ref(void 0);
+    const getInitialRefRecordNo = () => {
+      const fieldInfo = getFieldMeta(props.fieldMeta);
+      const isSubModel = props.fieldMeta.subModelKey && props.fieldMeta.subFieldKey;
+      const initRefRecordNo = isSubModel ? 1 : 0;
+      return fieldInfo?.specificConfig?.refRecordNo ?? initRefRecordNo;
+    };
+    watch(
+      () => props.fieldMeta,
+      () => {
+        _refRecordNo.value = void 0;
+      },
+      { immediate: true }
+    );
+    const refRecordNo = computed({
+      get() {
+        const initialValue = getInitialRefRecordNo();
+        return canEditDigits.value ? _refRecordNo.value ?? initialValue : initialValue;
+      },
+      set(val) {
+        _refRecordNo.value = val;
+      }
+    });
+    const onChange = () => {
+      setFieldRefRecordNo({
+        modelKey: props.fieldMeta.model,
+        fieldKey: props.fieldMeta.field,
+        refRecordNo: _refRecordNo.value
+      });
+      console.log("onChange", _refRecordNo.value);
+    };
+    const fillDefaultSearchField = (oldArr = []) => {
+      const set = new Set(["code_.like", "name_.like"].concat(oldArr));
+      return Array.from(set);
+    };
+    onMounted(() => {
+      if (props.fieldType === FIELD_TYPE.DEVICE) {
+        formState.value.searchField = fillDefaultSearchField(formState.value.searchField);
+      }
+    });
+    const onSearchFieldChange = (arr = []) => {
+      formState.value.searchField = fillDefaultSearchField(arr);
+    };
+    return (_ctx, _cache) => {
+      const _component_a_input = resolveComponent("a-input");
+      const _component_a_radio_group = resolveComponent("a-radio-group");
+      const _component_a_checkbox = resolveComponent("a-checkbox");
+      return openBlock(), createElementBlock(Fragment, null, [
+        !__props.readonly ? (openBlock(), createBlock(FormItem, {
+          key: 0,
+          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"])) : createCommentVNode("", true),
+        !__props.readonly && isRecordNo.value ? (openBlock(), createBlock(FormItem, {
+          key: 1,
+          label: _ctx.$t("sys.model.fieldAttr"),
+          inline: false
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_a_radio_group, {
+              value: refRecordNo.value,
+              "onUpdate:value": _cache[1] || (_cache[1] = ($event) => refRecordNo.value = $event),
+              options: options.value,
+              disabled: __props.disabled || !canEditDigits.value,
+              onChange
+            }, null, 8, ["value", "options", "disabled"]),
+            createElementVNode("div", _hoisted_1, toDisplayString(refRecordNo.value === 0 ? _ctx.$t("sys.onlineForm.traceFieldErrorTip1") : _ctx.$t("sys.onlineForm.traceFieldErrorTip2")), 1)
+          ]),
+          _: 1
+        }, 8, ["label"])) : createCommentVNode("", true),
+        showParseRule.value ? (openBlock(), createBlock(FormItem, {
+          key: 2,
+          inline: false,
+          label: _ctx.$t("sys.edhr.mcTable.parseRule"),
+          class: "justify-between"
+        }, {
+          default: withCtx(() => [
+            createVNode(unref(AddRuleBtn), {
+              modelValue: formState.value.parseRuleProps,
+              "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => formState.value.parseRuleProps = $event),
+              subModelKey: __props.fieldMeta.subModelKey
+            }, null, 8, ["modelValue", "subModelKey"])
+          ]),
+          _: 1
+        }, 8, ["label"])) : createCommentVNode("", true),
+        isDevice.value ? (openBlock(), createBlock(_sfc_main$1, {
+          key: 3,
+          fieldMeta: __props.fieldMeta,
+          disabled: __props.disabled,
+          "search-field": formState.value.searchField,
+          "onUpdate:searchField": onSearchFieldChange
+        }, null, 8, ["fieldMeta", "disabled", "search-field"])) : createCommentVNode("", true),
+        isTraceDate.value ? (openBlock(), createBlock(DateFormatEditor, {
+          key: 4,
+          widget: props.widget,
+          "field-type": fixedFieldType.value,
+          disabled: __props.disabled
+        }, null, 8, ["widget", "field-type", "disabled"])) : createCommentVNode("", true),
+        isTraceDate.value && !__props.readonly ? (openBlock(), createBlock(FormItem, {
+          key: 5,
+          label: `${_ctx.$t("sys.defaultValue")}`,
+          inline: false
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_a_checkbox, {
+              checked: formState.value.defaultSystemDate,
+              "onUpdate:checked": _cache[3] || (_cache[3] = ($event) => formState.value.defaultSystemDate = $event),
+              disabled: __props.disabled
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(`${_ctx.$t("sys.component.fieldTypeProps.defaultSysDate")}`), 1)
+              ]),
+              _: 1
+            }, 8, ["checked", "disabled"])
+          ]),
+          _: 1
+        }, 8, ["label"])) : createCommentVNode("", true),
+        isRefType.value ? (openBlock(), createBlock(RefAutofillEditor, {
+          key: 6,
+          fieldMeta: __props.fieldMeta,
+          disabled: __props.disabled,
+          "autofill-rules": autofillRules.value,
+          "onUpdate:autofillRules": _cache[4] || (_cache[4] = ($event) => autofillRules.value = $event),
+          "enable-autofill": enableAutofill.value,
+          "onUpdate:enableAutofill": _cache[5] || (_cache[5] = ($event) => enableAutofill.value = $event)
+        }, null, 8, ["fieldMeta", "disabled", "autofill-rules", "enable-autofill"])) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/trace-style-DjlUSE3I.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: "trace-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/user-design-BRIV937X.js

@@ -0,0 +1,24 @@
+import { defineComponent, resolveComponent, openBlock, createElementBlock, createVNode, normalizeStyle } from "vue";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "user-design",
+  props: {
+    disabled: { type: Boolean },
+    fieldWidget: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      const _component_a_select = resolveComponent("a-select");
+      return openBlock(), createElementBlock("div", null, [
+        createVNode(_component_a_select, {
+          disabled: __props.disabled,
+          style: normalizeStyle({ width: `${__props.fieldWidget.compWidth ?? 75}px` }),
+          placeholder: __props.fieldWidget.placeholder,
+          size: "small"
+        }, null, 8, ["disabled", "style", "placeholder"])
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};