@quidgest/ui 0.14.18 → 0.14.20

package/esm/components/QPasswordField/QPasswordField.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QPasswordField.vue.js";
+export {
+  f as default
+};

package/esm/components/QPasswordField/QPasswordFieldMessages.d.ts

@@ -0,0 +1,4 @@
+import { QPasswordFieldMessagesProps } from './types';
+declare const _default: import('vue').DefineComponent<QPasswordFieldMessagesProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<QPasswordFieldMessagesProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLUListElement>;
+export default _default;
+//# sourceMappingURL=QPasswordFieldMessages.vue.d.ts.map

package/esm/components/QPasswordField/QPasswordFieldMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QPasswordFieldMessages.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QPasswordField/QPasswordFieldMessages.vue"],"names":[],"mappings":"AASA;AAmBC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAA;;AAgD3D,wBAOG"}

package/esm/components/QPasswordField/QPasswordFieldMessages.vue.js

@@ -0,0 +1,28 @@
+import { defineComponent as o, createElementBlock as e, openBlock as s, Fragment as a, renderList as l, toDisplayString as c } from "vue";
+const p = { class: "q-password-field__messages" }, d = /* @__PURE__ */ o({
+  __name: "QPasswordFieldMessages",
+  props: {
+    messages: {}
+  },
+  setup(r) {
+    const n = r;
+    return (i, _) => (s(), e("ul", p, [
+      (s(!0), e(
+        a,
+        null,
+        l(n.messages, (t) => (s(), e(
+          "li",
+          { key: t },
+          c(t),
+          1
+          /* TEXT */
+        ))),
+        128
+        /* KEYED_FRAGMENT */
+      ))
+    ]));
+  }
+});
+export {
+  d as default
+};

package/esm/components/QPasswordField/QPasswordFieldMessages.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QPasswordFieldMessages.vue.js";
+export {
+  f as default
+};

package/esm/components/QPasswordField/QPasswordFieldMeterOverlay.d.ts

@@ -0,0 +1,12 @@
+import { QPasswordFieldMeterOverlay } from './types';
+type __VLS_Props = QPasswordFieldMeterOverlay;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=QPasswordFieldMeterOverlay.vue.d.ts.map

package/esm/components/QPasswordField/QPasswordFieldMeterOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QPasswordFieldMeterOverlay.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QPasswordField/QPasswordFieldMeterOverlay.vue"],"names":[],"mappings":"AA0BA;AAgFC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAA;AAKzD,KAAK,WAAW,GAAG,0BAA0B,CAAC;AAqC/C,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;;;;;;AAmGhB,wBAOG"}

package/esm/components/QPasswordField/QPasswordFieldMeterOverlay.vue.js

@@ -0,0 +1,97 @@
+import { defineComponent as p, mergeModels as u, useModel as f, computed as h, createBlock as d, openBlock as r, unref as i, withCtx as v, createElementVNode as m, createElementBlock as y, createCommentVNode as c, createVNode as g, toDisplayString as B } from "vue";
+import { QMeter as _ } from "../QMeter/index.js";
+import { QOverlay as V } from "../QOverlay/index.js";
+import k from "./QPasswordFieldMessages.vue.js";
+const w = { class: "q-password-field__meter" }, M = {
+  key: 0,
+  class: "q-password-field__meter-score"
+}, N = /* @__PURE__ */ p({
+  inheritAttrs: !1,
+  __name: "QPasswordFieldMeterOverlay",
+  props: /* @__PURE__ */ u({
+    id: {},
+    class: {},
+    anchor: {},
+    appearance: {},
+    arrow: { type: Boolean },
+    attach: {},
+    inline: { type: Boolean },
+    backdropBlur: { type: Boolean },
+    backdropClass: {},
+    delay: {},
+    nonModal: { type: Boolean },
+    scrollLock: { type: Boolean },
+    offset: {},
+    crossOffset: {},
+    persistent: { type: Boolean },
+    placement: {},
+    spy: { type: Boolean },
+    transition: {},
+    trigger: {},
+    width: {},
+    messages: {},
+    score: {},
+    levels: {}
+  }, {
+    modelValue: { type: Boolean },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(a) {
+    const o = a, n = f(a, "modelValue"), s = h(() => {
+      if (!o.levels.length) {
+        console.warn("Levels array is empty.");
+        return;
+      }
+      const t = [...o.levels].sort(
+        (l, e) => (l.threshold ?? 1 / 0) - (e.threshold ?? 1 / 0)
+      );
+      for (const l of t) {
+        const e = l.threshold ?? 1 / 0;
+        if (o.score < e)
+          return l;
+      }
+      return o.levels[o.levels.length - 1];
+    });
+    return (t, l) => (r(), d(i(V), {
+      modelValue: n.value,
+      "onUpdate:modelValue": l[0] || (l[0] = (e) => n.value = e),
+      trigger: "manual",
+      anchor: o.anchor,
+      width: "anchor",
+      "non-modal": "",
+      placement: "bottom"
+    }, {
+      default: v(() => {
+        var e;
+        return [
+          m("div", w, [
+            s.value ? (r(), y("div", M, [
+              g(i(_), {
+                "model-value": o.score,
+                max: 1,
+                color: s.value.color
+              }, null, 8, ["model-value", "color"]),
+              m(
+                "span",
+                null,
+                B(s.value.label),
+                1
+                /* TEXT */
+              )
+            ])) : c("v-if", !0),
+            (e = t.messages) != null && e.length ? (r(), d(k, {
+              key: 1,
+              messages: t.messages
+            }, null, 8, ["messages"])) : c("v-if", !0)
+          ])
+        ];
+      }),
+      _: 1
+      /* STABLE */
+    }, 8, ["modelValue", "anchor"]));
+  }
+});
+export {
+  N as default
+};

package/esm/components/QPasswordField/QPasswordFieldMeterOverlay.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QPasswordFieldMeterOverlay.vue.js";
+export {
+  f as default
+};

package/esm/components/QPasswordField/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_ICONS: {
+    show: {
+        icon: string;
+    };
+    hide: {
+        icon: string;
+    };
+};
+//# sourceMappingURL=constants.d.ts.map

package/esm/components/QPasswordField/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/QPasswordField/constants.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;;CAOM,CAAA"}

package/esm/components/QPasswordField/constants.js

@@ -0,0 +1,11 @@
+const e = {
+  show: {
+    icon: "eye"
+  },
+  hide: {
+    icon: "eye-off"
+  }
+};
+export {
+  e as DEFAULT_ICONS
+};

package/esm/components/QPasswordField/index.d.ts

@@ -0,0 +1,264 @@
+import { QPasswordFieldProps } from './types';
+declare const QPasswordField: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: string;
+        masked?: boolean;
+    } & Omit<import('..').QTextFieldProps, "type" | "texts" | "clearable"> & {
+        toggle?: boolean;
+        meter?: boolean;
+        meterLevels?: import('./types').PasswordStrengthLevel[];
+        rules?: import('./types').QPasswordFieldRule[];
+        icons?: import('./types').QPasswordFieldIcons;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        "onUpdate:masked"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: string) => any;
+        "update:masked": (value: boolean) => any;
+    }, import('vue').PublicProps, {
+        size: import('..').QFieldSize;
+        icons: import('./types').QPasswordFieldIcons;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        fieldRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | undefined;
+                readonly id?: string | undefined;
+                readonly class?: string | unknown[] | undefined;
+                readonly label?: string | undefined;
+                readonly for?: string | undefined;
+                readonly size?: import('..').QFieldSize | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly required?: boolean | undefined;
+                readonly invalid?: boolean | undefined;
+                readonly placeholder?: string | undefined;
+                readonly clearable?: boolean | undefined;
+                readonly type?: string | undefined;
+                readonly texts?: typeof import('../QTextField/types').DEFAULT_TEXTS | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                readonly "onClick:clear"?: ((event: Event) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                fieldRef: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly id?: string | undefined;
+                        readonly class?: string | unknown[] | undefined;
+                        readonly label?: string | undefined;
+                        readonly for?: string | undefined;
+                        readonly size?: import('..').QFieldSize | undefined;
+                        readonly readonly?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly required?: boolean | undefined;
+                        readonly invalid?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        fieldRef: HTMLDivElement;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('..').QFieldProps> & Readonly<{}>, {
+                        fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        size: import('..').QFieldSize;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import('vue').nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                } & Readonly<{
+                    size: import('..').QFieldSize;
+                }> & Omit<Readonly<import('..').QFieldProps> & Readonly<{}>, "size" | "fieldRef"> & import('vue').ShallowUnwrapRef<{
+                    fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        'label.prepend'?(_: {}): any;
+                        'label.append'?(_: {}): any;
+                        control?(_: {}): any;
+                        prepend?(_: {}): any;
+                        default?(_: {}): any;
+                        append?(_: {}): any;
+                        extras?(_: {}): any;
+                    };
+                }) | null;
+                inputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "update:modelValue", value: string) => void) & ((event: "click:clear", event: Event) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                modelValue?: string;
+            } & import('../../types/component').QBaseComponentProps & {
+                label?: string;
+                for?: string;
+            } & {
+                size?: import('..').QFieldSize;
+                readonly?: boolean;
+                disabled?: boolean;
+                required?: boolean;
+                invalid?: boolean;
+            } & {
+                placeholder?: string;
+                clearable?: boolean;
+                type?: string;
+                texts?: typeof import('../QTextField/types').DEFAULT_TEXTS;
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                "onClick:clear"?: ((event: Event) => any) | undefined;
+            }>, {
+                fieldRef: import('vue').ComputedRef<HTMLElement | null | undefined>;
+                inputRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: string) => any;
+            } & {
+                "click:clear": (event: Event) => any;
+            }, string, {
+                type: string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            type: string;
+        }> & Omit<Readonly<{
+            modelValue?: string;
+        } & import('../../types/component').QBaseComponentProps & {
+            label?: string;
+            for?: string;
+        } & {
+            size?: import('..').QFieldSize;
+            readonly?: boolean;
+            disabled?: boolean;
+            required?: boolean;
+            invalid?: boolean;
+        } & {
+            placeholder?: string;
+            clearable?: boolean;
+            type?: string;
+            texts?: typeof import('../QTextField/types').DEFAULT_TEXTS;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            "onClick:clear"?: ((event: Event) => any) | undefined;
+        }>, "type" | "fieldRef" | "inputRef"> & import('vue').ShallowUnwrapRef<{
+            fieldRef: import('vue').ComputedRef<HTMLElement | null | undefined>;
+            inputRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                'label.prepend'?(_: {}): any;
+                'label.append'?(_: {}): any;
+                prepend?(_: {}): any;
+                append?(_: {}): any;
+                extras?(_: {}): any;
+            };
+        }) | null;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: string;
+        masked?: boolean;
+    } & Omit<import('..').QTextFieldProps, "type" | "texts" | "clearable"> & {
+        toggle?: boolean;
+        meter?: boolean;
+        meterLevels?: import('./types').PasswordStrengthLevel[];
+        rules?: import('./types').QPasswordFieldRule[];
+        icons?: import('./types').QPasswordFieldIcons;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        "onUpdate:masked"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('..').QFieldSize;
+        icons: import('./types').QPasswordFieldIcons;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: string;
+    masked?: boolean;
+} & Omit<import('..').QTextFieldProps, "type" | "texts" | "clearable"> & {
+    toggle?: boolean;
+    meter?: boolean;
+    meterLevels?: import('./types').PasswordStrengthLevel[];
+    rules?: import('./types').QPasswordFieldRule[];
+    icons?: import('./types').QPasswordFieldIcons;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:masked"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "update:masked": (value: boolean) => any;
+}, string, {
+    size: import('..').QFieldSize;
+    icons: import('./types').QPasswordFieldIcons;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        'label.prepend'?(_: {}): any;
+        'label.append'?(_: {}): any;
+        prepend?(_: {}): any;
+        append?(_: {}): any;
+        extras?(_: {}): any;
+    };
+});
+export { QPasswordField };
+export type { QPasswordFieldProps };
+//# sourceMappingURL=index.d.ts.map

package/esm/components/QPasswordField/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QPasswordField/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAKlD,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAO+mzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAPlszB,CAAA;AAGvD,OAAO,EAAE,cAAc,EAAE,CAAA;AAGzB,YAAY,EAAE,mBAAmB,EAAE,CAAA"}

package/esm/components/QPasswordField/index.js

@@ -0,0 +1,6 @@
+import o from "./QPasswordField.vue.js";
+import { setupPropsProxy as r } from "../../utils/setupPropsProxy.js";
+const p = r(o);
+export {
+  p as QPasswordField
+};

package/esm/components/QPasswordField/types.d.ts

@@ -0,0 +1,100 @@
+import { DEFAULT_ICONS } from './constants';
+import { QOverlayProps } from '../QOverlay';
+import { QTextFieldProps } from '../QTextField';
+/**
+ * Represents a password strength level.
+ */
+export type PasswordStrengthLevel = {
+    /**
+     * The label describing this strength level (e.g., "Weak", "Strong").
+     */
+    label: string;
+    /**
+     * The maximum threshold value below which this strength level applies.
+     */
+    threshold?: number;
+    /**
+     * Optional color associated with this strength level (e.g., for UI representation).
+     */
+    color?: string;
+};
+/**
+ * Represents the strength of a password.
+ */
+export type PasswordStrengthEvalResult = {
+    /**
+     * The overall score of the password strength.
+     */
+    score: number;
+    /**
+     * An array of messages providing feedback on the password strength.
+     */
+    messages: string[];
+};
+/**
+ * Represents the icons used in the QPasswordField component.
+ */
+export type QPasswordFieldIcons = typeof DEFAULT_ICONS;
+/**
+ * Represents a rule for validating a password field.
+ */
+export type QPasswordFieldRule = {
+    /**
+     * A regular expression or a function to test the password.
+     */
+    test: RegExp | ((password: string) => boolean | string);
+    /**
+     * The weight of the rule.
+     */
+    weight: number;
+};
+/**
+ * Props for the QPasswordField component.
+ * Extends {@link QTextFieldProps} excluding 'type', 'clearable', and 'texts'.
+ */
+export type QPasswordFieldProps = Omit<QTextFieldProps, 'type' | 'clearable' | 'texts'> & {
+    /**
+     * Whether to provide a toggle to show the password as plain text.
+     */
+    toggle?: boolean;
+    /**
+     * Flag to enable the password strength meter.
+     */
+    meter?: boolean;
+    /**
+     * Configuration for the password strength meter.
+     */
+    meterLevels?: PasswordStrengthLevel[];
+    /**
+     * Array of password validation rules to be applied.
+     */
+    rules?: QPasswordFieldRule[];
+    /**
+     * Custom icon configurations.
+     */
+    icons?: QPasswordFieldIcons;
+};
+/**
+ * Props for the QPasswordFieldMessagesProps component.
+ */
+export type QPasswordFieldMessagesProps = {
+    /**
+     * The validation messages to display.
+     */
+    messages: string[];
+};
+/**
+ * Props for the QPasswordFieldMeterOverlay component.
+ * Extends {@link QOverlayProps} and {@link QPasswordFieldMessagesProps}.
+ */
+export type QPasswordFieldMeterOverlay = QOverlayProps & Partial<QPasswordFieldMessagesProps> & {
+    /**
+     * The current score.
+     */
+    score: number;
+    /**
+     * Configuration for the strength meter.
+     */
+    levels: PasswordStrengthLevel[];
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/components/QPasswordField/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QPasswordField/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAG3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IACnC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACxC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,aAAa,CAAA;AAEtD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAChC;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM,CAAC,CAAA;IAEvD;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,GAAG;IACzF;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;OAEG;IACH,WAAW,CAAC,EAAE,qBAAqB,EAAE,CAAA;IAErC;;OAEG;IACH,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAE5B;;OAEG;IACH,KAAK,CAAC,EAAE,mBAAmB,CAAA;CAC3B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACzC;;OAEG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,aAAa,GACrD,OAAO,CAAC,2BAA2B,CAAC,GAAG;IACtC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,MAAM,EAAE,qBAAqB,EAAE,CAAA;CAC/B,CAAA"}

package/esm/components/QSelect/QSelect.d.ts

@@ -30,6 +30,7 @@ declare function __VLS_template(): {
                 readonly readonly?: boolean | undefined;
                 readonly disabled?: boolean | undefined;
                 readonly required?: boolean | undefined;
+                readonly invalid?: boolean | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: {
                 [x: string]: unknown;
@@ -117,6 +118,7 @@ declare function __VLS_template(): {
                         readonly value: Primitive;
                         readonly label: string;
                         readonly icon?: import('../QIcon').Icon | undefined;
+                        readonly selectable?: boolean | undefined;
                         readonly selected?: boolean | undefined;
                         readonly highlighted?: boolean | undefined;
                         readonly disabled?: boolean | undefined;
@@ -300,6 +302,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
             readonly readonly?: boolean | undefined;
             readonly disabled?: boolean | undefined;
             readonly required?: boolean | undefined;
+            readonly invalid?: boolean | undefined;
         } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
         $attrs: {
             [x: string]: unknown;
@@ -387,6 +390,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
                     readonly value: Primitive;
                     readonly label: string;
                     readonly icon?: import('../QIcon').Icon | undefined;
+                    readonly selectable?: boolean | undefined;
                     readonly selected?: boolean | undefined;
                     readonly highlighted?: boolean | undefined;
                     readonly disabled?: boolean | undefined;

package/esm/components/QSelect/QSelect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QSelect.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/QSelect.vue"],"names":[],"mappings":"AAuHA;AAkUC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAatD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAG3C,OAAO,EAAY,QAAQ,EAAc,MAAM,KAAK,CAAA;AAEpD,KAAK,WAAW,GAAG,YAAY,CAAC;AA8LjC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,SAAS,CAAC;CACtB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAwTT,OAAO,IAA6B;;yBAnBpB,GAAG;wBACJ,GAAG;wBACH,GAAG;gCACK,GAAG;;;YACb,GAAG;+BACM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAoEG,GAAE,8CAGf,GAAG,yBAAyB,GAAG,6DAC/B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAJU,GAAE,8CAGf,GAAG,yBAAyB,GAAG,6DAC/B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAJU,GAAE,8CAGf,GAAG,yBAAyB,GAAG,6DAC/B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EArD/B;AAkCD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAcqB,GAAE,8CAGf,GAAG,yBAAyB,GAAG,6DAC/B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAJU,GAAE,8CAGf,GAAG,yBAAyB,GAAG,6DAC/B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAJU,GAAE,8CAGf,GAAG,yBAAyB,GAAG,6DAC/B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAT9B,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QSelect.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/QSelect.vue"],"names":[],"mappings":"AAwHA;AAmUC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAatD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAG3C,OAAO,EAAY,QAAQ,EAAc,MAAM,KAAK,CAAA;AAEpD,KAAK,WAAW,GAAG,YAAY,CAAC;AA8LjC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,SAAS,CAAC;CACtB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WA0TT,OAAO,IAA6B;;yBAnBpB,GAAG;wBACJ,GAAG;wBACH,GAAG;gCACK,GAAG;;;YACb,GAAG;+BACM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmE/B,GAAG,8CACJ,GAAG,yBAAyB,GAAG,6DAG1B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAJP,GAAG,8CACJ,GAAG,yBAAyB,GAAG,6DAG1B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAJP,GAAG,8CACJ,GAAG,yBAAyB,GAAG,6DAG1B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EApDd;AAkCD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAab,GAAG,8CACJ,GAAG,yBAAyB,GAAG,6DAG1B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAJP,GAAG,8CACJ,GAAG,yBAAyB,GAAG,6DAG1B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAJP,GAAG,8CACJ,GAAG,yBAAyB,GAAG,6DAG1B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OARb,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}