@antify/ui 4.1.37 → 4.1.38

package/dist/components/inputs/AntPhoneNumberInput.vue

@@ -0,0 +1,347 @@
+<script lang="ts" setup>
+import {
+  computed, watch,
+} from 'vue';
+import {
+  useVModel,
+} from '@vueuse/core';
+import AntField from '../forms/AntField.vue';
+import AntCountryInput from './AntCountryInput.vue';
+import AntBaseInput from './Elements/AntBaseInput.vue';
+import {
+  Size, InputState, Grouped,
+} from '../../enums';
+import {
+  BaseInputType,
+} from './Elements/__types';
+import {
+  COUNTRIES, CountryValueKey, Locale,
+} from '../../constants/countries';
+import type {
+  Country,
+} from '../../types';
+import {
+  ref, nextTick,
+} from 'vue';
+
+const phoneInputNativeRef = ref<HTMLInputElement | null>(null);
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(defineProps<{
+  modelValue: string | null;
+  countryValue: string | number | null;
+  countries?: Country[];
+
+  //Common Props
+  size?: Size;
+  state?: InputState;
+  disabled?: boolean;
+  readonly?: boolean;
+  skeleton?: boolean;
+
+  //AntField Props
+  label?: string;
+  description?: string;
+  messages?: string[];
+
+  //AntCountryInput Props
+  countryPlaceholder?: string;
+  searchPlaceholder?: string;
+  searchable?: boolean;
+  countryMaxHeight?: string;
+  countryValueKey?: CountryValueKey;
+  countryErrorMessage?: string;
+  countrySortable?: boolean;
+
+  //AntBaseInput Props
+  placeholder?: string;
+  nullable?: boolean;
+  locale?: Locale;
+}>(), {
+  size: Size.md,
+  state: InputState.base,
+  searchable: true,
+  searchPlaceholder: 'Search country...',
+  countryPlaceholder: 'Select country',
+  placeholder: 'Enter phone number',
+  countryValueKey: CountryValueKey.dialCode,
+  countryErrorMessage: 'Please select a country code or start with "+"',
+  countrySortable: true,
+  messages: () => [],
+  nullable: true,
+  countries: () => COUNTRIES,
+  locale: Locale.en,
+});
+
+const emit = defineEmits([
+  'update:modelValue',
+  'update:countryValue',
+  'select-country',
+  'validate',
+  'blur',
+]);
+
+const _countryValue = useVModel(props, 'countryValue', emit);
+const _phoneNumber = useVModel(props, 'modelValue', emit);
+
+const updateFullValue = (countryId: string | number | null, rawPhone: string | null) => {
+  if (!rawPhone) {
+    _phoneNumber.value = null;
+
+    return;
+  }
+
+  const country = props.countries.find(c => String(c[props.countryValueKey]) === String(countryId));
+
+  if (country && !rawPhone.startsWith('+')) {
+    const digitsOnly = rawPhone.replace(/\D/g, '');
+    _phoneNumber.value = `${country.dialCode}${digitsOnly}`;
+  } else {
+    _phoneNumber.value = rawPhone;
+  }
+};
+
+const showCountryError = computed(() => {
+  const val = props.modelValue || '';
+
+  return props.countryValue == null && val.length > 0 && !val.startsWith('+');
+});
+
+const allMessages = computed(() => {
+  const msgs = [
+    ...(props.messages || []),
+  ];
+
+  if (showCountryError.value) {
+    msgs.push(props.countryErrorMessage);
+  }
+
+  return msgs;
+});
+
+const currentCountry = computed(() => {
+  return props.countries.find(c => String(c[props.countryValueKey]) === String(props.countryValue));
+});
+
+const sortedCountriesByDialCode = computed(() => {
+  return [
+    ...props.countries,
+  ].sort((a, b) => b.dialCode.length - a.dialCode.length);
+});
+
+const findCountryByPhone = (phone: string): Country | undefined => {
+  if (!phone.startsWith('+')) {
+    return undefined;
+  }
+
+  return sortedCountriesByDialCode.value.find(country => phone.startsWith(country.dialCode));
+};
+
+const formattedNumber = computed({
+  get: () => {
+    const fullVal = props.modelValue || '';
+    const country = currentCountry.value;
+
+    if (country && fullVal.startsWith(country.dialCode)) {
+      const shortNumber = fullVal.slice(country.dialCode.length);
+
+      return country.mask ? formatByMask(shortNumber, country.mask) : shortNumber;
+    }
+
+    return fullVal;
+  },
+  set: (val: string | null) => {
+    if (!val) {
+      _phoneNumber.value = null;
+
+      return;
+    }
+
+    if (val.startsWith('+')) {
+      const country = findCountryByPhone(val);
+
+      if (country) {
+        _countryValue.value = country[props.countryValueKey] as string | number;
+      }
+
+      _phoneNumber.value = val;
+
+      return;
+    }
+
+    updateFullValue(_countryValue.value, val);
+  },
+});
+
+const formatByMask = (value: string | null, mask: string): string | null => {
+  if (!value) {
+    return null;
+  }
+
+  const digits = value.replace(/\D/g, '');
+  if (digits.length === 0) {
+    return null;
+  }
+
+  let result = '';
+  let digitIndex = 0;
+
+  for (let i = 0; i < mask.length; i++) {
+    if (mask[i] === '#') {
+      if (digitIndex < digits.length) {
+        result += digits[digitIndex];
+        digitIndex++;
+      } else {
+        break;
+      }
+    } else if (digitIndex < digits.length) {
+      result += mask[i];
+    }
+  }
+
+  if (digitIndex < digits.length) {
+    result += digits.substring(digitIndex);
+  }
+
+  return result || null;
+};
+
+function onCountrySelect(country: Country) {
+  emit('select-country', country);
+
+  nextTick(() => {
+    phoneInputNativeRef.value?.focus();
+  });
+}
+
+function onKeyPress(event: KeyboardEvent) {
+  const charStr = event.key;
+  const target = event.target as HTMLInputElement;
+  const currentRawValue = target.value;
+
+  if (event.ctrlKey || event.metaKey || charStr.length > 1) {
+    return;
+  }
+
+  if (!/[\d+]/.test(charStr)) {
+    event.preventDefault();
+
+    return;
+  }
+
+  if (props.countryValue && charStr === '+') {
+    event.preventDefault();
+
+    return;
+  }
+
+  if (!props.countryValue && charStr === '+' && currentRawValue.length > 0) {
+    event.preventDefault();
+  }
+
+  if (charStr === '+' && currentRawValue.includes('+')) {
+    event.preventDefault();
+  }
+}
+
+function onPaste(event: ClipboardEvent) {
+  event.preventDefault();
+  const pasteData = event.clipboardData?.getData('text') || '';
+
+  if (!pasteData) {
+    return;
+  }
+
+  const cleanInput = pasteData.replace(/[^\d+]/g, '');
+
+  if (cleanInput.startsWith('+')) {
+    const country = findCountryByPhone(cleanInput);
+
+    if (country) {
+      _countryValue.value = country[props.countryValueKey] as string | number;
+    }
+    _phoneNumber.value = cleanInput;
+  } else {
+    updateFullValue(_countryValue.value, cleanInput);
+  }
+}
+
+watch(_countryValue, (newCountryId, oldCountryId) => {
+  if (newCountryId === oldCountryId) {
+    return;
+  }
+
+  const fullVal = props.modelValue || '';
+  const oldCountry = props.countries.find(c => String(c[props.countryValueKey]) === String(oldCountryId));
+  let body = fullVal;
+
+  if (oldCountry && fullVal.startsWith(oldCountry.dialCode)) {
+    body = fullVal.slice(oldCountry.dialCode.length);
+  }
+
+  updateFullValue(newCountryId, body);
+});
+</script>
+
+<template>
+  <AntField
+    :label="label"
+    :messages="allMessages"
+    :state="showCountryError ? InputState.danger : state"
+    :size="size"
+    :skeleton="skeleton"
+    :description="description"
+    data-e2e="phone-input"
+  >
+    <div
+      class="flex relative w-full"
+      @click.prevent
+    >
+      <AntCountryInput
+        v-model="_countryValue"
+        :countries="countries"
+        :size="size"
+        :locale="locale"
+        :state="showCountryError ? InputState.danger : state"
+        :disabled="disabled"
+        :readonly="readonly"
+        :skeleton="skeleton"
+        :searchable="searchable"
+        :placeholder="countryPlaceholder"
+        :search-placeholder="searchPlaceholder"
+        :max-height="countryMaxHeight"
+        :is-grouped="true"
+        :grouped="Grouped.left"
+        class="w-fit flex-shrink-0"
+        :show-dial-code-in-menu="true"
+        :option-value-key="countryValueKey"
+        :sortable="countrySortable"
+        @select="onCountrySelect"
+      />
+
+      <AntBaseInput
+        v-model="formattedNumber"
+        v-model:input-ref="phoneInputNativeRef"
+        :nullable="nullable"
+        :type="BaseInputType.text"
+        :state="showCountryError ? InputState.danger : state"
+        :size="size"
+        :skeleton="skeleton"
+        v-bind="$attrs"
+        :disabled="disabled"
+        :readonly="readonly"
+        :placeholder="placeholder"
+        :grouped="Grouped.right"
+        wrapper-class="flex-grow"
+        class="-ml-px"
+        @validate="val => $emit('validate', val)"
+        @blur="e => $emit('blur', e)"
+        @keydown="onKeyPress"
+        @paste="onPaste"
+      />
+    </div>
+  </AntField>
+</template>

package/dist/components/inputs/Elements/AntSelectMenu.vue

@@ -30,6 +30,7 @@ const emit = defineEmits([
   'update:modelValue',
   'update:focused',
   'selectElement',
+  'clickOutside',
 ]);
 const props = withDefaults(defineProps<{
   modelValue: string | string[] | number | number[] | null;
@@ -76,6 +77,7 @@ onClickOutside(floating, () => {
   }
 
   emit('update:open', false);
+  emit('clickOutside');
 });
 
 const _modelValue = useVModel(props, 'modelValue', emit);

package/dist/components/inputs/__stories/AntCountryInput.stories.d.ts

@@ -0,0 +1,16 @@
+import { type Meta, type StoryObj } from '@storybook/vue3';
+import AntCountryInput from '../AntCountryInput.vue';
+declare const meta: Meta<typeof AntCountryInput>;
+export default meta;
+type Story = StoryObj<typeof AntCountryInput>;
+export declare const Docs: Story;
+export declare const ValueKeyNumericCode: Story;
+export declare const DefaultCountry: Story;
+export declare const DefaultByNumericCode: Story;
+export declare const Localization: Story;
+export declare const WithoutSearch: Story;
+export declare const WithoutFlags: Story;
+export declare const GroupedMode: Story;
+export declare const GermanEmptyState: Story;
+export declare const Skeleton: Story;
+export declare const summary: Story;

package/dist/components/inputs/__stories/AntCountryInput.stories.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.summary = exports.default = exports.WithoutSearch = exports.WithoutFlags = exports.ValueKeyNumericCode = exports.Skeleton = exports.Localization = exports.GroupedMode = exports.GermanEmptyState = exports.Docs = exports.DefaultCountry = exports.DefaultByNumericCode = void 0;
+var _AntCountryInput = _interopRequireDefault(require("../AntCountryInput.vue"));
+var _AntField = _interopRequireDefault(require("../../../components/forms/AntField.vue"));
+var _vue = require("vue");
+var _enums = require("../../../enums");
+var _countries = require("../../../constants/countries");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const meta = {
+  title: "Inputs/Country Input",
+  component: _AntCountryInput.default,
+  parameters: {
+    controls: {
+      sort: "requiredFirst"
+    }
+  },
+  argTypes: {
+    state: {
+      control: "select",
+      options: Object.values(_enums.InputState)
+    },
+    size: {
+      control: "select",
+      options: Object.values(_enums.Size)
+    },
+    grouped: {
+      control: {
+        type: "select"
+      },
+      options: Object.values(_enums.Grouped),
+      description: "Where is this fields position in a group"
+    },
+    locale: {
+      control: {
+        type: "select"
+      },
+      options: Object.values(_countries.Locale),
+      description: "Language for country labels"
+    },
+    optionValueKey: {
+      control: {
+        type: "select"
+      },
+      options: Object.values(_countries.CountryValueKey)
+    },
+    countries: {
+      table: {
+        disable: true
+      }
+    }
+  }
+};
+module.exports = meta;
+const MainRender = args => ({
+  components: {
+    AntCountryInput: _AntCountryInput.default
+  },
+  setup() {
+    const modelValue = (0, _vue.ref)(args.modelValue);
+    return {
+      args,
+      modelValue
+    };
+  },
+  template: `
+    <div>
+      <AntCountryInput v-bind="args" v-model="modelValue" />
+
+      <div class="mt-2 text-md text-base-400">
+        Selected Value ({{ args.optionValueKey || 'default' }}):
+        <span class="text-blue-500 font-bold">{{ modelValue === null ? 'null' : modelValue }}</span>
+      </div>
+    </div>
+  `
+});
+const Docs = exports.Docs = {
+  render: MainRender,
+  args: {
+    modelValue: null,
+    searchable: true,
+    countries: _countries.COUNTRIES
+  }
+};
+const ValueKeyNumericCode = exports.ValueKeyNumericCode = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    label: "Value as Numeric Code",
+    description: "Using the numericCode field from the data as the model value.",
+    optionValueKey: _countries.CountryValueKey.numericCode,
+    countries: _countries.COUNTRIES
+  }
+};
+const DefaultCountry = exports.DefaultCountry = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    label: "Default Country Logic",
+    description: 'Preselects Germany (DE) by providing modelValue: "DE" to the component.',
+    modelValue: "DE"
+  }
+};
+const DefaultByNumericCode = exports.DefaultByNumericCode = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    label: "Default by Numeric Code",
+    description: "Using numericCode: 33 (France) as the default value.",
+    optionValueKey: _countries.CountryValueKey.numericCode,
+    modelValue: 33
+  }
+};
+const Localization = exports.Localization = {
+  render: args => ({
+    components: {
+      AntCountryInput: _AntCountryInput.default
+    },
+    setup() {
+      const modelValue = (0, _vue.ref)("DE");
+      return {
+        args,
+        modelValue
+      };
+    },
+    template: `
+    <div class="flex flex-col gap-4">
+      <div>
+        <p class="text-xs text-base-400 mb-1">Current Locale: <b>{{ args.locale }}</b></p>
+        <AntCountryInput v-bind="args" v-model="modelValue" />
+      </div>
+
+      <div class="p-4 border border-dashed border-base-300 rounded-md bg-base-50">
+        <p class="text-sm italic text-base-500">
+          Try switching the <b>locale</b> control in the panel below to see labels change between
+          "Germany" (EN) and "Deutschland" (DE).
+        </p>
+      </div>
+    </div>
+  `
+  }),
+  args: {
+    ...Docs.args,
+    label: "Localized Selector",
+    locale: _countries.Locale.de,
+    searchPlaceholder: "Land suchen...",
+    description: "The labels and search logic adapt based on the provided locale."
+  }
+};
+const WithoutSearch = exports.WithoutSearch = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    label: "No Search Field",
+    searchable: false
+  }
+};
+const WithoutFlags = exports.WithoutFlags = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    label: "No Flags Mode",
+    showFlags: false
+  }
+};
+const GroupedMode = exports.GroupedMode = {
+  render: args => ({
+    components: {
+      AntCountryInput: _AntCountryInput.default,
+      AntField: _AntField.default
+    },
+    setup() {
+      const modelValue = (0, _vue.ref)(args.modelValue);
+      return {
+        args,
+        modelValue
+      };
+    },
+    template: `
+      <div>
+        <AntField
+          :label="args.label"
+          :description="args.description"
+          :size="args.size"
+          :state="args.state"
+        >
+          <div class="flex items-center">
+            <AntCountryInput
+              v-bind="args"
+              v-model="modelValue"
+              class="w-fit flex-shrink-0"
+            />
+
+            <div
+              class="flex-grow border border-l-0 p-2 text-sm text-base-400 bg-base-50 border-base-300 rounded-r-md h-[36px] flex items-center"
+            >
+              Input area...
+            </div>
+          </div>
+        </AntField>
+
+        <div class="mt-2 text-md text-base-400">
+          Value: {{ modelValue || null }}
+        </div>
+      </div>
+    `
+  }),
+  args: {
+    ...Docs.args,
+    label: "Grouped Mode (Phone Input Style)",
+    description: "When isGrouped is true, label and description must be provided by a parent AntField.",
+    isGrouped: true,
+    grouped: _enums.Grouped.left,
+    modelValue: "DE",
+    countries: _countries.COUNTRIES
+  }
+};
+const GermanEmptyState = exports.GermanEmptyState = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    label: "German Empty State",
+    description: 'Custom empty state message: "Keine L\xE4nder gefunden". Open the dropdown to see it.',
+    searchPlaceholder: "Land suchen...",
+    emptyStateMessage: "Keine L\xE4nder gefunden",
+    countries: []
+  }
+};
+const Skeleton = exports.Skeleton = {
+  render: MainRender,
+  args: {
+    ...Docs.args,
+    skeleton: true
+  }
+};
+const summary = exports.summary = {
+  parameters: {
+    chromatic: {
+      disableSnapshot: false
+    }
+  },
+  render: args => ({
+    components: {
+      AntCountryInput: _AntCountryInput.default
+    },
+    setup() {
+      const val = (0, _vue.ref)("DE");
+      return {
+        args,
+        val,
+        InputState: _enums.InputState,
+        Size: _enums.Size,
+        COUNTRIES: _countries.COUNTRIES
+      };
+    },
+    template: `
+      <div class="p-4 flex flex-col gap-6">
+        <div class="flex flex-wrap gap-4">
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :state="InputState.base" label="Base" class="w-64"/>
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :state="InputState.info" label="Info" class="w-64"/>
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :state="InputState.success" label="Success" class="w-64"/>
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :state="InputState.warning" label="Warning" class="w-64"/>
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :state="InputState.danger" label="Danger" class="w-64"/>
+        </div>
+
+        <div class="flex items-end gap-4">
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :size="Size.sm" label="Small" class="w-64"/>
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :size="Size.md" label="Medium" class="w-64"/>
+          <AntCountryInput v-bind="args" v-model="val" :countries="COUNTRIES" :size="Size.lg" label="Large" class="w-64"/>
+        </div>
+
+        <div class="flex gap-4">
+          <AntCountryInput v-bind="args" :countries="COUNTRIES" model-value="FR" disabled label="Disabled" class="w-64" />
+          <AntCountryInput v-bind="args" :countries="COUNTRIES" model-value="FR" readonly label="Readonly" class="w-64" />
+          <AntCountryInput v-bind="args" :countries="COUNTRIES" model-value="FR" skeleton label="Skeleton" class="w-64" />
+        </div>
+      </div>
+    `
+  }),
+  args: {
+    searchPlaceholder: "Search..."
+  }
+};