@aziontech/webkit 1.6.0 → 1.7.1

package/src/core/form/field-dropdown/field-dropdown.vue

@@ -82,7 +82,7 @@
       type: String,
       default: 'No results found'
     },
-    aditionalError: {
+    additionalError: {
       type: String,
       default: ''
     }
@@ -202,7 +202,7 @@
       :emptyFilterMessage="props.emptyFilterMessage"
       @change="emitChange"
       @blur="emitBlur"
-      :class="{ 'p-invalid': aditionalError || errorMessage }"
+      :class="{ 'p-invalid': additionalError || errorMessage }"
       v-bind="$attrs"
       :disabled="props.disabled"
       class="w-full"
@@ -224,11 +224,11 @@
     </Dropdown>
 
     <small
-      v-if="aditionalError || errorMessage"
+      v-if="additionalError || errorMessage"
       :data-testid="customTestId.error"
       class="p-error text-xs font-normal leading-tight"
     >
-      {{ aditionalError || errorMessage }}
+      {{ additionalError || errorMessage }}
     </small>
     <small
       class="text-xs text-color-secondary font-normal leading-5"

package/src/core/form/field-dropdown/field-dropdown.vue.d.ts

@@ -81,7 +81,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: StringConstructor;
         default: string;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -166,7 +166,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: StringConstructor;
         default: string;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -193,7 +193,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     editable: boolean;
     emptyMessage: string;
     emptyFilterMessage: string;
-    aditionalError: string;
+    additionalError: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 type __VLS_Slots = {
     footer?: ((props: {}) => any) | undefined;

package/src/core/form/field-group-switch/field-group-switch.vue.d.ts

@@ -73,8 +73,8 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>> & Readonly<{}>, {
     label: string;
     disabled: boolean;
-    inputClass: string;
     auto: boolean;
+    inputClass: string;
     isCard: boolean;
     hideSelector: boolean;
     helpText: string;

package/src/core/form/field-number/field-number.vue

@@ -57,7 +57,7 @@
       type: Boolean,
       default: true
     },
-    aditionalError: {
+    additionalError: {
       type: String,
       default: ''
     }
@@ -125,16 +125,16 @@
           name: props.name
         }
       }"
-      :class="[{ 'p-invalid': aditionalError || errorMessage }, props.inputClass]"
+      :class="[{ 'p-invalid': additionalError || errorMessage }, props.inputClass]"
       :data-testid="customTestId.input"
     />
 
     <small
-      v-if="aditionalError || errorMessage"
+      v-if="additionalError || errorMessage"
       class="p-error text-xs font-normal leading-tight"
       :data-testid="customTestId.error"
     >
-      {{ aditionalError || errorMessage }}
+      {{ additionalError || errorMessage }}
     </small>
     <small
       class="text-xs text-color-secondary font-normal leading-5"

package/src/core/form/field-number/field-number.vue.d.ts

@@ -51,7 +51,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: BooleanConstructor;
         default: boolean;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -109,7 +109,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: BooleanConstructor;
         default: boolean;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -124,7 +124,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     placeholder: string;
     readonly: boolean;
     inputClass: string;
-    aditionalError: string;
+    additionalError: string;
     step: number;
     showButtons: boolean;
     useGrouping: boolean;

package/src/core/form/{field-text-password/field-text-password.vue → field-password/field-password.vue}

@@ -42,7 +42,7 @@
       type: Boolean,
       default: false
     },
-    aditionalError: {
+    additionalError: {
       type: String,
       default: ''
     }
@@ -104,18 +104,18 @@
       :readonly="readonly"
       :disabled="disabled"
       :placeholder="props.placeholder"
-      :class="[{ 'p-invalid': aditionalError || veeValidateErrorMessage }, props.class]"
+      :class="[{ 'p-invalid': additionalError || veeValidateErrorMessage }, props.class]"
       :feedback="false"
       :data-testid="customTestId.input"
       @input="onChange"
       @blur="onBlur"
     />
     <small
-      v-if="aditionalError || veeValidateErrorMessage"
+      v-if="additionalError || veeValidateErrorMessage"
       class="p-error text-xs font-normal leading-tight"
       :data-testid="customTestId.error"
     >
-      {{ aditionalError || veeValidateErrorMessage }}
+      {{ additionalError || veeValidateErrorMessage }}
     </small>
     <small
       v-if="props.description || hasDescriptionSlot"

package/src/core/form/{field-text-password/field-text-password.vue.d.ts → field-password/field-password.vue.d.ts}

@@ -40,7 +40,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: BooleanConstructor;
         default: boolean;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -85,7 +85,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: BooleanConstructor;
         default: boolean;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -99,10 +99,10 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     value: string;
     placeholder: string;
     readonly: boolean;
-    aditionalError: string;
+    additionalError: string;
     sensitive: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 type __VLS_Slots = {
     description?: ((props: {}) => any) | undefined;
 };
-//# sourceMappingURL=field-text-password.vue.d.ts.map
+//# sourceMappingURL=field-password.vue.d.ts.map

package/src/core/form/field-password/field-password.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-password.vue.d.ts","sourceRoot":"","sources":["field-password.vue"],"names":[],"mappings":"wBAoZqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AA/CzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EA4CG"}

package/src/core/form/field-password/package.json

@@ -0,0 +1,11 @@
+{
+  "main": "./field-password.vue",
+  "module": "./field-password.vue",
+  "types": "./field-password.vue.d.ts",
+  "browser": {
+    "./sfc": "./field-password.vue"
+  },
+  "sideEffects": [
+    "*.vue"
+  ]
+}

package/src/core/form/field-password-strength/field-password-strength.vue

@@ -0,0 +1,209 @@
+<script setup>
+  import { computed, ref, toRef, useAttrs, useSlots } from 'vue'
+  import { useField } from 'vee-validate'
+  import Password from 'primevue/password'
+  import Divider from 'primevue/divider'
+  import Label from '../label'
+  import InputSlot from '../slots/input-slot'
+
+  const emit = defineEmits(['blur', 'input', 'submit', 'focus'])
+  const props = defineProps({
+    value: {
+      type: String,
+      default: ''
+    },
+    class: {
+      type: String,
+      default: ''
+    },
+    name: {
+      type: String,
+      required: true
+    },
+    label: {
+      type: String,
+      default: ''
+    },
+    placeholder: {
+      type: String,
+      default: ''
+    },
+    description: {
+      type: String,
+      default: ''
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    readonly: {
+      type: Boolean,
+      default: false
+    },
+    additionalError: {
+      type: String,
+      default: ''
+    },
+    promptLabel: {
+      type: String,
+      default: 'Choose a password'
+    },
+    weakLabel: {
+      type: String,
+      default: 'Weak'
+    },
+    mediumLabel: {
+      type: String,
+      default: 'Medium'
+    },
+    strongLabel: {
+      type: String,
+      default: 'Strong'
+    },
+    strongRegex: {
+      type: String,
+      default: '^(?=.*[-_!@#$%^&*(),.?":{}|<>])(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.{8,})'
+    },
+    requirements: {
+      type: Array,
+      default: () => [
+        { text: '8 characters' },
+        { text: '1 uppercase letter' },
+        { text: '1 lowercase letter' },
+        { text: '1 number' },
+        { text: '1 special character' }
+      ],
+      validator: (value) => value.every((item) => typeof item.text === 'string')
+    },
+    requirementsLabel: {
+      type: String,
+      default: 'Must have at least:'
+    }
+  })
+
+  const inputPasswordRef = ref(null)
+  const name = toRef(props, 'name')
+  const slots = useSlots()
+  const attrs = useAttrs()
+  const hasDescriptionSlot = computed(() => !!slots.description)
+
+  const hasError = computed(() => !!(props.additionalError || veeValidateErrorMessage.value))
+
+  const customTestId = computed(() => {
+    const id = attrs['data-testid'] || 'field-password-strength'
+
+    return {
+      label: `${id}__label`,
+      input: `${id}__input`,
+      description: `${id}__description`,
+      error: `${id}__error-message`
+    }
+  })
+
+  const {
+    value: inputValue,
+    errorMessage: veeValidateErrorMessage,
+    handleBlur,
+    handleChange
+  } = useField(name, undefined, {
+    initialValue: props.value
+  })
+
+  const onBlur = (event) => {
+    handleBlur(event)
+    emit('blur', event)
+  }
+
+  const onChange = (event) => {
+    handleChange(event)
+    emit('input', event?.target?.value ?? inputValue.value)
+  }
+
+  const onFocus = (event) => {
+    emit('focus', event)
+  }
+
+  const onKeydown = (event) => {
+    if (event.key === 'Enter' && !props.disabled && !props.readonly) {
+      event.preventDefault()
+      emit('submit', inputValue.value)
+    }
+  }
+
+  defineExpose({ inputPasswordRef })
+</script>
+
+<template>
+  <InputSlot>
+    <Label
+      v-if="props.label"
+      :for="props.name"
+      :data-testid="customTestId.label"
+      :label="props.label"
+      :isRequired="attrs.required"
+    />
+    <Password
+      toggleMask
+      ref="inputPasswordRef"
+      v-model="inputValue"
+      :id="name"
+      :name="name"
+      :readonly="readonly"
+      :disabled="disabled"
+      :placeholder="props.placeholder"
+      :class="[{ 'p-invalid': hasError }, props.class]"
+      :aria-invalid="hasError"
+      :aria-describedby="`${name}-error ${name}-description`"
+      :promptLabel="props.promptLabel"
+      :weakLabel="props.weakLabel"
+      :mediumLabel="props.mediumLabel"
+      :strongLabel="props.strongLabel"
+      :strongRegex="props.strongRegex"
+      :pt="{ meter: 'rounded-md', meterLabel: 'text-sm' }"
+      :data-testid="customTestId.input"
+      autocomplete="off"
+      @input="onChange"
+      @blur="onBlur"
+      @focus="onFocus"
+      @keydown="onKeydown"
+    >
+      <template #header> </template>
+      <template #footer v-if="props.requirements.length">
+        <div class="mt-4 text-sm space-y-4">
+          <Divider />
+          <p class="font-medium">{{ props.requirementsLabel }}</p>
+        </div>
+        <div class="text-sm p-4 py-0 mt-2">
+          <ul
+            :aria-label="props.requirementsLabel"
+            class="list-square font-normal space-y-2 text-color-secondary"
+          >
+            <li v-for="(requirement, index) in props.requirements" :key="requirement.text || index">
+              <span>{{ requirement.text }}</span>
+            </li>
+          </ul>
+        </div>
+      </template>
+    </Password>
+    <small
+      v-if="hasError"
+      :id="`${name}-error`"
+      role="alert"
+      aria-live="assertive"
+      class="p-error text-xs font-normal leading-tight"
+      :data-testid="customTestId.error"
+    >
+      {{ additionalError || veeValidateErrorMessage }}
+    </small>
+    <small
+      v-if="props.description || hasDescriptionSlot"
+      :id="`${name}-description`"
+      class="text-xs text-color-secondary font-normal leading-5"
+      :data-testid="customTestId.description"
+    >
+      <slot name="description">
+        {{ props.description }}
+      </slot>
+    </small>
+  </InputSlot>
+</template>

package/src/core/form/field-password-strength/field-password-strength.vue.d.ts

@@ -0,0 +1,175 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    additionalError: {
+        type: StringConstructor;
+        default: string;
+    };
+    promptLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    weakLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    mediumLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    strongLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    strongRegex: {
+        type: StringConstructor;
+        default: string;
+    };
+    requirements: {
+        type: ArrayConstructor;
+        default: () => {
+            text: string;
+        }[];
+        validator: (value: unknown) => any;
+    };
+    requirementsLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    inputPasswordRef: import("vue").Ref<null, null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+    blur: (...args: any[]) => void;
+    focus: (...args: any[]) => void;
+    submit: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    additionalError: {
+        type: StringConstructor;
+        default: string;
+    };
+    promptLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    weakLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    mediumLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    strongLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    strongRegex: {
+        type: StringConstructor;
+        default: string;
+    };
+    requirements: {
+        type: ArrayConstructor;
+        default: () => {
+            text: string;
+        }[];
+        validator: (value: unknown) => any;
+    };
+    requirementsLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onInput?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onSubmit?: ((...args: any[]) => any) | undefined;
+}>, {
+    description: string;
+    label: string;
+    class: string;
+    disabled: boolean;
+    value: string;
+    placeholder: string;
+    readonly: boolean;
+    additionalError: string;
+    promptLabel: string;
+    strongRegex: string;
+    weakLabel: string;
+    mediumLabel: string;
+    strongLabel: string;
+    requirements: unknown[];
+    requirementsLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    description?: ((props: {}) => any) | undefined;
+};
+//# sourceMappingURL=field-password-strength.vue.d.ts.map

package/src/core/form/field-password-strength/field-password-strength.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-password-strength.vue.d.ts","sourceRoot":"","sources":["field-password-strength.vue"],"names":[],"mappings":"wBA+oBqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AA/EzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EA4EG"}

package/src/core/form/field-password-strength/package.json

@@ -0,0 +1,11 @@
+{
+  "main": "./field-password-strength.vue",
+  "module": "./field-password-strength.vue",
+  "types": "./field-password-strength.vue.d.ts",
+  "browser": {
+    "./sfc": "./field-password-strength.vue"
+  },
+  "sideEffects": [
+    "*.vue"
+  ]
+}

package/src/core/form/field-radio-block/field-radio-block.vue.d.ts

@@ -102,8 +102,8 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     onOnRadioChange?: ((...args: any[]) => any) | undefined;
 }>, {
     disabled: boolean;
-    inputValue: string | boolean | Record<string, any>;
     auto: boolean;
+    inputValue: string | boolean | Record<string, any>;
     isCard: boolean;
     hideSelector: boolean;
     isLabel: boolean;

package/src/core/form/field-switch-block/field-switch-block.vue.d.ts

@@ -111,8 +111,8 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>, {
     disabled: boolean;
     value: boolean;
-    readonly: boolean;
     auto: boolean;
+    readonly: boolean;
     isCard: boolean;
     hideSelector: boolean;
     isLabel: boolean;

package/src/core/form/field-text/field-text.vue

@@ -42,7 +42,7 @@
       type: Boolean,
       default: false
     },
-    aditionalError: {
+    additionalError: {
       type: String,
       default: ''
     }
@@ -106,17 +106,17 @@
       :readonly="readonly"
       :disabled="disabled"
       :placeholder="props.placeholder"
-      :class="[{ 'p-invalid': aditionalError || veeValidateErrorMessage }, props.class]"
+      :class="[{ 'p-invalid': additionalError || veeValidateErrorMessage }, props.class]"
       @input="onChange"
       @keypress.enter.prevent
       @blur="onBlur"
     />
     <small
-      v-if="aditionalError || veeValidateErrorMessage"
+      v-if="additionalError || veeValidateErrorMessage"
       class="p-error text-xs font-normal leading-tight"
       :data-testid="customTestId.error"
     >
-      {{ aditionalError || veeValidateErrorMessage }}
+      {{ additionalError || veeValidateErrorMessage }}
     </small>
     <small
       v-if="props.description || hasDescriptionSlot"

package/src/core/form/field-text/field-text.vue.d.ts

@@ -40,7 +40,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: BooleanConstructor;
         default: boolean;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -85,7 +85,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: BooleanConstructor;
         default: boolean;
     };
-    aditionalError: {
+    additionalError: {
         type: StringConstructor;
         default: string;
     };
@@ -99,7 +99,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     value: string;
     placeholder: string;
     readonly: boolean;
-    aditionalError: string;
+    additionalError: string;
     sensitive: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 type __VLS_Slots = {