lew-ui 2.3.6 → 2.3.9

package/dist/components/upload/src/LewUpload.vue.d.ts

@@ -1,20 +1,15 @@
 import { UploadFileItem } from './props';
 
-declare const _default: import('vue').DefineComponent<{
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
     modelValue: import('vue').PropType<UploadFileItem[]>;
-    size: {
-        type: PropType<import('../..').FormSize>;
-        default: string;
-        description: string;
-    };
     accept: {
         type: StringConstructor;
         default: string;
         description: string;
     };
-    maxFileSize: {
-        type: NumberConstructor;
-        default: number;
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
         description: string;
     };
     disabled: {
@@ -27,43 +22,48 @@ declare const _default: import('vue').DefineComponent<{
         default: boolean;
         description: string;
     };
-    tips: {
-        type: StringConstructor;
-        default: string;
-        description: string;
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
+    limit: {
+        type: NumberConstructor;
+        default: number;
         description: string;
+        validator: (value: number) => boolean;
     };
-    limit: {
+    maxFileSize: {
         type: NumberConstructor;
         default: number;
         description: string;
+        validator: (value: number) => boolean;
+    };
+    size: {
+        type: PropType<import('../../..').LewSize>;
+        default: string;
+        description: string;
+        validator: (value: import('../../..').LewSize) => boolean;
+    };
+    tips: {
+        type: StringConstructor;
+        default: string;
+        description: string;
+        validator: (value: string) => boolean;
     };
     uploadHelper: {
         type: FunctionConstructor;
-        default: () => void;
+        default: () => Promise<void>;
         description: string;
+        validator: (value: Function) => boolean;
     };
-}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     change: (...args: any[]) => void;
 }, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
     modelValue: import('vue').PropType<UploadFileItem[]>;
-    size: {
-        type: PropType<import('../..').FormSize>;
-        default: string;
-        description: string;
-    };
     accept: {
         type: StringConstructor;
         default: string;
         description: string;
     };
-    maxFileSize: {
-        type: NumberConstructor;
-        default: number;
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
         description: string;
     };
     disabled: {
@@ -76,37 +76,47 @@ declare const _default: import('vue').DefineComponent<{
         default: boolean;
         description: string;
     };
-    tips: {
-        type: StringConstructor;
-        default: string;
-        description: string;
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
+    limit: {
+        type: NumberConstructor;
+        default: number;
         description: string;
+        validator: (value: number) => boolean;
     };
-    limit: {
+    maxFileSize: {
         type: NumberConstructor;
         default: number;
         description: string;
+        validator: (value: number) => boolean;
+    };
+    size: {
+        type: PropType<import('../../..').LewSize>;
+        default: string;
+        description: string;
+        validator: (value: import('../../..').LewSize) => boolean;
+    };
+    tips: {
+        type: StringConstructor;
+        default: string;
+        description: string;
+        validator: (value: string) => boolean;
     };
     uploadHelper: {
         type: FunctionConstructor;
-        default: () => void;
+        default: () => Promise<void>;
         description: string;
+        validator: (value: Function) => boolean;
     };
-}>> & {
+}>> & Readonly<{
     onChange?: ((...args: any[]) => any) | undefined;
-}, {
-    size: import('../..').FormSize;
+}>, {
+    size: import('../../..').LewSize;
+    disabled: boolean;
     multiple: boolean;
     readonly: boolean;
-    disabled: boolean;
     tips: string;
     accept: string;
-    maxFileSize: number;
     limit: number;
+    maxFileSize: number;
     uploadHelper: Function;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/upload/src/props.d.ts

@@ -1,5 +1,5 @@
 import { ExtractPropTypes } from 'vue';
-import { FormSize } from '../../..';
+import { LewSize } from '../../..';
 
 export type UploadStatus = 'success' | 'fail' | 'uploading' | 'pending' | 'complete' | 'wrong_type' | 'wrong_size';
 export type UploadFileItem = {
@@ -11,23 +11,18 @@ export type UploadFileItem = {
     file?: File;
     size?: number;
     type?: string;
-    lastModifiedDate?: any;
-    lastModified?: any;
+    lastModifiedDate?: Date;
+    lastModified?: number;
 };
 export declare const uploadProps: {
-    size: {
-        type: PropType<FormSize>;
-        default: string;
-        description: string;
-    };
     accept: {
         type: StringConstructor;
         default: string;
         description: string;
     };
-    maxFileSize: {
-        type: NumberConstructor;
-        default: number;
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
         description: string;
     };
     disabled: {
@@ -40,25 +35,35 @@ export declare const uploadProps: {
         default: boolean;
         description: string;
     };
-    tips: {
-        type: StringConstructor;
-        default: string;
-        description: string;
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
+    limit: {
+        type: NumberConstructor;
+        default: number;
         description: string;
+        validator: (value: number) => boolean;
     };
-    limit: {
+    maxFileSize: {
         type: NumberConstructor;
         default: number;
         description: string;
+        validator: (value: number) => boolean;
+    };
+    size: {
+        type: PropType<LewSize>;
+        default: string;
+        description: string;
+        validator: (value: LewSize) => boolean;
+    };
+    tips: {
+        type: StringConstructor;
+        default: string;
+        description: string;
+        validator: (value: string) => boolean;
     };
     uploadHelper: {
         type: FunctionConstructor;
-        default: () => void;
+        default: () => Promise<void>;
         description: string;
+        validator: (value: Function) => boolean;
     };
 };
 export type UploadProps = ExtractPropTypes<typeof uploadProps>;

package/dist/confetti.browser.min.js

@@ -0,0 +1,456 @@
+/**
+ * Minified by jsDelivr using Terser v5.10.0.
+ * Original file: /npm/canvas-confetti@1.5.1/dist/confetti.browser.js
+ *
+ * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
+ */
+!(function (t, e) {
+    !(function t(e, n, a, i) {
+        let o = !!(
+            e.Worker &&
+            e.Blob &&
+            e.Promise &&
+            e.OffscreenCanvas &&
+            e.OffscreenCanvasRenderingContext2D &&
+            e.HTMLCanvasElement &&
+            e.HTMLCanvasElement.prototype.transferControlToOffscreen &&
+            e.URL &&
+            e.URL.createObjectURL
+        )
+
+        function r() {}
+
+        function l(t) {
+            let a = n.exports.Promise,
+                i = void 0 !== a ? a : e.Promise
+            return typeof i === 'function' ? new i(t) : (t(r, r), null)
+        }
+        let c,
+            s,
+            u,
+            d,
+            f,
+            h,
+            m,
+            g,
+            b,
+            v =
+                ((u = Math.floor(1e3 / 60)),
+                (d = {}),
+                (f = 0),
+                typeof requestAnimationFrame === 'function' && typeof cancelAnimationFrame === 'function'
+                    ? ((c = function (t) {
+                          let e = Math.random()
+                          return (
+                              (d[e] = requestAnimationFrame(function n(a) {
+                                  f === a || f + u - 1 < a
+                                      ? ((f = a), delete d[e], t())
+                                      : (d[e] = requestAnimationFrame(n))
+                              })),
+                              e
+                          )
+                      }),
+                      (s = function (t) {
+                          d[t] && cancelAnimationFrame(d[t])
+                      }))
+                    : ((c = function (t) {
+                          return setTimeout(t, u)
+                      }),
+                      (s = function (t) {
+                          return clearTimeout(t)
+                      })),
+                { frame: c, cancel: s }),
+            p =
+                ((g = {}),
+                function () {
+                    if (h) return h
+                    if (!a && o) {
+                        let e = [
+                            'var CONFETTI, SIZE = {}, module = {};',
+                            '(' + t.toString() + ')(this, module, true, SIZE);',
+                            'onmessage = function(msg) {',
+                            '  if (msg.data.options) {',
+                            '    CONFETTI(msg.data.options).then(function () {',
+                            '      if (msg.data.callback) {',
+                            '        postMessage({ callback: msg.data.callback });',
+                            '      }',
+                            '    });',
+                            '  } else if (msg.data.reset) {',
+                            '    CONFETTI.reset();',
+                            '  } else if (msg.data.resize) {',
+                            '    SIZE.width = msg.data.resize.width;',
+                            '    SIZE.height = msg.data.resize.height;',
+                            '  } else if (msg.data.canvas) {',
+                            '    SIZE.width = msg.data.canvas.width;',
+                            '    SIZE.height = msg.data.canvas.height;',
+                            '    CONFETTI = module.exports.create(msg.data.canvas);',
+                            '  }',
+                            '}'
+                        ].join('\n')
+                        try {
+                            h = new Worker(URL.createObjectURL(new Blob([e])))
+                        } catch (t) {
+                            return (
+                                void 0 !== typeof console &&
+                                    typeof console.warn === 'function' &&
+                                    console.warn('🎊 Could not load worker', t),
+                                null
+                            )
+                        }
+                        !(function (t) {
+                            function e(e, n) {
+                                t.postMessage({
+                                    options: e || {},
+                                    callback: n
+                                })
+                            }
+                            ;(t.init = function (e) {
+                                let n = e.transferControlToOffscreen()
+                                t.postMessage({ canvas: n }, [n])
+                            }),
+                                (t.fire = function (n, a, i) {
+                                    if (m) return e(n, null), m
+                                    let o = Math.random().toString(36).slice(2)
+                                    return (m = l(function (a) {
+                                        function r(e) {
+                                            e.data.callback === o &&
+                                                (delete g[o], t.removeEventListener('message', r), (m = null), i(), a())
+                                        }
+                                        t.addEventListener('message', r),
+                                            e(n, o),
+                                            (g[o] = r.bind(null, {
+                                                data: { callback: o }
+                                            }))
+                                    }))
+                                }),
+                                (t.reset = function () {
+                                    for (let e in (t.postMessage({ reset: !0 }), g)) g[e](), delete g[e]
+                                })
+                        })(h)
+                    }
+                    return h
+                }),
+            y = {
+                particleCount: 50,
+                angle: 90,
+                spread: 45,
+                startVelocity: 45,
+                decay: 0.9,
+                gravity: 1,
+                drift: 0,
+                ticks: 200,
+                x: 0.5,
+                y: 0.5,
+                shapes: ['square', 'circle'],
+                zIndex: 100,
+                colors: ['#26ccff', '#a25afd', '#ff5e7e', '#88ff5a', '#fcff42', '#ffa62d', '#ff36ff'],
+                disableForReducedMotion: !1,
+                scalar: 1
+            }
+
+        function M(t, e, n) {
+            return (function (t, e) {
+                return e ? e(t) : t
+            })(t && t[e] != null ? t[e] : y[e], n)
+        }
+
+        function w(t) {
+            return t < 0 ? 0 : Math.floor(t)
+        }
+
+        function x(t) {
+            return parseInt(t, 16)
+        }
+
+        function C(t) {
+            return t.map(k)
+        }
+
+        function k(t) {
+            let e = String(t).replace(/[^0-9a-f]/gi, '')
+            return (
+                e.length < 6 && (e = e[0] + e[0] + e[1] + e[1] + e[2] + e[2]),
+                {
+                    r: x(e.substring(0, 2)),
+                    g: x(e.substring(2, 4)),
+                    b: x(e.substring(4, 6))
+                }
+            )
+        }
+
+        function I(t) {
+            ;(t.width = document.documentElement.clientWidth), (t.height = document.documentElement.clientHeight)
+        }
+
+        function S(t) {
+            let e = t.getBoundingClientRect()
+            ;(t.width = e.width), (t.height = e.height)
+        }
+
+        function T(t, e, n, o, r) {
+            let c,
+                s,
+                u = e.slice(),
+                d = t.getContext('2d'),
+                f = l(function (e) {
+                    function l() {
+                        ;(c = s = null), d.clearRect(0, 0, o.width, o.height), r(), e()
+                    }
+                    ;(c = v.frame(function e() {
+                        !a ||
+                            (o.width === i.width && o.height === i.height) ||
+                            ((o.width = t.width = i.width), (o.height = t.height = i.height)),
+                            o.width || o.height || (n(t), (o.width = t.width), (o.height = t.height)),
+                            d.clearRect(0, 0, o.width, o.height),
+                            (u = u.filter(function (t) {
+                                return (function (t, e) {
+                                    ;(e.x += Math.cos(e.angle2D) * e.velocity + e.drift),
+                                        (e.y += Math.sin(e.angle2D) * e.velocity + e.gravity),
+                                        (e.wobble += e.wobbleSpeed),
+                                        (e.velocity *= e.decay),
+                                        (e.tiltAngle += 0.1),
+                                        (e.tiltSin = Math.sin(e.tiltAngle)),
+                                        (e.tiltCos = Math.cos(e.tiltAngle)),
+                                        (e.random = Math.random() + 2),
+                                        (e.wobbleX = e.x + 10 * e.scalar * Math.cos(e.wobble)),
+                                        (e.wobbleY = e.y + 10 * e.scalar * Math.sin(e.wobble))
+                                    let n = e.tick++ / e.totalTicks,
+                                        a = e.x + e.random * e.tiltCos,
+                                        i = e.y + e.random * e.tiltSin,
+                                        o = e.wobbleX + e.random * e.tiltCos,
+                                        r = e.wobbleY + e.random * e.tiltSin
+                                    return (
+                                        (t.fillStyle =
+                                            'rgba(' +
+                                            e.color.r +
+                                            ', ' +
+                                            e.color.g +
+                                            ', ' +
+                                            e.color.b +
+                                            ', ' +
+                                            (1 - n) +
+                                            ')'),
+                                        t.beginPath(),
+                                        e.shape === 'circle'
+                                            ? t.ellipse
+                                                ? t.ellipse(
+                                                      e.x,
+                                                      e.y,
+                                                      Math.abs(o - a) * e.ovalScalar,
+                                                      Math.abs(r - i) * e.ovalScalar,
+                                                      (Math.PI / 10) * e.wobble,
+                                                      0,
+                                                      2 * Math.PI
+                                                  )
+                                                : (function (t, e, n, a, i, o, r, l, c) {
+                                                      t.save(),
+                                                          t.translate(e, n),
+                                                          t.rotate(o),
+                                                          t.scale(a, i),
+                                                          t.arc(0, 0, 1, r, l, c),
+                                                          t.restore()
+                                                  })(
+                                                      t,
+                                                      e.x,
+                                                      e.y,
+                                                      Math.abs(o - a) * e.ovalScalar,
+                                                      Math.abs(r - i) * e.ovalScalar,
+                                                      (Math.PI / 10) * e.wobble,
+                                                      0,
+                                                      2 * Math.PI
+                                                  )
+                                            : (t.moveTo(Math.floor(e.x), Math.floor(e.y)),
+                                              t.lineTo(Math.floor(e.wobbleX), Math.floor(i)),
+                                              t.lineTo(Math.floor(o), Math.floor(r)),
+                                              t.lineTo(Math.floor(a), Math.floor(e.wobbleY))),
+                                        t.closePath(),
+                                        t.fill(),
+                                        e.tick < e.totalTicks
+                                    )
+                                })(d, t)
+                            })),
+                            u.length ? (c = v.frame(e)) : l()
+                    })),
+                        (s = l)
+                })
+            return {
+                addFettis(t) {
+                    return (u = u.concat(t)), f
+                },
+                canvas: t,
+                promise: f,
+                reset() {
+                    c && v.cancel(c), s && s()
+                }
+            }
+        }
+
+        function E(t, n) {
+            let a,
+                i = !t,
+                r = !!M(n || {}, 'resize'),
+                c = M(n, 'disableForReducedMotion', Boolean),
+                s = o && !!M(n || {}, 'useWorker') ? p() : null,
+                u = i ? I : S,
+                d = !(!t || !s) && !!t.__confetti_initialized,
+                f = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion)').matches
+
+            function h(e, n, i) {
+                for (
+                    var o,
+                        r,
+                        l,
+                        c,
+                        s,
+                        d = M(e, 'particleCount', w),
+                        f = M(e, 'angle', Number),
+                        h = M(e, 'spread', Number),
+                        m = M(e, 'startVelocity', Number),
+                        g = M(e, 'decay', Number),
+                        b = M(e, 'gravity', Number),
+                        v = M(e, 'drift', Number),
+                        p = M(e, 'colors', C),
+                        y = M(e, 'ticks', Number),
+                        x = M(e, 'shapes'),
+                        k = M(e, 'scalar'),
+                        I = (function (t) {
+                            let e = M(t, 'origin', Object)
+                            return (e.x = M(e, 'x', Number)), (e.y = M(e, 'y', Number)), e
+                        })(e),
+                        S = d,
+                        E = [],
+                        F = t.width * I.x,
+                        N = t.height * I.y;
+                    S--;
+
+                )
+                    E.push(
+                        ((o = {
+                            x: F,
+                            y: N,
+                            angle: f,
+                            spread: h,
+                            startVelocity: m,
+                            color: p[S % p.length],
+                            shape: x[((c = 0), (s = x.length), Math.floor(Math.random() * (s - c)) + c)],
+                            ticks: y,
+                            decay: g,
+                            gravity: b,
+                            drift: v,
+                            scalar: k
+                        }),
+                        (r = void 0),
+                        (l = void 0),
+                        (r = o.angle * (Math.PI / 180)),
+                        (l = o.spread * (Math.PI / 180)),
+                        {
+                            x: o.x,
+                            y: o.y,
+                            wobble: 10 * Math.random(),
+                            wobbleSpeed: Math.min(0.11, 0.1 * Math.random() + 0.05),
+                            velocity: 0.5 * o.startVelocity + Math.random() * o.startVelocity,
+                            angle2D: -r + (0.5 * l - Math.random() * l),
+                            tiltAngle: (0.5 * Math.random() + 0.25) * Math.PI,
+                            color: o.color,
+                            shape: o.shape,
+                            tick: 0,
+                            totalTicks: o.ticks,
+                            decay: o.decay,
+                            drift: o.drift,
+                            random: Math.random() + 2,
+                            tiltSin: 0,
+                            tiltCos: 0,
+                            wobbleX: 0,
+                            wobbleY: 0,
+                            gravity: 3 * o.gravity,
+                            ovalScalar: 0.6,
+                            scalar: o.scalar
+                        })
+                    )
+                return a ? a.addFettis(E) : (a = T(t, E, u, n, i)).promise
+            }
+
+            function m(n) {
+                let o = c || M(n, 'disableForReducedMotion', Boolean),
+                    m = M(n, 'zIndex', Number)
+                if (o && f)
+                    return l(function (t) {
+                        t()
+                    })
+                i && a
+                    ? (t = a.canvas)
+                    : i &&
+                      !t &&
+                      ((t = (function (t) {
+                          let e = document.createElement('canvas')
+                          return (
+                              (e.style.position = 'fixed'),
+                              (e.style.top = '0px'),
+                              (e.style.left = '0px'),
+                              (e.style.pointerEvents = 'none'),
+                              (e.style.zIndex = t),
+                              e
+                          )
+                      })(m)),
+                      document.body.appendChild(t)),
+                    r && !d && u(t)
+                let g = { width: t.width, height: t.height }
+
+                function b() {
+                    if (s) {
+                        let e = {
+                            getBoundingClientRect() {
+                                if (!i) return t.getBoundingClientRect()
+                            }
+                        }
+                        return (
+                            u(e),
+                            void s.postMessage({
+                                resize: { width: e.width, height: e.height }
+                            })
+                        )
+                    }
+                    g.width = g.height = null
+                }
+
+                function v() {
+                    ;(a = null),
+                        r && e.removeEventListener('resize', b),
+                        i && t && (document.body.removeChild(t), (t = null), (d = !1))
+                }
+                return (
+                    s && !d && s.init(t),
+                    (d = !0),
+                    s && (t.__confetti_initialized = !0),
+                    r && e.addEventListener('resize', b, !1),
+                    s ? s.fire(n, g, v) : h(n, g, v)
+                )
+            }
+            return (
+                (m.reset = function () {
+                    s && s.reset(), a && a.reset()
+                }),
+                m
+            )
+        }
+
+        function F() {
+            return b || (b = E(null, { useWorker: !0, resize: !0 })), b
+        }
+        ;(n.exports = function () {
+            return F().apply(this, arguments)
+        }),
+            (n.exports.reset = function () {
+                F().reset()
+            }),
+            (n.exports.create = E)
+    })(
+        (function () {
+            return void 0 !== t ? t : typeof self != 'undefined' ? self : this || {}
+        })(),
+        e,
+        !1
+    ),
+        (t.confetti = e.exports)
+})(window, {})
+// # sourceMappingURL=/sm/ab60d7fb9bf5b5ded42c77782b65b071de85f56c21da42948364d6b2b1961762.map