orion-design 0.1.20 → 0.1.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -5
- package/dist/components/Form/NumberInput/NumberInput.d.ts +19 -0
- package/dist/components/Form/NumberInput/NumberInput.js +2 -0
- package/dist/components/Form/NumberInput/NumberInput.js.map +1 -0
- package/dist/components/Form/NumberInput/NumberInput.vue.d.ts +3 -0
- package/dist/components/Form/NumberInput/index.d.ts +1 -0
- package/dist/components/Form/NumberInput/index.js +2 -0
- package/dist/components/Form/NumberInput/index.js.map +1 -0
- package/dist/components/Form/index.d.ts +3 -0
- package/dist/components/Form/index.js +320 -245
- package/dist/components/Form/index.js.map +1 -1
- package/dist/components/LovTable/LovPagetable.vue.d.ts +20 -2
- package/dist/components/LovTable/LovQuerytable.vue.d.ts +20 -2
- package/dist/components/LovTable/index.d.ts +20 -2
- package/dist/components/Pagetable/Pagetable.d.ts +4 -1
- package/dist/components/Pagetable/index.d.ts +4 -1
- package/dist/components/Pagetable/index.js +258 -243
- package/dist/components/Pagetable/index.js.map +1 -1
- package/dist/components/Querytable/Querytable.d.ts +4 -1
- package/dist/components/Querytable/index.d.ts +4 -1
- package/dist/components/Querytable/index.js +166 -151
- package/dist/components/Querytable/index.js.map +1 -1
- package/dist/components/_util/arrays.js.map +1 -1
- package/dist/components/_util/browser.js.map +1 -1
- package/dist/components/_util/dom/aria.js.map +1 -1
- package/dist/components/_util/dom/element.js.map +1 -1
- package/dist/components/_util/dom/event.js.map +1 -1
- package/dist/components/_util/dom/position.js.map +1 -1
- package/dist/components/_util/dom/scroll.js.map +1 -1
- package/dist/components/_util/dom/style.js.map +1 -1
- package/dist/components/_util/easings.js.map +1 -1
- package/dist/components/_util/error.js.map +1 -1
- package/dist/components/_util/i18n.js.map +1 -1
- package/dist/components/_util/objects.js.map +1 -1
- package/dist/components/_util/raf.js.map +1 -1
- package/dist/components/_util/rand.js.map +1 -1
- package/dist/components/_util/strings.js.map +1 -1
- package/dist/components/_util/throttleByRaf.js.map +1 -1
- package/dist/components/_util/types.js.map +1 -1
- package/dist/components/_util/typescript.js.map +1 -1
- package/dist/components/_util/vue/global-node.js.map +1 -1
- package/dist/components/_util/vue/icon.js.map +1 -1
- package/dist/components/_util/vue/install.js.map +1 -1
- package/dist/components/_util/vue/props/runtime.js.map +1 -1
- package/dist/components/_util/vue/refs.js.map +1 -1
- package/dist/components/_util/vue/size.js.map +1 -1
- package/dist/components/_util/vue/validator.js.map +1 -1
- package/dist/components/_util/vue/vnode.js.map +1 -1
- package/dist/version/version.d.ts +1 -1
- package/dist/version/version.js +1 -1
- package/dist/version/version.js.map +1 -1
- package/package.json +1 -1
| @@ -1,36 +1,36 @@ | |
| 1 1 | 
             
            import "lodash-es";
         | 
| 2 | 
            -
            import { defineComponent as C, ref as W, computed as X, createVNode as o, createTextVNode as Z, isVNode as  | 
| 2 | 
            +
            import { defineComponent as C, ref as W, computed as X, createVNode as o, createTextVNode as Z, isVNode as P } from "vue";
         | 
| 3 3 | 
             
            import { withInstall as ee } from "../_util/vue/install.js";
         | 
| 4 4 | 
             
            import { ElTable as te, ElTableColumn as w, ElButton as re } from "element-plus";
         | 
| 5 | 
            -
            import  | 
| 6 | 
            -
            import { arrayType as  | 
| 7 | 
            -
            import { number2string as  | 
| 8 | 
            -
            import  | 
| 5 | 
            +
            import le from "../_util/classNames.js";
         | 
| 6 | 
            +
            import { arrayType as ne, booleanType as v, stringType as r, someType as c, numberType as oe } from "../_util/type.js";
         | 
| 7 | 
            +
            import { number2string as ae, formatDate as k, getSingleCodeContent as N, getMultiCodeContent as q } from "./utils/index.js";
         | 
| 8 | 
            +
            import se from "dayjs";
         | 
| 9 9 | 
             
            import { S as ue } from "../../index-BbsXWo7C.js";
         | 
| 10 10 | 
             
            import ie from "../../error/OrionError.js";
         | 
| 11 | 
            -
            import  | 
| 12 | 
            -
            import  | 
| 13 | 
            -
            function  | 
| 14 | 
            -
              return typeof  | 
| 11 | 
            +
            import ce from "./hooks/useColumns.js";
         | 
| 12 | 
            +
            import M from "../../Throne/index.js";
         | 
| 13 | 
            +
            function de(l) {
         | 
| 14 | 
            +
              return typeof l == "function" || Object.prototype.toString.call(l) === "[object Object]" && !P(l);
         | 
| 15 15 | 
             
            }
         | 
| 16 16 | 
             
            const pe = () => ({
         | 
| 17 | 
            -
              data:  | 
| 18 | 
            -
              showRowNumber:  | 
| 19 | 
            -
              selectionMode:  | 
| 20 | 
            -
              currentRowMode:  | 
| 17 | 
            +
              data: ne(),
         | 
| 18 | 
            +
              showRowNumber: v(!0),
         | 
| 19 | 
            +
              selectionMode: v(!1),
         | 
| 20 | 
            +
              currentRowMode: v(!1),
         | 
| 21 21 | 
             
              size: r()
         | 
| 22 22 | 
             
            }), me = /* @__PURE__ */ C({
         | 
| 23 23 | 
             
              name: "OQuerytable",
         | 
| 24 24 | 
             
              inheritAttrs: !1,
         | 
| 25 25 | 
             
              props: pe(),
         | 
| 26 | 
            -
              emits: ["selectionChange", "currentRowChange", "rowClick"],
         | 
| 27 | 
            -
              setup( | 
| 28 | 
            -
                slots:  | 
| 26 | 
            +
              emits: ["selectionChange", "currentRowChange", "rowClick", "rowDblclick", "cellClick", "cellDblclick"],
         | 
| 27 | 
            +
              setup(l, {
         | 
| 28 | 
            +
                slots: p,
         | 
| 29 29 | 
             
                attrs: y,
         | 
| 30 | 
            -
                emit:  | 
| 30 | 
            +
                emit: i,
         | 
| 31 31 | 
             
                expose: b
         | 
| 32 32 | 
             
              }) {
         | 
| 33 | 
            -
                const S = W(), B = X(() => ({})),  | 
| 33 | 
            +
                const S = W(), B = X(() => ({})), D = ce(p);
         | 
| 34 34 | 
             
                return b({
         | 
| 35 35 | 
             
                  clearSelection: () => {
         | 
| 36 36 | 
             
                    S.value.clearSelection();
         | 
| @@ -43,15 +43,15 @@ const pe = () => ({ | |
| 43 43 | 
             
                }), () => {
         | 
| 44 44 | 
             
                  const {
         | 
| 45 45 | 
             
                    data: Q
         | 
| 46 | 
            -
                  } =  | 
| 47 | 
            -
                    selectionMode:  | 
| 48 | 
            -
                  } =  | 
| 46 | 
            +
                  } = l, {
         | 
| 47 | 
            +
                    selectionMode: j = !1
         | 
| 48 | 
            +
                  } = l, {
         | 
| 49 49 | 
             
                    showRowNumber: I = !0
         | 
| 50 | 
            -
                  } =  | 
| 50 | 
            +
                  } = l, {
         | 
| 51 51 | 
             
                    currentRowMode: V = !1
         | 
| 52 | 
            -
                  } =  | 
| 52 | 
            +
                  } = l, {
         | 
| 53 53 | 
             
                    size: $ = "default"
         | 
| 54 | 
            -
                  } =  | 
| 54 | 
            +
                  } = l, z = le("orion-querytable"), E = () => o(w, {
         | 
| 55 55 | 
             
                    type: "index",
         | 
| 56 56 | 
             
                    label: "No",
         | 
| 57 57 | 
             
                    width: 56,
         | 
| @@ -65,14 +65,14 @@ const pe = () => ({ | |
| 65 65 | 
             
                  }, null), F = (t) => {
         | 
| 66 66 | 
             
                    const {
         | 
| 67 67 | 
             
                      name: e,
         | 
| 68 | 
            -
                      head:  | 
| 69 | 
            -
                      headAlign:  | 
| 68 | 
            +
                      head: n,
         | 
| 69 | 
            +
                      headAlign: s,
         | 
| 70 70 | 
             
                      width: m,
         | 
| 71 71 | 
             
                      fixed: h
         | 
| 72 72 | 
             
                    } = t;
         | 
| 73 73 | 
             
                    return o(w, {
         | 
| 74 | 
            -
                      label:  | 
| 75 | 
            -
                      headerAlign:  | 
| 74 | 
            +
                      label: n,
         | 
| 75 | 
            +
                      headerAlign: s,
         | 
| 76 76 | 
             
                      prop: e,
         | 
| 77 77 | 
             
                      width: m,
         | 
| 78 78 | 
             
                      fixed: h,
         | 
| @@ -81,18 +81,18 @@ const pe = () => ({ | |
| 81 81 | 
             
                  }, H = (t) => {
         | 
| 82 82 | 
             
                    const {
         | 
| 83 83 | 
             
                      name: e,
         | 
| 84 | 
            -
                      head:  | 
| 85 | 
            -
                      headAlign:  | 
| 84 | 
            +
                      head: n,
         | 
| 85 | 
            +
                      headAlign: s,
         | 
| 86 86 | 
             
                      width: m,
         | 
| 87 87 | 
             
                      fixed: h
         | 
| 88 88 | 
             
                    } = t, {
         | 
| 89 | 
            -
                      thousandsSeparator:  | 
| 89 | 
            +
                      thousandsSeparator: a = !0,
         | 
| 90 90 | 
             
                      precision: d = -1,
         | 
| 91 | 
            -
                      percentage:  | 
| 91 | 
            +
                      percentage: u = !1
         | 
| 92 92 | 
             
                    } = t;
         | 
| 93 93 | 
             
                    return o(w, {
         | 
| 94 | 
            -
                      label:  | 
| 95 | 
            -
                      headerAlign:  | 
| 94 | 
            +
                      label: n,
         | 
| 95 | 
            +
                      headerAlign: s,
         | 
| 96 96 | 
             
                      align: "right",
         | 
| 97 97 | 
             
                      prop: e,
         | 
| 98 98 | 
             
                      width: m,
         | 
| @@ -106,48 +106,48 @@ const pe = () => ({ | |
| 106 106 | 
             
                        } = f;
         | 
| 107 107 | 
             
                        return o("span", {
         | 
| 108 108 | 
             
                          class: "cell-numbercolumn"
         | 
| 109 | 
            -
                        }, [ | 
| 109 | 
            +
                        }, [ae(x[g.property], a, d, u === !0 || u === "")]);
         | 
| 110 110 | 
             
                      }
         | 
| 111 111 | 
             
                    });
         | 
| 112 112 | 
             
                  }, _ = (t) => {
         | 
| 113 113 | 
             
                    const {
         | 
| 114 114 | 
             
                      name: e,
         | 
| 115 | 
            -
                      head:  | 
| 116 | 
            -
                      headAlign:  | 
| 115 | 
            +
                      head: n,
         | 
| 116 | 
            +
                      headAlign: s,
         | 
| 117 117 | 
             
                      width: m,
         | 
| 118 118 | 
             
                      fixed: h,
         | 
| 119 | 
            -
                      sourceFormat:  | 
| 119 | 
            +
                      sourceFormat: a,
         | 
| 120 120 | 
             
                      format: d = "YYYYMMDDHHmmss"
         | 
| 121 121 | 
             
                    } = t;
         | 
| 122 122 | 
             
                    return o(w, {
         | 
| 123 | 
            -
                      label:  | 
| 124 | 
            -
                      headerAlign:  | 
| 123 | 
            +
                      label: n,
         | 
| 124 | 
            +
                      headerAlign: s,
         | 
| 125 125 | 
             
                      prop: e,
         | 
| 126 126 | 
             
                      width: m,
         | 
| 127 127 | 
             
                      fixed: h,
         | 
| 128 128 | 
             
                      showOverflowTooltip: !0
         | 
| 129 129 | 
             
                    }, {
         | 
| 130 | 
            -
                      default: ( | 
| 130 | 
            +
                      default: (u) => {
         | 
| 131 131 | 
             
                        const {
         | 
| 132 132 | 
             
                          row: f,
         | 
| 133 133 | 
             
                          column: x
         | 
| 134 | 
            -
                        } =  | 
| 135 | 
            -
                        return g instanceof Date ||  | 
| 134 | 
            +
                        } = u, g = f[x.property];
         | 
| 135 | 
            +
                        return g instanceof Date || se.isDayjs(g) ? o("div", null, [k(g, d)]) : a && d ? o("div", null, [k(g, a, d)]) : o("div", null, [g]);
         | 
| 136 136 | 
             
                      }
         | 
| 137 137 | 
             
                    });
         | 
| 138 138 | 
             
                  }, G = (t) => {
         | 
| 139 139 | 
             
                    const {
         | 
| 140 140 | 
             
                      name: e,
         | 
| 141 | 
            -
                      head:  | 
| 142 | 
            -
                      headAlign:  | 
| 141 | 
            +
                      head: n,
         | 
| 142 | 
            +
                      headAlign: s,
         | 
| 143 143 | 
             
                      width: m,
         | 
| 144 144 | 
             
                      fixed: h
         | 
| 145 145 | 
             
                    } = t, {
         | 
| 146 | 
            -
                      code:  | 
| 146 | 
            +
                      code: a
         | 
| 147 147 | 
             
                    } = t;
         | 
| 148 148 | 
             
                    return o(w, {
         | 
| 149 | 
            -
                      label:  | 
| 150 | 
            -
                      headerAlign:  | 
| 149 | 
            +
                      label: n,
         | 
| 150 | 
            +
                      headerAlign: s,
         | 
| 151 151 | 
             
                      prop: e,
         | 
| 152 152 | 
             
                      width: m,
         | 
| 153 153 | 
             
                      fixed: h,
         | 
| @@ -155,11 +155,11 @@ const pe = () => ({ | |
| 155 155 | 
             
                    }, {
         | 
| 156 156 | 
             
                      default: (d) => {
         | 
| 157 157 | 
             
                        const {
         | 
| 158 | 
            -
                          row:  | 
| 158 | 
            +
                          row: u,
         | 
| 159 159 | 
             
                          column: f
         | 
| 160 | 
            -
                        } = d, x =  | 
| 160 | 
            +
                        } = d, x = u[f.property];
         | 
| 161 161 | 
             
                        let g, A, O;
         | 
| 162 | 
            -
                        return  | 
| 162 | 
            +
                        return a ? typeof a == "string" ? (g = a, A = M.getCode(g), O = N(A.value, x)) : (A = a, O = N(A, x)) : O = null, o("span", {
         | 
| 163 163 | 
             
                          class: "cell-singleselect"
         | 
| 164 164 | 
             
                        }, [O]);
         | 
| 165 165 | 
             
                      }
         | 
| @@ -167,16 +167,16 @@ const pe = () => ({ | |
| 167 167 | 
             
                  }, J = (t) => {
         | 
| 168 168 | 
             
                    const {
         | 
| 169 169 | 
             
                      name: e,
         | 
| 170 | 
            -
                      head:  | 
| 171 | 
            -
                      headAlign:  | 
| 170 | 
            +
                      head: n,
         | 
| 171 | 
            +
                      headAlign: s,
         | 
| 172 172 | 
             
                      width: m,
         | 
| 173 173 | 
             
                      fixed: h
         | 
| 174 174 | 
             
                    } = t, {
         | 
| 175 | 
            -
                      code:  | 
| 175 | 
            +
                      code: a
         | 
| 176 176 | 
             
                    } = t;
         | 
| 177 177 | 
             
                    return o(w, {
         | 
| 178 | 
            -
                      label:  | 
| 179 | 
            -
                      headerAlign:  | 
| 178 | 
            +
                      label: n,
         | 
| 179 | 
            +
                      headerAlign: s,
         | 
| 180 180 | 
             
                      prop: e,
         | 
| 181 181 | 
             
                      width: m,
         | 
| 182 182 | 
             
                      fixed: h,
         | 
| @@ -184,11 +184,11 @@ const pe = () => ({ | |
| 184 184 | 
             
                    }, {
         | 
| 185 185 | 
             
                      default: (d) => {
         | 
| 186 186 | 
             
                        const {
         | 
| 187 | 
            -
                          row:  | 
| 187 | 
            +
                          row: u,
         | 
| 188 188 | 
             
                          column: f
         | 
| 189 | 
            -
                        } = d, x =  | 
| 189 | 
            +
                        } = d, x = u[f.property];
         | 
| 190 190 | 
             
                        let g, A, O;
         | 
| 191 | 
            -
                        return  | 
| 191 | 
            +
                        return a ? typeof a == "string" ? (g = a, A = M.getCode(g), O = q(A.value, x)) : (A = a, O = q(A, x)) : O = null, o("span", {
         | 
| 192 192 | 
             
                          class: "cell-multiselect"
         | 
| 193 193 | 
             
                        }, [O]);
         | 
| 194 194 | 
             
                      }
         | 
| @@ -196,28 +196,28 @@ const pe = () => ({ | |
| 196 196 | 
             
                  }, K = (t) => {
         | 
| 197 197 | 
             
                    const {
         | 
| 198 198 | 
             
                      name: e,
         | 
| 199 | 
            -
                      head:  | 
| 200 | 
            -
                      headAlign:  | 
| 199 | 
            +
                      head: n,
         | 
| 200 | 
            +
                      headAlign: s,
         | 
| 201 201 | 
             
                      width: m,
         | 
| 202 202 | 
             
                      fixed: h
         | 
| 203 203 | 
             
                    } = t;
         | 
| 204 204 | 
             
                    return o(w, {
         | 
| 205 | 
            -
                      label:  | 
| 206 | 
            -
                      headerAlign:  | 
| 205 | 
            +
                      label: n,
         | 
| 206 | 
            +
                      headerAlign: s,
         | 
| 207 207 | 
             
                      prop: e,
         | 
| 208 208 | 
             
                      width: m,
         | 
| 209 209 | 
             
                      fixed: h
         | 
| 210 210 | 
             
                    }, {
         | 
| 211 | 
            -
                      default: ( | 
| 212 | 
            -
                        var  | 
| 213 | 
            -
                        const d = (f = ( | 
| 214 | 
            -
                          rowData:  | 
| 211 | 
            +
                      default: (a) => {
         | 
| 212 | 
            +
                        var u, f;
         | 
| 213 | 
            +
                        const d = (f = (u = t.children) == null ? void 0 : u.default) == null ? void 0 : f.call(u, {
         | 
| 214 | 
            +
                          rowData: a.row,
         | 
| 215 215 | 
             
                          column: t,
         | 
| 216 | 
            -
                          rowIndex:  | 
| 216 | 
            +
                          rowIndex: a.$index
         | 
| 217 217 | 
             
                        });
         | 
| 218 218 | 
             
                        return o("div", {
         | 
| 219 219 | 
             
                          class: "cell-buttongroup"
         | 
| 220 | 
            -
                        }, [o(ue, null,  | 
| 220 | 
            +
                        }, [o(ue, null, de(d) ? d : {
         | 
| 221 221 | 
             
                          default: () => [d]
         | 
| 222 222 | 
             
                        })]);
         | 
| 223 223 | 
             
                      }
         | 
| @@ -225,37 +225,37 @@ const pe = () => ({ | |
| 225 225 | 
             
                  }, L = (t) => {
         | 
| 226 226 | 
             
                    const {
         | 
| 227 227 | 
             
                      head: e,
         | 
| 228 | 
            -
                      headAlign:  | 
| 228 | 
            +
                      headAlign: n
         | 
| 229 229 | 
             
                    } = t, {
         | 
| 230 | 
            -
                      children:  | 
| 230 | 
            +
                      children: s
         | 
| 231 231 | 
             
                    } = t;
         | 
| 232 232 | 
             
                    return o(w, {
         | 
| 233 233 | 
             
                      label: e,
         | 
| 234 | 
            -
                      headerAlign:  | 
| 234 | 
            +
                      headerAlign: n
         | 
| 235 235 | 
             
                    }, {
         | 
| 236 | 
            -
                      default: (m) => R( | 
| 236 | 
            +
                      default: (m) => R(s)
         | 
| 237 237 | 
             
                    });
         | 
| 238 238 | 
             
                  }, U = (t) => {
         | 
| 239 239 | 
             
                    const {
         | 
| 240 240 | 
             
                      name: e,
         | 
| 241 | 
            -
                      head:  | 
| 242 | 
            -
                      headAlign:  | 
| 241 | 
            +
                      head: n,
         | 
| 242 | 
            +
                      headAlign: s,
         | 
| 243 243 | 
             
                      width: m,
         | 
| 244 244 | 
             
                      fixed: h
         | 
| 245 245 | 
             
                    } = t;
         | 
| 246 246 | 
             
                    return o(w, {
         | 
| 247 | 
            -
                      label:  | 
| 248 | 
            -
                      headerAlign:  | 
| 247 | 
            +
                      label: n,
         | 
| 248 | 
            +
                      headerAlign: s,
         | 
| 249 249 | 
             
                      prop: e,
         | 
| 250 250 | 
             
                      width: m,
         | 
| 251 251 | 
             
                      fixed: h
         | 
| 252 252 | 
             
                    }, {
         | 
| 253 | 
            -
                      default: ( | 
| 254 | 
            -
                        var  | 
| 255 | 
            -
                        const d = (f = ( | 
| 256 | 
            -
                          rowData:  | 
| 253 | 
            +
                      default: (a) => {
         | 
| 254 | 
            +
                        var u, f;
         | 
| 255 | 
            +
                        const d = (f = (u = t.children) == null ? void 0 : u.default) == null ? void 0 : f.call(u, {
         | 
| 256 | 
            +
                          rowData: a.row,
         | 
| 257 257 | 
             
                          column: t,
         | 
| 258 | 
            -
                          rowIndex:  | 
| 258 | 
            +
                          rowIndex: a.$index
         | 
| 259 259 | 
             
                        });
         | 
| 260 260 | 
             
                        return o("div", {
         | 
| 261 261 | 
             
                          class: "cell-diy"
         | 
| @@ -292,13 +292,28 @@ const pe = () => ({ | |
| 292 292 | 
             
                    style: {
         | 
| 293 293 | 
             
                      width: "100%"
         | 
| 294 294 | 
             
                    },
         | 
| 295 | 
            -
                    "onSelection-change": (t) =>  | 
| 295 | 
            +
                    "onSelection-change": (t) => i("selectionChange", t),
         | 
| 296 296 | 
             
                    "highlight-current-row": V,
         | 
| 297 | 
            -
                    "onCurrent-change": (t, e) =>  | 
| 298 | 
            -
                    "onRow-click": (t, e,  | 
| 297 | 
            +
                    "onCurrent-change": (t, e) => i("currentRowChange", t, e),
         | 
| 298 | 
            +
                    "onRow-click": (t, e, n) => i("rowClick", t, {
         | 
| 299 | 
            +
                      name: e.property,
         | 
| 300 | 
            +
                      head: e.label
         | 
| 301 | 
            +
                    }, n),
         | 
| 302 | 
            +
                    "onRow-dblclick": (t, e, n) => i("rowDblclick", t, {
         | 
| 303 | 
            +
                      name: e.property,
         | 
| 304 | 
            +
                      head: e.label
         | 
| 305 | 
            +
                    }, n),
         | 
| 306 | 
            +
                    "onCell-click": (t, e, n, s) => i("cellClick", t, {
         | 
| 307 | 
            +
                      name: e.property,
         | 
| 308 | 
            +
                      head: e.label
         | 
| 309 | 
            +
                    }, n, s),
         | 
| 310 | 
            +
                    "onCell-dblclick": (t, e, n, s) => i("cellDblclick", t, {
         | 
| 311 | 
            +
                      name: e.property,
         | 
| 312 | 
            +
                      head: e.label
         | 
| 313 | 
            +
                    }, n, s),
         | 
| 299 314 | 
             
                    size: $
         | 
| 300 315 | 
             
                  }, {
         | 
| 301 | 
            -
                    default: () => [I && E(),  | 
| 316 | 
            +
                    default: () => [I && E(), j && Y(), R(D.value)]
         | 
| 302 317 | 
             
                  })]);
         | 
| 303 318 | 
             
                };
         | 
| 304 319 | 
             
              }
         | 
| @@ -306,10 +321,10 @@ const pe = () => ({ | |
| 306 321 | 
             
              name: "OQuerytableColumnIndex",
         | 
| 307 322 | 
             
              inheritAttrs: !1,
         | 
| 308 323 | 
             
              props: he(),
         | 
| 309 | 
            -
              setup( | 
| 310 | 
            -
                slots:  | 
| 324 | 
            +
              setup(l, {
         | 
| 325 | 
            +
                slots: p,
         | 
| 311 326 | 
             
                attrs: y,
         | 
| 312 | 
            -
                emit:  | 
| 327 | 
            +
                emit: i,
         | 
| 313 328 | 
             
                expose: b
         | 
| 314 329 | 
             
              }) {
         | 
| 315 330 | 
             
                return () => null;
         | 
| @@ -318,16 +333,16 @@ const pe = () => ({ | |
| 318 333 | 
             
              head: r(),
         | 
| 319 334 | 
             
              headAlign: r(),
         | 
| 320 335 | 
             
              name: r(),
         | 
| 321 | 
            -
              width:  | 
| 322 | 
            -
              fixed:  | 
| 336 | 
            +
              width: c([Boolean, String]),
         | 
| 337 | 
            +
              fixed: c([Boolean, String])
         | 
| 323 338 | 
             
            }), ye = /* @__PURE__ */ C({
         | 
| 324 339 | 
             
              name: "OQuerytableColumnString",
         | 
| 325 340 | 
             
              inheritAttrs: !1,
         | 
| 326 341 | 
             
              props: ge(),
         | 
| 327 | 
            -
              setup( | 
| 328 | 
            -
                slots:  | 
| 342 | 
            +
              setup(l, {
         | 
| 343 | 
            +
                slots: p,
         | 
| 329 344 | 
             
                attrs: y,
         | 
| 330 | 
            -
                emit:  | 
| 345 | 
            +
                emit: i,
         | 
| 331 346 | 
             
                expose: b
         | 
| 332 347 | 
             
              }) {
         | 
| 333 348 | 
             
                return () => null;
         | 
| @@ -336,19 +351,19 @@ const pe = () => ({ | |
| 336 351 | 
             
              head: r(),
         | 
| 337 352 | 
             
              headAlign: r(),
         | 
| 338 353 | 
             
              name: r(),
         | 
| 339 | 
            -
              width:  | 
| 340 | 
            -
              fixed:  | 
| 341 | 
            -
              thousandsSeparator:  | 
| 342 | 
            -
              precision:  | 
| 343 | 
            -
              percentage:  | 
| 354 | 
            +
              width: c([Boolean, String]),
         | 
| 355 | 
            +
              fixed: c([Boolean, String]),
         | 
| 356 | 
            +
              thousandsSeparator: v(!0),
         | 
| 357 | 
            +
              precision: oe(-1),
         | 
| 358 | 
            +
              percentage: v(!1)
         | 
| 344 359 | 
             
            }), Ce = /* @__PURE__ */ C({
         | 
| 345 360 | 
             
              name: "OQuerytableColumnNumber",
         | 
| 346 361 | 
             
              inheritAttrs: !1,
         | 
| 347 362 | 
             
              props: be(),
         | 
| 348 | 
            -
              setup( | 
| 349 | 
            -
                slots:  | 
| 363 | 
            +
              setup(l, {
         | 
| 364 | 
            +
                slots: p,
         | 
| 350 365 | 
             
                attrs: y,
         | 
| 351 | 
            -
                emit:  | 
| 366 | 
            +
                emit: i,
         | 
| 352 367 | 
             
                expose: b
         | 
| 353 368 | 
             
              }) {
         | 
| 354 369 | 
             
                return () => null;
         | 
| @@ -357,8 +372,8 @@ const pe = () => ({ | |
| 357 372 | 
             
              head: r(),
         | 
| 358 373 | 
             
              headAlign: r(),
         | 
| 359 374 | 
             
              name: r(),
         | 
| 360 | 
            -
              width:  | 
| 361 | 
            -
              fixed:  | 
| 375 | 
            +
              width: c([Boolean, String]),
         | 
| 376 | 
            +
              fixed: c([Boolean, String]),
         | 
| 362 377 | 
             
              // Date
         | 
| 363 378 | 
             
              format: r(),
         | 
| 364 379 | 
             
              sourceFormat: r()
         | 
| @@ -366,10 +381,10 @@ const pe = () => ({ | |
| 366 381 | 
             
              name: "OQuerytableColumnDate",
         | 
| 367 382 | 
             
              inheritAttrs: !1,
         | 
| 368 383 | 
             
              props: we(),
         | 
| 369 | 
            -
              setup( | 
| 370 | 
            -
                slots:  | 
| 384 | 
            +
              setup(l, {
         | 
| 385 | 
            +
                slots: p,
         | 
| 371 386 | 
             
                attrs: y,
         | 
| 372 | 
            -
                emit:  | 
| 387 | 
            +
                emit: i,
         | 
| 373 388 | 
             
                expose: b
         | 
| 374 389 | 
             
              }) {
         | 
| 375 390 | 
             
                return () => null;
         | 
| @@ -378,17 +393,17 @@ const pe = () => ({ | |
| 378 393 | 
             
              head: r(),
         | 
| 379 394 | 
             
              headAlign: r(),
         | 
| 380 395 | 
             
              name: r(),
         | 
| 381 | 
            -
              width:  | 
| 382 | 
            -
              fixed:  | 
| 383 | 
            -
              code:  | 
| 396 | 
            +
              width: c([Boolean, String]),
         | 
| 397 | 
            +
              fixed: c([Boolean, String]),
         | 
| 398 | 
            +
              code: c([String, Array])
         | 
| 384 399 | 
             
            }), Ae = /* @__PURE__ */ C({
         | 
| 385 400 | 
             
              name: "OQuerytableColumnSingleselect",
         | 
| 386 401 | 
             
              inheritAttrs: !1,
         | 
| 387 402 | 
             
              props: xe(),
         | 
| 388 | 
            -
              setup( | 
| 389 | 
            -
                slots:  | 
| 403 | 
            +
              setup(l, {
         | 
| 404 | 
            +
                slots: p,
         | 
| 390 405 | 
             
                attrs: y,
         | 
| 391 | 
            -
                emit:  | 
| 406 | 
            +
                emit: i,
         | 
| 392 407 | 
             
                expose: b
         | 
| 393 408 | 
             
              }) {
         | 
| 394 409 | 
             
                return () => null;
         | 
| @@ -397,17 +412,17 @@ const pe = () => ({ | |
| 397 412 | 
             
              head: r(),
         | 
| 398 413 | 
             
              headAlign: r(),
         | 
| 399 414 | 
             
              name: r(),
         | 
| 400 | 
            -
              width:  | 
| 401 | 
            -
              fixed:  | 
| 402 | 
            -
              code:  | 
| 415 | 
            +
              width: c([Boolean, String]),
         | 
| 416 | 
            +
              fixed: c([Boolean, String]),
         | 
| 417 | 
            +
              code: c([String, Array])
         | 
| 403 418 | 
             
            }), Qe = /* @__PURE__ */ C({
         | 
| 404 419 | 
             
              name: "OQuerytableColumnMultiselect",
         | 
| 405 420 | 
             
              inheritAttrs: !1,
         | 
| 406 421 | 
             
              props: Oe(),
         | 
| 407 | 
            -
              setup( | 
| 408 | 
            -
                slots:  | 
| 422 | 
            +
              setup(l, {
         | 
| 423 | 
            +
                slots: p,
         | 
| 409 424 | 
             
                attrs: y,
         | 
| 410 | 
            -
                emit:  | 
| 425 | 
            +
                emit: i,
         | 
| 411 426 | 
             
                expose: b
         | 
| 412 427 | 
             
              }) {
         | 
| 413 428 | 
             
                return () => null;
         | 
| @@ -416,24 +431,24 @@ const pe = () => ({ | |
| 416 431 | 
             
              head: r(),
         | 
| 417 432 | 
             
              headAlign: r(),
         | 
| 418 433 | 
             
              name: r(),
         | 
| 419 | 
            -
              width:  | 
| 420 | 
            -
              fixed:  | 
| 421 | 
            -
            }),  | 
| 434 | 
            +
              width: c([Boolean, String]),
         | 
| 435 | 
            +
              fixed: c([Boolean, String])
         | 
| 436 | 
            +
            }), De = /* @__PURE__ */ C({
         | 
| 422 437 | 
             
              name: "OQuerytableColumnButtongroup",
         | 
| 423 438 | 
             
              inheritAttrs: !1,
         | 
| 424 439 | 
             
              props: Be(),
         | 
| 425 440 | 
             
              slots: Object,
         | 
| 426 | 
            -
              setup( | 
| 427 | 
            -
                slots:  | 
| 441 | 
            +
              setup(l, {
         | 
| 442 | 
            +
                slots: p,
         | 
| 428 443 | 
             
                attrs: y,
         | 
| 429 | 
            -
                emit:  | 
| 444 | 
            +
                emit: i,
         | 
| 430 445 | 
             
                expose: b
         | 
| 431 446 | 
             
              }) {
         | 
| 432 447 | 
             
                return () => null;
         | 
| 433 448 | 
             
              }
         | 
| 434 449 | 
             
            });
         | 
| 435 | 
            -
            function  | 
| 436 | 
            -
              return typeof  | 
| 450 | 
            +
            function ve(l) {
         | 
| 451 | 
            +
              return typeof l == "function" || Object.prototype.toString.call(l) === "[object Object]" && !P(l);
         | 
| 437 452 | 
             
            }
         | 
| 438 453 | 
             
            const Te = () => ({
         | 
| 439 454 | 
             
              type: r()
         | 
| @@ -442,60 +457,60 @@ const Te = () => ({ | |
| 442 457 | 
             
              inheritAttrs: !1,
         | 
| 443 458 | 
             
              props: Te(),
         | 
| 444 459 | 
             
              emits: ["click"],
         | 
| 445 | 
            -
              setup( | 
| 446 | 
            -
                slots:  | 
| 460 | 
            +
              setup(l, {
         | 
| 461 | 
            +
                slots: p,
         | 
| 447 462 | 
             
                attrs: y,
         | 
| 448 | 
            -
                emit:  | 
| 463 | 
            +
                emit: i,
         | 
| 449 464 | 
             
                expose: b
         | 
| 450 465 | 
             
              }) {
         | 
| 451 466 | 
             
                const S = (B) => {
         | 
| 452 | 
            -
                   | 
| 467 | 
            +
                  i("click", B);
         | 
| 453 468 | 
             
                };
         | 
| 454 469 | 
             
                return () => {
         | 
| 455 470 | 
             
                  var T;
         | 
| 456 471 | 
             
                  const {
         | 
| 457 472 | 
             
                    type: B
         | 
| 458 | 
            -
                  } =  | 
| 473 | 
            +
                  } = l, D = (T = p.default) == null ? void 0 : T.call(p);
         | 
| 459 474 | 
             
                  return o(re, {
         | 
| 460 475 | 
             
                    link: !0,
         | 
| 461 476 | 
             
                    type: B,
         | 
| 462 477 | 
             
                    size: "small",
         | 
| 463 478 | 
             
                    onClick: S
         | 
| 464 | 
            -
                  },  | 
| 465 | 
            -
                    default: () => [ | 
| 479 | 
            +
                  }, ve(D) ? D : {
         | 
| 480 | 
            +
                    default: () => [D]
         | 
| 466 481 | 
             
                  });
         | 
| 467 482 | 
             
                };
         | 
| 468 483 | 
             
              }
         | 
| 469 | 
            -
            }),  | 
| 484 | 
            +
            }), ke = () => ({
         | 
| 470 485 | 
             
              head: r(),
         | 
| 471 486 | 
             
              headAlign: r()
         | 
| 472 | 
            -
            }),  | 
| 487 | 
            +
            }), Ne = /* @__PURE__ */ C({
         | 
| 473 488 | 
             
              name: "OQuerytableColumngroup",
         | 
| 474 489 | 
             
              inheritAttrs: !1,
         | 
| 475 | 
            -
              props:  | 
| 476 | 
            -
              setup( | 
| 477 | 
            -
                slots:  | 
| 490 | 
            +
              props: ke(),
         | 
| 491 | 
            +
              setup(l, {
         | 
| 492 | 
            +
                slots: p,
         | 
| 478 493 | 
             
                attrs: y,
         | 
| 479 | 
            -
                emit:  | 
| 494 | 
            +
                emit: i,
         | 
| 480 495 | 
             
                expose: b
         | 
| 481 496 | 
             
              }) {
         | 
| 482 497 | 
             
                return () => null;
         | 
| 483 498 | 
             
              }
         | 
| 484 | 
            -
            }),  | 
| 499 | 
            +
            }), qe = () => ({
         | 
| 485 500 | 
             
              head: r(),
         | 
| 486 501 | 
             
              headAlign: r(),
         | 
| 487 502 | 
             
              name: r(),
         | 
| 488 | 
            -
              width:  | 
| 489 | 
            -
              fixed:  | 
| 490 | 
            -
            }),  | 
| 503 | 
            +
              width: c([Boolean, String]),
         | 
| 504 | 
            +
              fixed: c([Boolean, String])
         | 
| 505 | 
            +
            }), Me = /* @__PURE__ */ C({
         | 
| 491 506 | 
             
              name: "OQuerytableColumnDiy",
         | 
| 492 507 | 
             
              inheritAttrs: !1,
         | 
| 493 | 
            -
              props:  | 
| 508 | 
            +
              props: qe(),
         | 
| 494 509 | 
             
              slots: Object,
         | 
| 495 | 
            -
              setup( | 
| 496 | 
            -
                slots:  | 
| 510 | 
            +
              setup(l, {
         | 
| 511 | 
            +
                slots: p,
         | 
| 497 512 | 
             
                attrs: y,
         | 
| 498 | 
            -
                emit:  | 
| 513 | 
            +
                emit: i,
         | 
| 499 514 | 
             
                expose: b
         | 
| 500 515 | 
             
              }) {
         | 
| 501 516 | 
             
                return () => null;
         | 
| @@ -507,10 +522,10 @@ const Te = () => ({ | |
| 507 522 | 
             
              QuerytableColumnDate: Se,
         | 
| 508 523 | 
             
              QuerytableColumnSingleselect: Ae,
         | 
| 509 524 | 
             
              QuerytableColumnMultiselect: Qe,
         | 
| 510 | 
            -
              QuerytableColumnButtongroup:  | 
| 525 | 
            +
              QuerytableColumnButtongroup: De,
         | 
| 511 526 | 
             
              QuerytableCellButton: Re,
         | 
| 512 | 
            -
              QuerytableColumngroup:  | 
| 513 | 
            -
              QuerytableColumnDiy:  | 
| 527 | 
            +
              QuerytableColumngroup: Ne,
         | 
| 528 | 
            +
              QuerytableColumnDiy: Me
         | 
| 514 529 | 
             
            });
         | 
| 515 530 | 
             
            export {
         | 
| 516 531 | 
             
              Xe as default
         |