@aziontech/webkit 0.0.1

package/src/core/field-dropdown-multi-select-lazy-loader/field-dropdown-multi-select-lazy-loader.vue.d.ts

@@ -0,0 +1,162 @@
+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: ArrayConstructor;
+        default: () => never[];
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    moreOptions: {
+        type: ArrayConstructor;
+        default: null;
+    };
+    optionDisabled: {
+        type: (StringConstructor | FunctionConstructor)[];
+        default: string;
+    };
+    service: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: true;
+    };
+    loadService: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: true;
+    };
+    enableWorkaroundLabelToDisabledOptions: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableClearOption: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disableEmitFirstRender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    validationRules: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, {
+    refreshData: () => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    onBlur: (...args: any[]) => void;
+    onChange: (...args: any[]) => void;
+    onSelectOption: (...args: any[]) => void;
+    onAccessDenied: (...args: any[]) => void;
+    onClear: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    moreOptions: {
+        type: ArrayConstructor;
+        default: null;
+    };
+    optionDisabled: {
+        type: (StringConstructor | FunctionConstructor)[];
+        default: string;
+    };
+    service: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: true;
+    };
+    loadService: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: true;
+    };
+    enableWorkaroundLabelToDisabledOptions: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableClearOption: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disableEmitFirstRender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    validationRules: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onOnBlur?: ((...args: any[]) => any) | undefined;
+    onOnChange?: ((...args: any[]) => any) | undefined;
+    onOnSelectOption?: ((...args: any[]) => any) | undefined;
+    onOnAccessDenied?: ((...args: any[]) => any) | undefined;
+    onOnClear?: ((...args: any[]) => any) | undefined;
+}>, {
+    value: unknown[];
+    label: string;
+    placeholder: string;
+    description: string;
+    optionLabel: string;
+    optionDisabled: string | Function;
+    optionValue: string;
+    enableWorkaroundLabelToDisabledOptions: boolean;
+    moreOptions: unknown[];
+    enableClearOption: boolean;
+    disableEmitFirstRender: boolean;
+    validationRules: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    footer?: ((props: {}) => any) | undefined;
+} & {
+    description?: ((props: {}) => any) | undefined;
+};
+//# sourceMappingURL=field-dropdown-multi-select-lazy-loader.vue.d.ts.map

package/src/core/field-dropdown-multi-select-lazy-loader/field-dropdown-multi-select-lazy-loader.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-dropdown-multi-select-lazy-loader.vue.d.ts","sourceRoot":"","sources":["field-dropdown-multi-select-lazy-loader.vue"],"names":[],"mappings":"wBAukCqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AApEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAiEG"}

package/src/core/field-dropdown-multi-select-lazy-loader/package.json

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

package/src/core/field-group-checkbox/field-group-checkbox.vue

@@ -0,0 +1,102 @@
+<script setup>
+  import FieldCheckboxBlock from '../field-checkbox-block'
+  import { computed, ref } from 'vue'
+  import PrimeDivider from 'primevue/divider'
+
+  defineOptions({ name: 'FieldGroupCheckbox' })
+
+  const props = defineProps({
+    hideSelector: {
+      type: Boolean,
+      default: false
+    },
+    auto: {
+      type: Boolean,
+      default: false
+    },
+    isCard: {
+      type: Boolean,
+      default: true
+    },
+    label: {
+      type: String,
+      default: ''
+    },
+    options: {
+      type: Array,
+      required: true
+    },
+    helpText: {
+      type: String,
+      default: ''
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    hasDivider: {
+      type: Boolean,
+      default: true
+    }
+  })
+
+  const pickListSize = ref(props.options.length - 1)
+
+  const classStateRoot = computed(() => ({
+    'p-disabled': props.disabled
+  }))
+
+  const classListSelector = computed(() => ({
+    'flex-wrap': props.auto,
+    'flex-col': !props.auto,
+    'gap-3': props.isCard
+  }))
+
+  const showDivider = (position) => {
+    return position < pickListSize.value && !props.isCard
+  }
+
+  const isRenderDivider = (index) => {
+    return showDivider(index) && props.hasDivider
+  }
+</script>
+
+<template>
+  <div :class="['flex flex-col gap-2', classStateRoot]">
+    <label class="text-color text-base font-medium leading-5">
+      {{ props.label }}
+    </label>
+    <div
+      class="flex"
+      :class="classListSelector"
+    >
+      <template
+        v-for="(item, index) in props.options"
+        :key="index"
+      >
+        <FieldCheckboxBlock
+          :nameField="item.nameField"
+          :name="`${item.nameField}-checkbox-${index}`"
+          :auto="props.auto"
+          :hideSelector="props.hideSelector"
+          :isCard="props.isCard"
+          v-bind="item"
+        >
+          <template #footer>
+            <slot :item="item" />
+          </template>
+        </FieldCheckboxBlock>
+        <PrimeDivider
+          v-if="isRenderDivider(index)"
+          class="my-2"
+        />
+      </template>
+    </div>
+    <small
+      class="text-xs text-color-secondary font-normal leading-5"
+      v-if="props.helpText"
+    >
+      {{ props.helpText }}
+    </small>
+  </div>
+</template>

package/src/core/field-group-checkbox/field-group-checkbox.vue.d.ts

@@ -0,0 +1,87 @@
+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<{
+    hideSelector: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    auto: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isCard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    helpText: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasDivider: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    hideSelector: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    auto: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isCard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    helpText: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasDivider: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    label: string;
+    disabled: boolean;
+    auto: boolean;
+    isCard: boolean;
+    hideSelector: boolean;
+    helpText: string;
+    hasDivider: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {
+        item: unknown;
+    }) => any) | undefined;
+};
+//# sourceMappingURL=field-group-checkbox.vue.d.ts.map

package/src/core/field-group-checkbox/field-group-checkbox.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-group-checkbox.vue.d.ts","sourceRoot":"","sources":["field-group-checkbox.vue"],"names":[],"mappings":"wBAsTqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AAtCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAmCG"}

package/src/core/field-group-checkbox/package.json

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

package/src/core/field-group-radio/field-group-radio.vue

@@ -0,0 +1,149 @@
+<script setup>
+  import FieldRadioBlock from '../field-radio-block'
+  import { useField } from 'vee-validate'
+  import { computed, ref, toRefs, useAttrs } from 'vue'
+  import PrimeDivider from 'primevue/divider'
+
+  defineOptions({ name: 'FieldGroupRadio' })
+
+  const emit = defineEmits(['onRadioChange'])
+
+  const props = defineProps({
+    hideSelector: {
+      type: Boolean,
+      default: false
+    },
+    auto: {
+      type: Boolean,
+      default: false
+    },
+    isCard: {
+      type: Boolean,
+      default: true
+    },
+    label: {
+      type: String,
+      default: ''
+    },
+    options: {
+      type: Array,
+      required: true
+    },
+    helpText: {
+      type: String,
+      default: ''
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    nameField: {
+      type: String,
+      required: true
+    },
+    isRequired: {
+      type: Boolean,
+      default: false
+    }
+  })
+
+  const { nameField } = toRefs(props)
+  const { errorMessage } = useField(nameField)
+  const pickListSize = ref(props.options.length - 1)
+
+  const classStateRoot = computed(() => ({
+    'p-disabled': props.disabled
+  }))
+
+  const classListSelector = computed(() => ({
+    'flex-wrap': props.auto,
+    'flex-col': !props.auto,
+    'gap-3': props.isCard
+  }))
+
+  const showDivider = (position) => {
+    return position < pickListSize.value && !props.isCard
+  }
+
+  const attrs = useAttrs()
+
+  const customTestId = computed(() => {
+    const id = attrs['data-testid'] || 'field-radio'
+
+    return {
+      label: `${id}__label`,
+      radio: `${id}__radio`,
+      description: `${id}__description`,
+      error: `${id}__error-message`
+    }
+  })
+
+  const radioTestId = (name, nameField, index) => {
+    const remainder = name ?? `${nameField}-radio-${index}`
+    return `${customTestId.value.radio}__${remainder}`
+  }
+</script>
+
+<template>
+  <div :class="['flex flex-col gap-2', classStateRoot]">
+    <label
+      class="text-color text-base font-medium leading-5 flex gap-1 align-items-center"
+      :data-testid="customTestId.label"
+    >
+      {{ props.label }}
+      <div
+        v-if="props.isRequired"
+        class="text-sm text-orange-500 flex gap-1"
+      >
+        *
+        <span class="text-[0.625rem] text-color-secondary">(Required)</span>
+      </div>
+    </label>
+    <div
+      class="flex"
+      :class="classListSelector"
+    >
+      <template
+        v-for="(item, index) in props.options"
+        :key="index"
+      >
+        <FieldRadioBlock
+          v-show="!item.hide"
+          :nameField="props.nameField"
+          :name="item.name ?? `${props.nameField}-radio-${index}`"
+          :auto="props.auto"
+          :hideSelector="props.hideSelector"
+          :isCard="props.isCard"
+          v-bind="item"
+          @onRadioChange="emit('onRadioChange', item.inputValue)"
+          :data-testid="radioTestId(item.name, props.nameField, index)"
+        >
+          <template #footer>
+            <slot
+              name="footer"
+              :item="item"
+            />
+          </template>
+        </FieldRadioBlock>
+        <PrimeDivider
+          v-if="showDivider(index)"
+          class="my-2"
+        />
+      </template>
+    </div>
+    <small
+      class="text-xs text-color-secondary font-normal leading-5"
+      v-if="props.helpText"
+      :data-testid="customTestId.description"
+    >
+      {{ props.helpText }}
+    </small>
+    <small
+      v-if="errorMessage"
+      :data-testid="customTestId.error"
+      class="p-error text-xs font-normal leading-tight"
+    >
+      {{ errorMessage }}
+    </small>
+  </div>
+</template>

package/src/core/field-group-radio/field-group-radio.vue.d.ts

@@ -0,0 +1,99 @@
+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<{
+    hideSelector: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    auto: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isCard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    helpText: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nameField: {
+        type: StringConstructor;
+        required: true;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    onRadioChange: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    hideSelector: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    auto: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isCard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    helpText: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nameField: {
+        type: StringConstructor;
+        required: true;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onOnRadioChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    disabled: boolean;
+    auto: boolean;
+    isCard: boolean;
+    hideSelector: boolean;
+    helpText: string;
+    isRequired: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    footer?: ((props: {
+        item: unknown;
+    }) => any) | undefined;
+};
+//# sourceMappingURL=field-group-radio.vue.d.ts.map

package/src/core/field-group-radio/field-group-radio.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-group-radio.vue.d.ts","sourceRoot":"","sources":["field-group-radio.vue"],"names":[],"mappings":"wBAmbqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AA3CzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAwCG"}

package/src/core/field-group-radio/package.json

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