@ikas/storefront 0.0.40 → 0.0.41

package/build/models/ui/index.d.ts

@@ -5,3 +5,11 @@ export { IkasNavigationLink } from "./navigation-link/index";
 export { IkasProductDetail } from "./product-detail/index";
 export { IkasProductList, IkasProductListType, IkasProductListSortType, } from "./product-list/index";
 export { IkasProductListFilter } from "./product-list/filter";
+export { Validator, ValidationStatus } from "./validator/index";
+export * from "./validator/rules/index";
+export { LoginForm } from "./validator/form/login";
+export { AddressForm } from "./validator/form/address";
+export { RegisterForm } from "./validator/form/register";
+export { ForgotPasswordForm } from "./validator/form/forgot-password";
+export { RecoverPasswordForm } from "./validator/form/recover-password";
+export { AccountInfoForm } from "./validator/form/account-info";

package/build/models/ui/validator/form/account-info.d.ts

@@ -0,0 +1,40 @@
+import { PhoneRule, RequiredRule } from "../rules/index";
+import { IkasBaseStore } from "../../../../store/index";
+import { IkasCustomer } from "../../../index";
+declare type AccountInfoFormPropsValidatorMessage<T> = {
+    requiredRule: ((model: T) => string) | string;
+    phoneRule?: ((model: T) => string) | string;
+};
+declare type AccountInfoFormProps<T> = {
+    message: AccountInfoFormPropsValidatorMessage<T>;
+    customer: IkasCustomer;
+    store: IkasBaseStore;
+};
+export declare class AccountInfoForm {
+    private customer;
+    private validator;
+    private store;
+    private message;
+    constructor(props: AccountInfoFormProps<IkasCustomer>);
+    validatorRules: (includePhoneRule?: boolean) => (RequiredRule<IkasCustomer> | PhoneRule<IkasCustomer>)[];
+    get hasError(): boolean;
+    get email(): string;
+    get firstName(): string;
+    set firstName(value: string);
+    get lastName(): string;
+    set lastName(value: string);
+    get phone(): string;
+    set phone(value: string);
+    get firstNameErrorMessage(): string | undefined;
+    get lastNameErrorMessage(): string | undefined;
+    get phoneErrorMessage(): string | undefined;
+    onFirstNameChange: (value: string) => void;
+    onLastNameChange: (value: string) => void;
+    onPhoneChange: (value: string) => void;
+    validateAll(): Promise<boolean>;
+    submit(): Promise<{
+        isFormError: boolean;
+        isSuccess: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/form/address.d.ts

@@ -0,0 +1,72 @@
+import { IkasCity, IkasCountry, IkasCustomerAddress, IkasDistrict, IkasState } from "../../../data/index";
+import { IkasBaseStore } from "../../../../store/index";
+declare type AddressFormProps<T> = {
+    message: {
+        requiredRule: ((model: T) => string) | string;
+        phoneRule: ((model: T) => string) | string;
+    };
+    address: IkasCustomerAddress;
+    store: IkasBaseStore;
+};
+export declare class AddressForm {
+    address: IkasCustomerAddress;
+    countries: IkasCountry[];
+    states: IkasState[];
+    cities: IkasCity[];
+    districts: IkasDistrict[];
+    private _isCountriesPending;
+    private _isStatesPending;
+    private _isCitiesPending;
+    private _isDistrictsPending;
+    private store;
+    private validator;
+    constructor(props: AddressFormProps<IkasCustomerAddress>);
+    onTitleChange: (value: string) => void;
+    onFirstNameChange: (value: string) => void;
+    onLastNameChange: (value: string) => void;
+    onPhoneChange: (value: string) => void;
+    onAddressLine1Change: (value: string) => void;
+    onAddressLine2Change: (value: string) => void;
+    onAddressPostalCodeChange: (value: string) => void;
+    onCountryChange: (countryId: string) => void;
+    onStateChange: (stateId: string) => void;
+    onCityChange: (cityId: string) => void;
+    onDistrictChange: (districtId: string) => void;
+    onDistrictInputChange: (value: string) => void;
+    listCountries: () => Promise<void>;
+    listStates: () => Promise<void>;
+    listCities: () => Promise<void>;
+    listDistricts: () => Promise<void>;
+    get isEdit(): boolean;
+    private get editingAddressIndex();
+    get countryOptions(): {
+        label: string;
+        value: string;
+    }[];
+    get stateOptions(): {
+        label: string;
+        value: string;
+    }[];
+    get cityOptions(): {
+        label: string;
+        value: string;
+    }[];
+    get districtOptions(): {
+        label: string;
+        value: string;
+    }[];
+    get hasState(): boolean;
+    get isCountriesPending(): boolean;
+    get isStatesPending(): boolean;
+    get isCitiesPending(): boolean;
+    get isDistrictsPending(): boolean;
+    get hasValidatorError(): boolean;
+    get results(): import("../index").ValidationResults;
+    validateAll: () => Promise<boolean>;
+    submit: () => Promise<{
+        isFormError: boolean;
+        isAPIError: boolean;
+        isSuccess: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/form/forgot-password.d.ts

@@ -0,0 +1,29 @@
+import { IkasBaseStore } from "../../../../store/index";
+declare type ForgotPasswordProps<T> = {
+    message: {
+        requiredRule: ((model: T) => string) | string;
+        emailRule: ((model: T) => string) | string;
+    };
+    store: IkasBaseStore;
+};
+declare type ForgotPasswordFormModel = {
+    email: string;
+};
+export declare class ForgotPasswordForm {
+    private model;
+    private validator;
+    private store;
+    constructor(props: ForgotPasswordProps<ForgotPasswordFormModel>);
+    get email(): string;
+    set email(value: string);
+    onEmailChange: (value: string) => void;
+    get hasValidatorError(): boolean;
+    get emailErrorMessage(): string | undefined;
+    get redirect(): string | null | undefined;
+    validateAll(): Promise<boolean>;
+    submit(): Promise<{
+        isFormError: boolean;
+        isAPIError: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/form/login.d.ts

@@ -0,0 +1,35 @@
+import { IkasBaseStore } from "../../../../store/index";
+declare type LoginFormProps<T> = {
+    message: {
+        requiredRule: ((model: T) => string) | string;
+        emailRule: ((model: T) => string) | string;
+        minRule: ((model: T) => string) | string;
+    };
+    store: IkasBaseStore;
+};
+declare type LoginFormModel = {
+    email: string;
+    password: string;
+};
+export declare class LoginForm {
+    private model;
+    private validator;
+    private store;
+    constructor(props: LoginFormProps<LoginFormModel>);
+    get hasError(): boolean;
+    get email(): string;
+    set email(value: string);
+    get password(): string;
+    set password(value: string);
+    get emailErrorMessage(): string | undefined;
+    get passwordErrorMessage(): string | undefined;
+    get redirect(): string | null | undefined;
+    onEmailChange: (value: string) => void;
+    onPasswordChange: (value: string) => void;
+    validateAll(): Promise<boolean>;
+    logIn(): Promise<{
+        isFormError: boolean;
+        isLoginError: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/form/recover-password.d.ts

@@ -0,0 +1,36 @@
+import { IkasBaseStore } from "../../../../store/index";
+declare type RecoverPasswordFormProps<T> = {
+    message: {
+        requiredRule: ((model: T) => string) | string;
+        minRule: ((model: T) => string) | string;
+        equalsRule: ((model: T) => string) | string;
+    };
+    store: IkasBaseStore;
+};
+declare type RecoverPasswordFormModel = {
+    password: string;
+    passwordAgain: string;
+};
+export declare class RecoverPasswordForm {
+    private model;
+    private validator;
+    private store;
+    constructor(props: RecoverPasswordFormProps<RecoverPasswordFormModel>);
+    resetModel(): void;
+    get password(): string;
+    set password(value: string);
+    get passwordAgain(): string;
+    set passwordAgain(value: string);
+    get hasError(): boolean;
+    get passwordErrorMessage(): string | undefined;
+    get passwordAgainErrorMessage(): string | undefined;
+    get redirect(): string | null | undefined;
+    onPasswordChange: (value: string) => void;
+    onPasswordAgainChange: (value: string) => void;
+    validateAll(): Promise<boolean>;
+    submit(): Promise<{
+        isFormError: boolean;
+        isAPIError: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/form/register.d.ts

@@ -0,0 +1,45 @@
+import { IkasBaseStore } from "../../../../store/index";
+declare type RegisterFormProps<T> = {
+    message: {
+        requiredRule: ((model: T) => string) | string;
+        emailRule: ((model: T) => string) | string;
+        minRule: ((model: T) => string) | string;
+    };
+    store: IkasBaseStore;
+};
+declare type RegisterFormModel = {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+};
+export declare class RegisterForm {
+    private model;
+    private validator;
+    private store;
+    constructor(props: RegisterFormProps<RegisterFormModel>);
+    get firstName(): string;
+    set firstName(value: string);
+    get lastName(): string;
+    set lastName(value: string);
+    get email(): string;
+    set email(value: string);
+    get password(): string;
+    set password(value: string);
+    get hasError(): boolean;
+    get firstNameErrorMessage(): string | undefined;
+    get lastNameErrorMessage(): string | undefined;
+    get emailErrorMessage(): string | undefined;
+    get passwordErrorMessage(): string | undefined;
+    get redirect(): string | null | undefined;
+    onFirstNameChange: (value: string) => void;
+    onLastNameChange: (value: string) => void;
+    onEmailChange: (value: string) => void;
+    onPasswordChange: (value: string) => void;
+    validateAll(): Promise<boolean>;
+    register(): Promise<{
+        isFormError: boolean;
+        isRegisterError: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/index.d.ts

@@ -0,0 +1,27 @@
+import { ValidatorErrorType, ValidationRule } from "./rules/index";
+export declare type ValidationResults = {
+    [fieldKey: string]: ValidationResult;
+};
+export declare type ValidationStatus = "success" | "warning" | "error" | "validating";
+export declare class Validator<T = any> {
+    model: T;
+    rules: ValidationRule[];
+    results: ValidationResults;
+    constructor(model: T, rules: ValidationRule[]);
+    get hasError(): boolean;
+    onValueChange: (validationRule: ValidationRule) => void;
+    setRules(rules: ValidationRule[]): void;
+    validateAll(): Promise<boolean>;
+    validateFieldRules(fieldKey: string): Promise<void>;
+    private runRules;
+}
+declare class ValidationResult {
+    fieldKey: string;
+    status?: ValidationStatus;
+    messages: string[];
+    errorTypes: ValidatorErrorType[];
+    constructor(fieldKey: string, status?: ValidationStatus, messages?: string[], errorTypes?: ValidatorErrorType[]);
+    get errorMessage(): string | undefined;
+    get errorType(): ValidatorErrorType | undefined;
+}
+export {};

package/build/models/ui/validator/rules/index.d.ts

@@ -0,0 +1,87 @@
+export declare enum ValidatorErrorType {
+    "REQUIRED_RULE" = "REQUIRED_RULE",
+    "EMAIl_RULE" = "EMAIl_RULE",
+    "MIN_RULE" = "MIN_RULE"
+}
+declare type ValueGetter<T> = (model: T) => any;
+declare type ValuePath<T> = string | ValueGetter<T>;
+export interface IValidationRuleParams<T = any> {
+    model?: T;
+    fieldKey: string;
+    fieldName?: string;
+    message?: ((model: T) => string) | string;
+    errorType?: ValidatorErrorType;
+    valuePath: ValuePath<T>;
+    onValueChange?: (rule: ValidationRule) => void;
+}
+export declare abstract class ValidationRule<T = any> {
+    model?: T;
+    fieldKey: string;
+    fieldName?: string;
+    message?: ((model: T) => string) | string;
+    errorType?: ValidatorErrorType;
+    valuePath: ValuePath<T>;
+    onValueChange?: (rule: ValidationRule) => void;
+    disposer?: () => void;
+    constructor(data: IValidationRuleParams<T>);
+    get value(): any;
+    protected getValue(valuePath: ValuePath<T>): any;
+    abstract run(): Promise<boolean>;
+    abstract get errorMessage(): string;
+}
+export interface IMinRuleParams<T> extends IValidationRuleParams<T> {
+    minValue: number;
+}
+export declare class MinRule<T> extends ValidationRule<T> {
+    minValue: number;
+    errorType: ValidatorErrorType;
+    constructor(data: IMinRuleParams<T>);
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+export interface IMaxRuleParams extends IValidationRuleParams {
+    maxValue: number;
+}
+export declare class MaxRule<T> extends ValidationRule<T> {
+    maxValue: number;
+    constructor(data: IMaxRuleParams);
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+export declare class RequiredRule<T> extends ValidationRule<T> {
+    constructor(data: IValidationRuleParams<T>);
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+interface ILessThanRuleParams<T> extends IValidationRuleParams<T> {
+    otherFieldValuePath: ValuePath<T>;
+    otherFieldName?: string;
+}
+export declare class LessThanRule<T> extends ValidationRule<T> {
+    otherFieldName?: string;
+    otherFieldValuePath: ValuePath<T>;
+    constructor(data: ILessThanRuleParams<T>);
+    get otherValue(): any;
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+export declare class EmailRule<T> extends ValidationRule<T> {
+    errorType: ValidatorErrorType;
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+export declare class PhoneRule<T> extends ValidationRule<T> {
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+export interface IEqualsRuleParams<T> extends IValidationRuleParams<T> {
+    equalsValuePath: ValuePath<T>;
+}
+export declare class EqualsRule<T> extends ValidationRule<T> {
+    equalsValuePath: ValuePath<T>;
+    constructor(data: IEqualsRuleParams<T>);
+    get equalsValue(): any;
+    get errorMessage(): string;
+    run(): Promise<boolean>;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikas/storefront",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "main": "./build/index.js",
   "module": "./build/index.es.js",
   "author": "Umut Ozan Yıldırım",