@adyen/kyc-components 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/types/hooks/useForm/types.d.ts

@@ -37,8 +37,6 @@ export interface BaseFormFieldProps<FieldSchema> {
     guidanceText?: Partial<Record<keyof FieldSchema, string>>;
     placeholders?: Partial<Record<keyof FieldSchema, string>>;
     className?: string;
-    /** @deprecated */
-    classNameModifiers?: string[];
     name?: string;
     requiredFields?: Partial<Array<keyof FieldSchema>>;
     handleChangeFor: (key: keyof FieldSchema, mode?: ValidatorMode) => (e: any) => void;

package/dist/types/hooks/useLegalCompanyNameField/useLegalCompanyNameField.d.ts

@@ -0,0 +1,28 @@
+import type { JSX } from 'preact';
+import type { Form } from '../useForm/types';
+import type { CountryCode } from '../../types/datasets/country-code';
+import type { FormUtils } from '../../utils/formUtils';
+interface UseLegalCompanyNameFieldProps<FormSchema> extends Omit<Form<FormSchema>, 'setFieldProblems' | 'setData' | 'setErrors' | 'setValid' | 'triggerValidation' | 'mergeForm' | 'resetToDefaultData' | 'schema'> {
+    data: FormSchema;
+    country: CountryCode;
+    formUtils: FormUtils<FormSchema>;
+    fieldOptions: {
+        [key in keyof FormSchema]: {
+            onInput: (e: any) => void;
+            onBlur: (e: FocusEvent) => void;
+        };
+    };
+}
+export declare function useLegalCompanyNameField<FormSchema>({ data, valid, errors, fieldProblems, country, formUtils, fieldOptions, }: UseLegalCompanyNameFieldProps<FormSchema>): ({
+    name: string;
+    value: string;
+    readonly: boolean;
+    onInput: (e: any) => void;
+    onBlur: (e: FocusEvent) => void;
+    isValid: Record<keyof FormSchema, boolean>[keyof FormSchema];
+    errorMessage: Record<keyof FormSchema, boolean | import("../../../types").Translatable>[keyof FormSchema];
+    label: Partial<Record<keyof FormSchema, string>>[keyof FormSchema];
+    helper: Partial<Record<keyof FormSchema, string>>[keyof FormSchema];
+    onKeyDown: (e: JSX.TargetedKeyboardEvent<HTMLInputElement>) => void;
+} | undefined)[];
+export {};

package/dist/types/hooks/useMultiForm/types.d.ts

@@ -20,44 +20,43 @@ export interface FormState<InnerFormSchema> {
     dataStoreId?: string;
     local?: FormState<InnerFormSchema> | Partial<FormState<InnerFormSchema>>;
 }
+export type FormName<T> = keyof {
+    [InnerFormName in keyof T]: T[InnerFormName];
+};
+export type NestedSchema<T> = T[keyof T];
 export interface Form<T> extends MultiFormState<T> {
-    setData: (key: keyof NestedSchema<T>, value: FieldValue<NestedSchema<T>>, formName: FormName<T>) => void;
+    setData<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: FieldValue<NestedSchema<T>>, formName: InnerFormName): void;
     setFormData: <FN extends FormName<T>>(formName: FN, formData: T[FN]) => void;
-    setValid: (key: keyof NestedSchema<T>, value: boolean, formName: FormName<T>) => void;
-    setErrors: (key: keyof NestedSchema<T>, value: ValidationRuleResult | null, formName: FormName<T>) => void;
+    setValid<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: boolean, formName: InnerFormName): void;
+    setErrors<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: ValidationRuleResult | null, formName: InnerFormName): void;
     handleChangeFor<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], formName: InnerFormName, mode?: ValidatorMode): (e: any) => void;
-    triggerValidation: (formName: FormName<T>, selectedSchema?: (keyof NestedSchema<T>)[]) => Promise<boolean>;
+    triggerValidation<InnerFormName extends keyof T>(formName: InnerFormName, selectedSchema?: Array<keyof Required<T>[InnerFormName]>): Promise<boolean>;
     resetToDefaultData: () => void;
     defaultData?: T;
 }
-export type FormName<T> = keyof {
-    [InnerFormName in keyof T]: T[InnerFormName];
+export type NestedErrorState<InnerFormSchema> = {
+    [FieldName in keyof InnerFormSchema]: ValidationRuleResult | null;
+};
+export type NestedValidState<InnerFormSchema> = {
+    [FieldName in keyof InnerFormSchema]: boolean;
+};
+export type MultiFormErrorState<TopLevelSchema> = {
+    [InnerFormName in keyof TopLevelSchema]: NestedErrorState<TopLevelSchema[InnerFormName]>;
+};
+export type MultiFormValidState<TopLevelSchema> = {
+    [InnerFormName in keyof TopLevelSchema]: NestedValidState<TopLevelSchema[InnerFormName]>;
 };
-export type NestedSchema<T> = T[keyof T];
 export type MultiFormState<T> = {
-    requiredFields?: {
-        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
-    };
     data: T;
-    errors: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: ValidationRuleResult | null;
-        };
-    };
-    asyncErrors: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: ValidationRuleResult | null;
-        };
-    };
-    valid: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: boolean;
-        };
+    errors: MultiFormErrorState<T>;
+    asyncErrors: MultiFormErrorState<T>;
+    valid: MultiFormValidState<T>;
+    fieldProblems: MultiFormValidState<T>;
+    allFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
-    fieldProblems: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: boolean;
-        };
+    requiredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
     obscuredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
@@ -77,11 +76,6 @@ export type MultiFormState<T> = {
     defaultData?: T;
 };
 export interface MultiFormOptions<T> {
-    requiredFields?: {
-        [InnerFormName in keyof T]: (keyof Required<T[InnerFormName]>)[];
-    } | ((data: T | undefined) => {
-        [InnerFormName in keyof T]: (keyof T[InnerFormName])[];
-    });
     defaultData?: T;
     rules?: {
         [InnerFormName in keyof T]: ValidatorRules<T[InnerFormName]>;
@@ -101,12 +95,20 @@ export interface MultiFormOptions<T> {
             [FieldName in keyof T[InnerFormName]]: boolean;
         };
     };
-    obscuredFields?: {
+    allFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    requiredFields?: {
+        [InnerFormName in keyof T]: (keyof Required<T[InnerFormName]>)[];
+    } | ((data: T | undefined) => {
+        [InnerFormName in keyof T]: (keyof T[InnerFormName])[];
+    });
     optionalFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
     trustedFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };

package/dist/types/hooks/useMultiForm/useMultiForm.d.ts

@@ -1,2 +1,2 @@
 import type { Form, MultiFormOptions } from './types';
-export declare function useMultiForm<FormSchema>({ requiredFields, defaultData, rules, asyncRules, fieldProblems, obscuredFields, optionalFields, trustedFields, formatters, }: MultiFormOptions<FormSchema>): Form<FormSchema>;
+export declare function useMultiForm<FormSchema>({ defaultData, rules, asyncRules, fieldProblems, allFields, requiredFields, obscuredFields, optionalFields, trustedFields, formatters, }: MultiFormOptions<FormSchema>): Form<FormSchema>;

package/dist/types/language/Language.d.ts

@@ -3,7 +3,6 @@ import type { GetTranslationOptions } from './utils';
 export declare class Language {
     private readonly supportedLocales;
     readonly translations: Translations;
-    readonly languageCode: string;
     readonly locale: string;
     constructor({ locale, translations, allowedLocales, }: {
         locale?: string;
@@ -13,12 +12,7 @@ export declare class Language {
     /**
      * Returns a translated string from a key in the current {@link Language.locale}
      * @returns Translated string in the user's locale
+     * @deprecated we now have i18next for i18n, check out {@link /src/language/README.md} for more details and examples
      */
     get(translatable: Translatable, translationOptions?: GetTranslationOptions): string;
-    /**
-     * Returns a localized string for a date
-     * @param date - Date to be localized
-     * @param options - Options for {@link Intl.DateTimeFormatOptions}
-     */
-    date(date: string, options?: Intl.DateTimeFormatOptions): string;
 }

package/dist/types/language/i18n.d.ts

@@ -0,0 +1,2 @@
+import i18n from 'i18next';
+export default i18n;

package/dist/types/language/types.d.ts

@@ -1,3 +1,4 @@
+import type introductionKeys from '#shared/language/introduction/en-US.json';
 import type translations from './locales/en-US.json';
 export type TranslationKey = keyof typeof translations;
 export type TranslationItem = string;
@@ -7,3 +8,5 @@ export type TranslationObject = {
     values: Record<string, string>;
 };
 export type Translatable = TranslationKey | TranslationObject;
+export type CommonKey = keyof typeof translations;
+export type IntroductionKey = keyof typeof introductionKeys;

package/dist/types/language/utils.d.ts

@@ -1,5 +1,6 @@
+import type { TFunction } from 'i18next';
 import type { CountryCode } from '../types/datasets/country-code';
-import type { TranslationItem, TranslationKey, Translations } from './types';
+import type { Translatable, TranslationItem, TranslationKey, Translations } from './types';
 /**
  * Matches a string with one of the locales
 
@@ -31,7 +32,6 @@ export interface GetTranslationOptions {
  * Returns a translation string by key
  */
 export declare const getTranslationByKey: (translations: Translations, key: TranslationKey, options?: GetTranslationOptions) => TranslationItem | null;
-export declare const getTranslationKeysByPrefix: (translations: Translations, keyPrefix: string) => TranslationKey[];
 /**
  * Returns a LanguageCode from locale
  * @param locale - The locale the user wants to use
@@ -40,3 +40,12 @@ export declare const getTranslationKeysByPrefix: (translations: Translations, ke
  * // returns 'en'
  */
 export declare const getLanguageCode: (locale: string) => string;
+/**
+ * A helper function to translate a `Translatable` type, which can be either a simple string key
+ * or an object with a key and values for interpolation. It uses the provided `i18next` `t` function.
+ *
+ * @param t - The `i18next` translation function.
+ * @param translatable - The string or object to translate.
+ * @returns The translated string.
+ */
+export declare const translateStringOrObject: (t: TFunction, translatable: Translatable) => string;