orion-design 0.1.17 → 0.1.18
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/dist/components/Form/FileInput/FileInput.vue.d.ts +1 -1
- package/dist/components/LovTable/LovPagetable.vue.d.ts +28 -0
- package/dist/components/LovTable/LovQuerytable.vue.d.ts +28 -0
- package/dist/components/LovTable/index.d.ts +28 -0
- package/dist/components/LovTable/index.js +22 -20
- package/dist/components/LovTable/index.js.map +1 -1
- package/dist/components/Pagetable/Pagetable.d.ts +13 -0
- package/dist/components/Pagetable/index.d.ts +9 -0
- package/dist/components/Pagetable/index.js +131 -126
- package/dist/components/Pagetable/index.js.map +1 -1
- package/dist/components/Querytable/Querytable.d.ts +13 -0
- package/dist/components/Querytable/index.d.ts +9 -0
- package/dist/components/Querytable/index.js +85 -81
- package/dist/components/Querytable/index.js.map +1 -1
- package/dist/components/RichTextEditor/RichTextEditor.d.ts +13 -0
- package/dist/components/RichTextEditor/index.d.ts +9 -0
- package/dist/components/RichTextEditor/index.js +20761 -0
- package/dist/components/RichTextEditor/index.js.map +1 -0
- package/dist/components/components.d.ts +2 -0
- package/dist/components/components.js +12 -10
- package/dist/components/components.js.map +1 -1
- package/dist/components/index.js +16 -14
- package/dist/components/index.js.map +1 -1
- package/dist/components-Cx2JsH63.js +74 -0
- package/dist/{components-0PErqPHo.js.map → components-Cx2JsH63.js.map} +1 -1
- package/dist/index.css +1 -1
- package/dist/index.js +22 -20
- package/dist/index.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/global.d.ts +2 -0
- package/package.json +3 -1
- package/dist/components-0PErqPHo.js +0 -72
| @@ -1,36 +1,37 @@ | |
| 1 1 | 
             
            import "lodash-es";
         | 
| 2 | 
            -
            import { defineComponent as C, ref as  | 
| 3 | 
            -
            import { withInstall as  | 
| 4 | 
            -
            import { ElTable as  | 
| 5 | 
            -
            import  | 
| 6 | 
            -
            import { arrayType as  | 
| 7 | 
            -
            import { number2string as  | 
| 8 | 
            -
            import  | 
| 9 | 
            -
            import { S as  | 
| 10 | 
            -
            import  | 
| 11 | 
            -
            import  | 
| 2 | 
            +
            import { defineComponent as C, ref as X, computed as Z, createVNode as l, createTextVNode as ee, isVNode as V } from "vue";
         | 
| 3 | 
            +
            import { withInstall as te } from "../_util/vue/install.js";
         | 
| 4 | 
            +
            import { ElTable as ne, ElPagination as oe, ElTableColumn as S, ElButton as le } from "element-plus";
         | 
| 5 | 
            +
            import re from "../_util/classNames.js";
         | 
| 6 | 
            +
            import { arrayType as ae, objectType as se, booleanType as D, stringType as n, someType as i, numberType as ie } from "../_util/type.js";
         | 
| 7 | 
            +
            import { number2string as ue, formatDate as M, getSingleCodeContent as k, getMultiCodeContent as z } from "./utils/index.js";
         | 
| 8 | 
            +
            import pe from "dayjs";
         | 
| 9 | 
            +
            import { S as ce } from "../../index-BbsXWo7C.js";
         | 
| 10 | 
            +
            import de from "../../error/OrionError.js";
         | 
| 11 | 
            +
            import ge from "./hooks/useColumns.js";
         | 
| 12 12 | 
             
            import I from "../../Throne/index.js";
         | 
| 13 | 
            -
            function  | 
| 14 | 
            -
              return typeof  | 
| 13 | 
            +
            function me(o) {
         | 
| 14 | 
            +
              return typeof o == "function" || Object.prototype.toString.call(o) === "[object Object]" && !V(o);
         | 
| 15 15 | 
             
            }
         | 
| 16 | 
            -
            const  | 
| 17 | 
            -
              data:  | 
| 18 | 
            -
              pagination:  | 
| 16 | 
            +
            const he = () => ({
         | 
| 17 | 
            +
              data: ae(),
         | 
| 18 | 
            +
              pagination: se(),
         | 
| 19 19 | 
             
              showRowNumber: D(!0),
         | 
| 20 20 | 
             
              selectionMode: D(!1),
         | 
| 21 | 
            -
              currentRowMode: D(!1)
         | 
| 22 | 
            -
             | 
| 21 | 
            +
              currentRowMode: D(!1),
         | 
| 22 | 
            +
              size: n()
         | 
| 23 | 
            +
            }), fe = /* @__PURE__ */ C({
         | 
| 23 24 | 
             
              name: "OPagetable",
         | 
| 24 25 | 
             
              inheritAttrs: !1,
         | 
| 25 | 
            -
              props:  | 
| 26 | 
            +
              props: he(),
         | 
| 26 27 | 
             
              emits: ["selectionChange", "currentRowChange", "update:pagination", "rowClick"],
         | 
| 27 | 
            -
              setup( | 
| 28 | 
            +
              setup(o, {
         | 
| 28 29 | 
             
                slots: d,
         | 
| 29 30 | 
             
                attrs: b,
         | 
| 30 31 | 
             
                emit: u,
         | 
| 31 32 | 
             
                expose: w
         | 
| 32 33 | 
             
              }) {
         | 
| 33 | 
            -
                const y =  | 
| 34 | 
            +
                const y = X(), B = Z(() => ({})), T = ge(d);
         | 
| 34 35 | 
             
                return w({
         | 
| 35 36 | 
             
                  clearSelection: () => {
         | 
| 36 37 | 
             
                    y.value.clearSelection();
         | 
| @@ -43,26 +44,28 @@ const me = () => ({ | |
| 43 44 | 
             
                }), () => {
         | 
| 44 45 | 
             
                  const {
         | 
| 45 46 | 
             
                    data: O
         | 
| 46 | 
            -
                  } =  | 
| 47 | 
            +
                  } = o, {
         | 
| 47 48 | 
             
                    selectionMode: E = !1
         | 
| 48 | 
            -
                  } =  | 
| 49 | 
            +
                  } = o, {
         | 
| 49 50 | 
             
                    pagination: v
         | 
| 50 | 
            -
                  } =  | 
| 51 | 
            +
                  } = o, {
         | 
| 51 52 | 
             
                    showRowNumber: $ = !0
         | 
| 52 | 
            -
                  } =  | 
| 53 | 
            -
                    currentRowMode:  | 
| 54 | 
            -
                  } =  | 
| 53 | 
            +
                  } = o, {
         | 
| 54 | 
            +
                    currentRowMode: Y = !1
         | 
| 55 | 
            +
                  } = o, {
         | 
| 56 | 
            +
                    size: N = "default"
         | 
| 57 | 
            +
                  } = o, F = re("orion-pagetbale"), H = () => l(S, {
         | 
| 55 58 | 
             
                    type: "index",
         | 
| 56 59 | 
             
                    label: "No",
         | 
| 57 60 | 
             
                    width: 56,
         | 
| 58 61 | 
             
                    fixed: "left",
         | 
| 59 62 | 
             
                    showOverflowTooltip: !0,
         | 
| 60 63 | 
             
                    index: (e) => (v.currentPage - 1) * v.pageSize + e + 1
         | 
| 61 | 
            -
                  }, null),  | 
| 64 | 
            +
                  }, null), _ = () => l(S, {
         | 
| 62 65 | 
             
                    type: "selection",
         | 
| 63 66 | 
             
                    width: 40,
         | 
| 64 67 | 
             
                    fixed: "left"
         | 
| 65 | 
            -
                  }, null),  | 
| 68 | 
            +
                  }, null), U = (e) => {
         | 
| 66 69 | 
             
                    const {
         | 
| 67 70 | 
             
                      name: t,
         | 
| 68 71 | 
             
                      head: s,
         | 
| @@ -70,7 +73,7 @@ const me = () => ({ | |
| 70 73 | 
             
                      width: g,
         | 
| 71 74 | 
             
                      fixed: m
         | 
| 72 75 | 
             
                    } = e;
         | 
| 73 | 
            -
                    return  | 
| 76 | 
            +
                    return l(S, {
         | 
| 74 77 | 
             
                      label: s,
         | 
| 75 78 | 
             
                      headerAlign: p,
         | 
| 76 79 | 
             
                      prop: t,
         | 
| @@ -78,7 +81,7 @@ const me = () => ({ | |
| 78 81 | 
             
                      fixed: m,
         | 
| 79 82 | 
             
                      showOverflowTooltip: !0
         | 
| 80 83 | 
             
                    }, null);
         | 
| 81 | 
            -
                  },  | 
| 84 | 
            +
                  }, q = (e) => {
         | 
| 82 85 | 
             
                    const {
         | 
| 83 86 | 
             
                      name: t,
         | 
| 84 87 | 
             
                      head: s,
         | 
| @@ -90,7 +93,7 @@ const me = () => ({ | |
| 90 93 | 
             
                      precision: c = -1,
         | 
| 91 94 | 
             
                      percentage: a = !1
         | 
| 92 95 | 
             
                    } = e;
         | 
| 93 | 
            -
                    return  | 
| 96 | 
            +
                    return l(S, {
         | 
| 94 97 | 
             
                      label: s,
         | 
| 95 98 | 
             
                      headerAlign: p,
         | 
| 96 99 | 
             
                      align: "right",
         | 
| @@ -104,12 +107,12 @@ const me = () => ({ | |
| 104 107 | 
             
                          row: P,
         | 
| 105 108 | 
             
                          column: f
         | 
| 106 109 | 
             
                        } = h;
         | 
| 107 | 
            -
                        return  | 
| 110 | 
            +
                        return l("span", {
         | 
| 108 111 | 
             
                          class: "cell-numbercolumn"
         | 
| 109 | 
            -
                        }, [ | 
| 112 | 
            +
                        }, [ue(P[f.property], r, c, a === !0 || a === "")]);
         | 
| 110 113 | 
             
                      }
         | 
| 111 114 | 
             
                    });
         | 
| 112 | 
            -
                  },  | 
| 115 | 
            +
                  }, G = (e) => {
         | 
| 113 116 | 
             
                    const {
         | 
| 114 117 | 
             
                      name: t,
         | 
| 115 118 | 
             
                      head: s,
         | 
| @@ -119,7 +122,7 @@ const me = () => ({ | |
| 119 122 | 
             
                      sourceFormat: r,
         | 
| 120 123 | 
             
                      format: c = "YYYYMMDDHHmmss"
         | 
| 121 124 | 
             
                    } = e;
         | 
| 122 | 
            -
                    return  | 
| 125 | 
            +
                    return l(S, {
         | 
| 123 126 | 
             
                      label: s,
         | 
| 124 127 | 
             
                      headerAlign: p,
         | 
| 125 128 | 
             
                      prop: t,
         | 
| @@ -132,10 +135,10 @@ const me = () => ({ | |
| 132 135 | 
             
                          row: h,
         | 
| 133 136 | 
             
                          column: P
         | 
| 134 137 | 
             
                        } = a, f = h[P.property];
         | 
| 135 | 
            -
                        return f instanceof Date ||  | 
| 138 | 
            +
                        return f instanceof Date || pe.isDayjs(f) ? l("div", null, [M(f, c)]) : r && c ? l("div", null, [M(f, r, c)]) : l("div", null, [f]);
         | 
| 136 139 | 
             
                      }
         | 
| 137 140 | 
             
                    });
         | 
| 138 | 
            -
                  },  | 
| 141 | 
            +
                  }, J = (e) => {
         | 
| 139 142 | 
             
                    const {
         | 
| 140 143 | 
             
                      name: t,
         | 
| 141 144 | 
             
                      head: s,
         | 
| @@ -145,7 +148,7 @@ const me = () => ({ | |
| 145 148 | 
             
                    } = e, {
         | 
| 146 149 | 
             
                      code: r
         | 
| 147 150 | 
             
                    } = e;
         | 
| 148 | 
            -
                    return  | 
| 151 | 
            +
                    return l(S, {
         | 
| 149 152 | 
             
                      label: s,
         | 
| 150 153 | 
             
                      headerAlign: p,
         | 
| 151 154 | 
             
                      prop: t,
         | 
| @@ -159,12 +162,12 @@ const me = () => ({ | |
| 159 162 | 
             
                          column: h
         | 
| 160 163 | 
             
                        } = c, P = a[h.property];
         | 
| 161 164 | 
             
                        let f, x, A;
         | 
| 162 | 
            -
                        return r ? typeof r == "string" ? (f = r, x = I.getCode(f), A =  | 
| 165 | 
            +
                        return r ? typeof r == "string" ? (f = r, x = I.getCode(f), A = k(x.value, P)) : (x = r, A = k(x, P)) : A = null, l("span", {
         | 
| 163 166 | 
             
                          class: "cell-singleselect"
         | 
| 164 167 | 
             
                        }, [A]);
         | 
| 165 168 | 
             
                      }
         | 
| 166 169 | 
             
                    });
         | 
| 167 | 
            -
                  },  | 
| 170 | 
            +
                  }, K = (e) => {
         | 
| 168 171 | 
             
                    const {
         | 
| 169 172 | 
             
                      name: t,
         | 
| 170 173 | 
             
                      head: s,
         | 
| @@ -174,7 +177,7 @@ const me = () => ({ | |
| 174 177 | 
             
                    } = e, {
         | 
| 175 178 | 
             
                      code: r
         | 
| 176 179 | 
             
                    } = e;
         | 
| 177 | 
            -
                    return  | 
| 180 | 
            +
                    return l(S, {
         | 
| 178 181 | 
             
                      label: s,
         | 
| 179 182 | 
             
                      headerAlign: p,
         | 
| 180 183 | 
             
                      prop: t,
         | 
| @@ -188,12 +191,12 @@ const me = () => ({ | |
| 188 191 | 
             
                          column: h
         | 
| 189 192 | 
             
                        } = c, P = a[h.property];
         | 
| 190 193 | 
             
                        let f, x, A;
         | 
| 191 | 
            -
                        return r ? typeof r == "string" ? (f = r, x = I.getCode(f), A =  | 
| 194 | 
            +
                        return r ? typeof r == "string" ? (f = r, x = I.getCode(f), A = z(x.value, P)) : (x = r, A = z(x, P)) : A = null, l("span", {
         | 
| 192 195 | 
             
                          class: "cell-multiselect"
         | 
| 193 196 | 
             
                        }, [A]);
         | 
| 194 197 | 
             
                      }
         | 
| 195 198 | 
             
                    });
         | 
| 196 | 
            -
                  },  | 
| 199 | 
            +
                  }, L = (e) => {
         | 
| 197 200 | 
             
                    const {
         | 
| 198 201 | 
             
                      name: t,
         | 
| 199 202 | 
             
                      head: s,
         | 
| @@ -201,7 +204,7 @@ const me = () => ({ | |
| 201 204 | 
             
                      width: g,
         | 
| 202 205 | 
             
                      fixed: m
         | 
| 203 206 | 
             
                    } = e;
         | 
| 204 | 
            -
                    return  | 
| 207 | 
            +
                    return l(S, {
         | 
| 205 208 | 
             
                      label: s,
         | 
| 206 209 | 
             
                      headerAlign: p,
         | 
| 207 210 | 
             
                      prop: t,
         | 
| @@ -215,27 +218,27 @@ const me = () => ({ | |
| 215 218 | 
             
                          column: e,
         | 
| 216 219 | 
             
                          rowIndex: r.$index
         | 
| 217 220 | 
             
                        });
         | 
| 218 | 
            -
                        return  | 
| 221 | 
            +
                        return l("div", {
         | 
| 219 222 | 
             
                          class: "cell-buttongroup"
         | 
| 220 | 
            -
                        }, [ | 
| 223 | 
            +
                        }, [l(ce, null, me(c) ? c : {
         | 
| 221 224 | 
             
                          default: () => [c]
         | 
| 222 225 | 
             
                        })]);
         | 
| 223 226 | 
             
                      }
         | 
| 224 227 | 
             
                    });
         | 
| 225 | 
            -
                  },  | 
| 228 | 
            +
                  }, Q = (e) => {
         | 
| 226 229 | 
             
                    const {
         | 
| 227 230 | 
             
                      head: t,
         | 
| 228 231 | 
             
                      headAlign: s
         | 
| 229 232 | 
             
                    } = e, {
         | 
| 230 233 | 
             
                      children: p
         | 
| 231 234 | 
             
                    } = e;
         | 
| 232 | 
            -
                    return  | 
| 235 | 
            +
                    return l(S, {
         | 
| 233 236 | 
             
                      label: t,
         | 
| 234 237 | 
             
                      headerAlign: s
         | 
| 235 238 | 
             
                    }, {
         | 
| 236 | 
            -
                      default: (g) =>  | 
| 239 | 
            +
                      default: (g) => j(p)
         | 
| 237 240 | 
             
                    });
         | 
| 238 | 
            -
                  },  | 
| 241 | 
            +
                  }, W = (e) => {
         | 
| 239 242 | 
             
                    const {
         | 
| 240 243 | 
             
                      name: t,
         | 
| 241 244 | 
             
                      head: s,
         | 
| @@ -243,7 +246,7 @@ const me = () => ({ | |
| 243 246 | 
             
                      width: g,
         | 
| 244 247 | 
             
                      fixed: m
         | 
| 245 248 | 
             
                    } = e;
         | 
| 246 | 
            -
                    return  | 
| 249 | 
            +
                    return l(S, {
         | 
| 247 250 | 
             
                      label: s,
         | 
| 248 251 | 
             
                      headerAlign: p,
         | 
| 249 252 | 
             
                      prop: t,
         | 
| @@ -257,36 +260,36 @@ const me = () => ({ | |
| 257 260 | 
             
                          column: e,
         | 
| 258 261 | 
             
                          rowIndex: r.$index
         | 
| 259 262 | 
             
                        });
         | 
| 260 | 
            -
                        return  | 
| 263 | 
            +
                        return l("div", {
         | 
| 261 264 | 
             
                          class: "cell-diy"
         | 
| 262 | 
            -
                        }, [c,  | 
| 265 | 
            +
                        }, [c, ee(" ")]);
         | 
| 263 266 | 
             
                      }
         | 
| 264 267 | 
             
                    });
         | 
| 265 | 
            -
                  },  | 
| 268 | 
            +
                  }, j = (e) => e == null ? void 0 : e.map((t) => {
         | 
| 266 269 | 
             
                    if (t.type === "OPagetableColumnString")
         | 
| 267 | 
            -
                      return _(t);
         | 
| 268 | 
            -
                    if (t.type === "OPagetableColumnNumber")
         | 
| 269 270 | 
             
                      return U(t);
         | 
| 270 | 
            -
                    if (t.type === " | 
| 271 | 
            +
                    if (t.type === "OPagetableColumnNumber")
         | 
| 271 272 | 
             
                      return q(t);
         | 
| 272 | 
            -
                    if (t.type === " | 
| 273 | 
            +
                    if (t.type === "OPagetableColumnDate")
         | 
| 273 274 | 
             
                      return G(t);
         | 
| 274 | 
            -
                    if (t.type === " | 
| 275 | 
            +
                    if (t.type === "OPagetableColumnSingleselect")
         | 
| 275 276 | 
             
                      return J(t);
         | 
| 276 | 
            -
                    if (t.type === " | 
| 277 | 
            +
                    if (t.type === "OPagetableColumnMultiselect")
         | 
| 277 278 | 
             
                      return K(t);
         | 
| 278 | 
            -
                    if (t.type === " | 
| 279 | 
            +
                    if (t.type === "OPagetableColumnButtongroup")
         | 
| 279 280 | 
             
                      return L(t);
         | 
| 280 | 
            -
                    if (t.type === " | 
| 281 | 
            +
                    if (t.type === "OPagetableColumngroup")
         | 
| 281 282 | 
             
                      return Q(t);
         | 
| 282 | 
            -
                     | 
| 283 | 
            +
                    if (t.type === "OPagetableColumnDiy")
         | 
| 284 | 
            +
                      return W(t);
         | 
| 285 | 
            +
                    throw new de(`OPagetable不能正确渲染'${t.type.name}'子组件。`);
         | 
| 283 286 | 
             
                  });
         | 
| 284 | 
            -
                  return  | 
| 285 | 
            -
                    class: [ | 
| 287 | 
            +
                  return l("div", {
         | 
| 288 | 
            +
                    class: [F, b.class],
         | 
| 286 289 | 
             
                    style: [B.value, b.style]
         | 
| 287 | 
            -
                  }, [ | 
| 290 | 
            +
                  }, [l("div", {
         | 
| 288 291 | 
             
                    class: "pagetable-wrapper"
         | 
| 289 | 
            -
                  }, [ | 
| 292 | 
            +
                  }, [l(ne, {
         | 
| 290 293 | 
             
                    border: !0,
         | 
| 291 294 | 
             
                    ref: y,
         | 
| 292 295 | 
             
                    data: O,
         | 
| @@ -295,14 +298,15 @@ const me = () => ({ | |
| 295 298 | 
             
                      width: "100%"
         | 
| 296 299 | 
             
                    },
         | 
| 297 300 | 
             
                    "onSelection-change": (e) => u("selectionChange", e),
         | 
| 298 | 
            -
                    "highlight-current-row":  | 
| 301 | 
            +
                    "highlight-current-row": Y,
         | 
| 299 302 | 
             
                    "onCurrent-change": (e, t) => u("currentRowChange", e, t),
         | 
| 300 | 
            -
                    "onRow-click": (e, t, s) => u("rowClick", e, t, s)
         | 
| 303 | 
            +
                    "onRow-click": (e, t, s) => u("rowClick", e, t, s),
         | 
| 304 | 
            +
                    size: N
         | 
| 301 305 | 
             
                  }, {
         | 
| 302 | 
            -
                    default: () => [$ &&  | 
| 303 | 
            -
                  })]),  | 
| 306 | 
            +
                    default: () => [$ && H(), E && _(), j(T.value)]
         | 
| 307 | 
            +
                  })]), l("div", {
         | 
| 304 308 | 
             
                    class: "pagination-wrapper"
         | 
| 305 | 
            -
                  }, [ | 
| 309 | 
            +
                  }, [l(oe, {
         | 
| 306 310 | 
             
                    currentPage: v.currentPage,
         | 
| 307 311 | 
             
                    "onUpdate:current-page": (e) => {
         | 
| 308 312 | 
             
                      u("update:pagination", {
         | 
| @@ -312,15 +316,16 @@ const me = () => ({ | |
| 312 316 | 
             
                    },
         | 
| 313 317 | 
             
                    pageSize: v.pageSize,
         | 
| 314 318 | 
             
                    total: v.total,
         | 
| 315 | 
            -
                    layout: "total, ->, prev, pager, next, jumper"
         | 
| 319 | 
            +
                    layout: "total, ->, prev, pager, next, jumper",
         | 
| 320 | 
            +
                    size: N
         | 
| 316 321 | 
             
                  }, null)])]);
         | 
| 317 322 | 
             
                };
         | 
| 318 323 | 
             
              }
         | 
| 319 | 
            -
            }),  | 
| 324 | 
            +
            }), be = () => ({}), we = /* @__PURE__ */ C({
         | 
| 320 325 | 
             
              name: "OPagetableColumnIndex",
         | 
| 321 326 | 
             
              inheritAttrs: !1,
         | 
| 322 | 
            -
              props:  | 
| 323 | 
            -
              setup( | 
| 327 | 
            +
              props: be(),
         | 
| 328 | 
            +
              setup(o, {
         | 
| 324 329 | 
             
                slots: d,
         | 
| 325 330 | 
             
                attrs: b,
         | 
| 326 331 | 
             
                emit: u,
         | 
| @@ -328,17 +333,17 @@ const me = () => ({ | |
| 328 333 | 
             
              }) {
         | 
| 329 334 | 
             
                return () => null;
         | 
| 330 335 | 
             
              }
         | 
| 331 | 
            -
            }),  | 
| 336 | 
            +
            }), Ce = () => ({
         | 
| 332 337 | 
             
              head: n(),
         | 
| 333 338 | 
             
              headAlign: n(),
         | 
| 334 339 | 
             
              name: n(),
         | 
| 335 340 | 
             
              width: i([Boolean, String]),
         | 
| 336 341 | 
             
              fixed: i([Boolean, String])
         | 
| 337 | 
            -
            }),  | 
| 342 | 
            +
            }), Se = /* @__PURE__ */ C({
         | 
| 338 343 | 
             
              name: "OPagetableColumnString",
         | 
| 339 344 | 
             
              inheritAttrs: !1,
         | 
| 340 | 
            -
              props:  | 
| 341 | 
            -
              setup( | 
| 345 | 
            +
              props: Ce(),
         | 
| 346 | 
            +
              setup(o, {
         | 
| 342 347 | 
             
                slots: d,
         | 
| 343 348 | 
             
                attrs: b,
         | 
| 344 349 | 
             
                emit: u,
         | 
| @@ -346,20 +351,20 @@ const me = () => ({ | |
| 346 351 | 
             
              }) {
         | 
| 347 352 | 
             
                return () => null;
         | 
| 348 353 | 
             
              }
         | 
| 349 | 
            -
            }),  | 
| 354 | 
            +
            }), ye = () => ({
         | 
| 350 355 | 
             
              head: n(),
         | 
| 351 356 | 
             
              headAlign: n(),
         | 
| 352 357 | 
             
              name: n(),
         | 
| 353 358 | 
             
              width: i([Boolean, String]),
         | 
| 354 359 | 
             
              fixed: i([Boolean, String]),
         | 
| 355 360 | 
             
              thousandsSeparator: D(!0),
         | 
| 356 | 
            -
              precision:  | 
| 361 | 
            +
              precision: ie(-1),
         | 
| 357 362 | 
             
              percentage: D(!1)
         | 
| 358 | 
            -
            }),  | 
| 363 | 
            +
            }), Pe = /* @__PURE__ */ C({
         | 
| 359 364 | 
             
              name: "OPagetableColumnNumber",
         | 
| 360 365 | 
             
              inheritAttrs: !1,
         | 
| 361 | 
            -
              props:  | 
| 362 | 
            -
              setup( | 
| 366 | 
            +
              props: ye(),
         | 
| 367 | 
            +
              setup(o, {
         | 
| 363 368 | 
             
                slots: d,
         | 
| 364 369 | 
             
                attrs: b,
         | 
| 365 370 | 
             
                emit: u,
         | 
| @@ -367,7 +372,7 @@ const me = () => ({ | |
| 367 372 | 
             
              }) {
         | 
| 368 373 | 
             
                return () => null;
         | 
| 369 374 | 
             
              }
         | 
| 370 | 
            -
            }),  | 
| 375 | 
            +
            }), xe = () => ({
         | 
| 371 376 | 
             
              head: n(),
         | 
| 372 377 | 
             
              headAlign: n(),
         | 
| 373 378 | 
             
              name: n(),
         | 
| @@ -376,11 +381,11 @@ const me = () => ({ | |
| 376 381 | 
             
              // Date
         | 
| 377 382 | 
             
              format: n(),
         | 
| 378 383 | 
             
              sourceFormat: n()
         | 
| 379 | 
            -
            }),  | 
| 384 | 
            +
            }), Ae = /* @__PURE__ */ C({
         | 
| 380 385 | 
             
              name: "OPagetableColumnDate",
         | 
| 381 386 | 
             
              inheritAttrs: !1,
         | 
| 382 | 
            -
              props:  | 
| 383 | 
            -
              setup( | 
| 387 | 
            +
              props: xe(),
         | 
| 388 | 
            +
              setup(o, {
         | 
| 384 389 | 
             
                slots: d,
         | 
| 385 390 | 
             
                attrs: b,
         | 
| 386 391 | 
             
                emit: u,
         | 
| @@ -388,18 +393,18 @@ const me = () => ({ | |
| 388 393 | 
             
              }) {
         | 
| 389 394 | 
             
                return () => null;
         | 
| 390 395 | 
             
              }
         | 
| 391 | 
            -
            }),  | 
| 396 | 
            +
            }), Oe = () => ({
         | 
| 392 397 | 
             
              head: n(),
         | 
| 393 398 | 
             
              headAlign: n(),
         | 
| 394 399 | 
             
              name: n(),
         | 
| 395 400 | 
             
              width: i([Boolean, String]),
         | 
| 396 401 | 
             
              fixed: i([Boolean, String]),
         | 
| 397 402 | 
             
              code: i([String, Array])
         | 
| 398 | 
            -
            }),  | 
| 403 | 
            +
            }), ve = /* @__PURE__ */ C({
         | 
| 399 404 | 
             
              name: "OPagetableColumnSingleselect",
         | 
| 400 405 | 
             
              inheritAttrs: !1,
         | 
| 401 | 
            -
              props:  | 
| 402 | 
            -
              setup( | 
| 406 | 
            +
              props: Oe(),
         | 
| 407 | 
            +
              setup(o, {
         | 
| 403 408 | 
             
                slots: d,
         | 
| 404 409 | 
             
                attrs: b,
         | 
| 405 410 | 
             
                emit: u,
         | 
| @@ -407,18 +412,18 @@ const me = () => ({ | |
| 407 412 | 
             
              }) {
         | 
| 408 413 | 
             
                return () => null;
         | 
| 409 414 | 
             
              }
         | 
| 410 | 
            -
            }),  | 
| 415 | 
            +
            }), Be = () => ({
         | 
| 411 416 | 
             
              head: n(),
         | 
| 412 417 | 
             
              headAlign: n(),
         | 
| 413 418 | 
             
              name: n(),
         | 
| 414 419 | 
             
              width: i([Boolean, String]),
         | 
| 415 420 | 
             
              fixed: i([Boolean, String]),
         | 
| 416 421 | 
             
              code: i([String, Array])
         | 
| 417 | 
            -
            }),  | 
| 422 | 
            +
            }), Te = /* @__PURE__ */ C({
         | 
| 418 423 | 
             
              name: "OPagetableColumnMultiselect",
         | 
| 419 424 | 
             
              inheritAttrs: !1,
         | 
| 420 | 
            -
              props:  | 
| 421 | 
            -
              setup( | 
| 425 | 
            +
              props: Be(),
         | 
| 426 | 
            +
              setup(o, {
         | 
| 422 427 | 
             
                slots: d,
         | 
| 423 428 | 
             
                attrs: b,
         | 
| 424 429 | 
             
                emit: u,
         | 
| @@ -426,18 +431,18 @@ const me = () => ({ | |
| 426 431 | 
             
              }) {
         | 
| 427 432 | 
             
                return () => null;
         | 
| 428 433 | 
             
              }
         | 
| 429 | 
            -
            }),  | 
| 434 | 
            +
            }), De = () => ({
         | 
| 430 435 | 
             
              head: n(),
         | 
| 431 436 | 
             
              headAlign: n(),
         | 
| 432 437 | 
             
              name: n(),
         | 
| 433 438 | 
             
              width: i([Boolean, String]),
         | 
| 434 439 | 
             
              fixed: i([Boolean, String])
         | 
| 435 | 
            -
            }),  | 
| 440 | 
            +
            }), Re = /* @__PURE__ */ C({
         | 
| 436 441 | 
             
              name: "OPagetableColumnButtongroup",
         | 
| 437 442 | 
             
              inheritAttrs: !1,
         | 
| 438 | 
            -
              props:  | 
| 443 | 
            +
              props: De(),
         | 
| 439 444 | 
             
              slots: Object,
         | 
| 440 | 
            -
              setup( | 
| 445 | 
            +
              setup(o, {
         | 
| 441 446 | 
             
                slots: d,
         | 
| 442 447 | 
             
                attrs: b,
         | 
| 443 448 | 
             
                emit: u,
         | 
| @@ -446,17 +451,17 @@ const me = () => ({ | |
| 446 451 | 
             
                return () => null;
         | 
| 447 452 | 
             
              }
         | 
| 448 453 | 
             
            });
         | 
| 449 | 
            -
            function  | 
| 450 | 
            -
              return typeof  | 
| 454 | 
            +
            function Ne(o) {
         | 
| 455 | 
            +
              return typeof o == "function" || Object.prototype.toString.call(o) === "[object Object]" && !V(o);
         | 
| 451 456 | 
             
            }
         | 
| 452 | 
            -
            const  | 
| 457 | 
            +
            const je = () => ({
         | 
| 453 458 | 
             
              type: n()
         | 
| 454 | 
            -
            }),  | 
| 459 | 
            +
            }), Me = /* @__PURE__ */ C({
         | 
| 455 460 | 
             
              name: "OPagetableCellButton",
         | 
| 456 461 | 
             
              inheritAttrs: !1,
         | 
| 457 | 
            -
              props:  | 
| 462 | 
            +
              props: je(),
         | 
| 458 463 | 
             
              emits: ["click"],
         | 
| 459 | 
            -
              setup( | 
| 464 | 
            +
              setup(o, {
         | 
| 460 465 | 
             
                slots: d,
         | 
| 461 466 | 
             
                attrs: b,
         | 
| 462 467 | 
             
                emit: u,
         | 
| @@ -469,25 +474,25 @@ const Ne = () => ({ | |
| 469 474 | 
             
                  var R;
         | 
| 470 475 | 
             
                  const {
         | 
| 471 476 | 
             
                    type: B
         | 
| 472 | 
            -
                  } =  | 
| 473 | 
            -
                  return  | 
| 477 | 
            +
                  } = o, T = (R = d.default) == null ? void 0 : R.call(d);
         | 
| 478 | 
            +
                  return l(le, {
         | 
| 474 479 | 
             
                    link: !0,
         | 
| 475 480 | 
             
                    type: B,
         | 
| 476 481 | 
             
                    size: "small",
         | 
| 477 482 | 
             
                    onClick: y
         | 
| 478 | 
            -
                  },  | 
| 483 | 
            +
                  }, Ne(T) ? T : {
         | 
| 479 484 | 
             
                    default: () => [T]
         | 
| 480 485 | 
             
                  });
         | 
| 481 486 | 
             
                };
         | 
| 482 487 | 
             
              }
         | 
| 483 | 
            -
            }),  | 
| 488 | 
            +
            }), ke = () => ({
         | 
| 484 489 | 
             
              head: n(),
         | 
| 485 490 | 
             
              headAlign: n()
         | 
| 486 | 
            -
            }),  | 
| 491 | 
            +
            }), ze = /* @__PURE__ */ C({
         | 
| 487 492 | 
             
              name: "OPagetableColumngroup",
         | 
| 488 493 | 
             
              inheritAttrs: !1,
         | 
| 489 | 
            -
              props:  | 
| 490 | 
            -
              setup( | 
| 494 | 
            +
              props: ke(),
         | 
| 495 | 
            +
              setup(o, {
         | 
| 491 496 | 
             
                slots: d,
         | 
| 492 497 | 
             
                attrs: b,
         | 
| 493 498 | 
             
                emit: u,
         | 
| @@ -506,7 +511,7 @@ const Ne = () => ({ | |
| 506 511 | 
             
              inheritAttrs: !1,
         | 
| 507 512 | 
             
              props: Ie(),
         | 
| 508 513 | 
             
              slots: Object,
         | 
| 509 | 
            -
              setup( | 
| 514 | 
            +
              setup(o, {
         | 
| 510 515 | 
             
                slots: d,
         | 
| 511 516 | 
             
                attrs: b,
         | 
| 512 517 | 
             
                emit: u,
         | 
| @@ -514,19 +519,19 @@ const Ne = () => ({ | |
| 514 519 | 
             
              }) {
         | 
| 515 520 | 
             
                return () => null;
         | 
| 516 521 | 
             
              }
         | 
| 517 | 
            -
            }),  | 
| 518 | 
            -
              PagetableColumnIndex:  | 
| 519 | 
            -
              PagetableColumnString:  | 
| 520 | 
            -
              PagetableColumnNumber:  | 
| 521 | 
            -
              PagetableColumnDate:  | 
| 522 | 
            -
              PagetableColumnSingleselect:  | 
| 523 | 
            -
              PagetableColumnMultiselect:  | 
| 524 | 
            -
              PagetableColumnButtongroup:  | 
| 525 | 
            -
              PagetableCellButton:  | 
| 526 | 
            -
              PagetableColumngroup:  | 
| 522 | 
            +
            }), tt = te(fe, {
         | 
| 523 | 
            +
              PagetableColumnIndex: we,
         | 
| 524 | 
            +
              PagetableColumnString: Se,
         | 
| 525 | 
            +
              PagetableColumnNumber: Pe,
         | 
| 526 | 
            +
              PagetableColumnDate: Ae,
         | 
| 527 | 
            +
              PagetableColumnSingleselect: ve,
         | 
| 528 | 
            +
              PagetableColumnMultiselect: Te,
         | 
| 529 | 
            +
              PagetableColumnButtongroup: Re,
         | 
| 530 | 
            +
              PagetableCellButton: Me,
         | 
| 531 | 
            +
              PagetableColumngroup: ze,
         | 
| 527 532 | 
             
              PagetableColumnDiy: Ve
         | 
| 528 533 | 
             
            });
         | 
| 529 534 | 
             
            export {
         | 
| 530 | 
            -
               | 
| 535 | 
            +
              tt as default
         | 
| 531 536 | 
             
            };
         | 
| 532 537 | 
             
            //# sourceMappingURL=index.js.map
         |