@ikas/storefront 0.0.14 → 0.0.16-0.alpha-1

package/build/models/ui/product-list/index.d.ts

@@ -1,60 +1,107 @@
-import { IkasProductListPropValue } from "../../theme/index";
+import { IkasProductListPropValue, IkasThemePageType } from "../../theme/index";
 import { IkasProductDetail } from "../product-detail/index";
-import { IkasProductListFilter } from "./filter";
+import { IkasProductFilter } from "../../data/product-filter/index";
+import { NextRouter } from "next/router";
+import { IkasFilterCategory } from "../../data/category/index";
 export declare class IkasProductList {
     data: IkasProductDetail[];
+    filters?: IkasProductFilter[] | null;
+    private _filterCategories?;
     private _type;
+    private _pageType;
     private _sort;
     private _limit;
     private _page;
+    private _infiniteScrollPage;
     private _count;
+    private _searchKeyword;
     private _initialized;
     private _minPage?;
     private _productListPropValue;
-    private _filters?;
+    private _filterBrandId?;
+    private _filterCategoryId?;
     private _recommendFor?;
     private _isLoading;
-    constructor(data: IkasProductListParams);
+    private _fetchRequestTime;
+    private router?;
+    constructor(data: IkasProductListParams, router?: NextRouter);
     get sort(): IkasProductListSortType;
     get limit(): number;
+    get pageType(): IkasThemePageType;
     get page(): number;
+    get minPage(): number;
     get count(): number;
+    get pageCount(): number;
+    get searchKeyword(): string;
+    set searchKeyword(value: string);
     get isInitialized(): boolean;
+    get isFilterable(): boolean;
+    get isFiltered(): boolean | undefined;
     get isStatic(): boolean;
     get isDiscounted(): boolean;
     get isRecommended(): boolean;
+    get isLastViewed(): boolean;
+    get isSearch(): boolean;
     get hasPrev(): boolean;
     get hasNext(): boolean;
     get isLoading(): boolean;
-    getInitial: () => Promise<void>;
+    get filterQueryParams(): string;
+    get filterCategories(): IkasFilterCategory[] | undefined;
+    get hasAppliedfilter(): boolean | undefined;
+    private getSortParams;
+    private searchProducts;
+    private getFilters;
+    private applyQueryParamFilters;
+    private applyFacets;
+    private applyFilters;
+    clearFilters(): void;
+    private getInitial;
     getPrev: () => Promise<void>;
     getNext: () => Promise<void>;
     getPage: (page: number) => Promise<void>;
-    applyFilters(): void;
+    setSortType(sortType: IkasProductListSortType): Promise<void>;
+    onFilterCategoryClick(filterCategory: IkasFilterCategory, disableRoute?: boolean): Promise<void>;
     toJSON(): {
         data: IkasProductDetail[];
         type: IkasProductListType;
+        pageType: IkasThemePageType;
         sort: IkasProductListSortType;
         limit: number;
         page: number;
         count: number;
+        searchKeyword: string;
         initialized: boolean;
         minPage: number | null | undefined;
-        filters: IkasProductListFilter | null | undefined;
+        filterBrandId: string | null | undefined;
+        filterCategoryId: string | null | undefined;
+        filterCategories: IkasFilterCategory[] | null | undefined;
+        filters: IkasProductFilter[] | null | undefined;
         recommendFor: string | null | undefined;
         productListPropValue: IkasProductListPropValue;
     };
+    setVisibleInfiniteScrollPage: (page: number) => void;
+    private restoreInfiniteScrollPage;
+    private getQueryParams;
+    private isBrowser;
+    private waitForCustomerStoreInit;
+    private searchDebouncer;
+    private analyticsDebouncer;
 }
 export declare type IkasProductListParams = {
     data?: IkasProductDetail[];
     type?: IkasProductListType;
+    pageType: IkasThemePageType;
     sort?: IkasProductListSortType;
     limit?: number;
     page?: number;
     count?: number;
+    searchKeyword?: string;
     initialized?: boolean;
     minPage?: number;
-    filters?: IkasProductListFilter;
+    filterBrandId?: string;
+    filterCategoryId?: string;
+    filters?: IkasProductFilter[];
+    filterCategories?: IkasFilterCategory[];
     recommendFor?: string;
     productListPropValue: IkasProductListPropValue;
 };
@@ -62,15 +109,16 @@ export declare enum IkasProductListType {
     ALL = "ALL",
     STATIC = "STATIC",
     DISCOUNTED = "DISCOUNTED",
-    RECOMMENDED = "RECOMMENDED"
+    RECOMMENDED = "RECOMMENDED",
+    CATEGORY = "CATEGORY",
+    SEARCH = "SEARCH",
+    LAST_VIEWED = "LAST_VIEWED"
 }
 export declare enum IkasProductListSortType {
-    MOST_SOLD = "MOST_SOLD",
-    FEATURED = "FEATURED",
     INCREASING_PRICE = "INCREASING_PRICE",
     DECREASING_PRICE = "DECREASING_PRICE",
-    A_Z = "A_Z",
-    Z_A = "Z_A",
     LAST_ADDED = "LAST_ADDED",
-    FIRST_ADDED = "FIRST_ADDED"
+    FIRST_ADDED = "FIRST_ADDED",
+    INCREASING_DISCOUNT = "INCREASING_DISCOUNT",
+    DECRASING_DISCOUNT = "DECRASING_DISCOUNT"
 }

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,75 @@
+import { IkasCity, IkasCountry, IkasCustomerAddress, IkasDistrict, IkasState } from "../../../data/index";
+import { IkasBaseStore } from "../../../../store/index";
+import { PhoneRule, RequiredRule } from "../rules/index";
+declare type AddressFormPropsValidatorMessage<T> = {
+    requiredRule: ((model: T) => string) | string;
+    phoneRule?: ((model: T) => string) | string;
+};
+declare type AddressFormProps<T> = {
+    message: AddressFormPropsValidatorMessage<T>;
+    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;
+    private message;
+    constructor(props: AddressFormProps<IkasCustomerAddress>);
+    validatorRules: (includePhoneRule?: boolean) => (RequiredRule<IkasCustomerAddress> | PhoneRule<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;
+        isSuccess: boolean;
+    }>;
+}
+export {};

package/build/models/ui/validator/form/contact-form.d.ts

@@ -0,0 +1,45 @@
+import { IkasBaseStore } from "../../../../store/index";
+declare type ContactFormProps<T> = {
+    message: {
+        requiredRule: ((model: T) => string) | string;
+        emailRule: ((model: T) => string) | string;
+        minRule: ((model: T) => string) | string;
+    };
+    store: IkasBaseStore;
+};
+declare type ContactFormModel = {
+    firstName: string;
+    lastName: string;
+    email: string;
+    message: string;
+};
+export declare class ContactForm {
+    private model;
+    private validator;
+    private store;
+    constructor(props: ContactFormProps<ContactFormModel>);
+    get firstName(): string;
+    set firstName(value: string);
+    get lastName(): string;
+    set lastName(value: string);
+    get email(): string;
+    set email(value: string);
+    get message(): string;
+    set message(value: string);
+    get hasError(): boolean;
+    get firstNameErrorMessage(): string | undefined;
+    get lastNameErrorMessage(): string | undefined;
+    get emailErrorMessage(): string | undefined;
+    get messageErrorMessage(): string | undefined;
+    get redirect(): string | null | undefined;
+    onFirstNameChange: (value: string) => void;
+    onLastNameChange: (value: string) => void;
+    onEmailChange: (value: string) => void;
+    onMessageChange: (value: string) => void;
+    validateAll(): Promise<boolean>;
+    saveContactForm(): Promise<{
+        isFormError: 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;
+        isSuccess: 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;
+        isSuccess: 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;
+        isSuccess: 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;
+        isSuccess: 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/build/pages/404.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasThemePage } from "../models/index";
+declare type Props = {
+    propValuesStr: string;
+    page: IkasThemePage;
+    settingsStr: string;
+    merchantSettings: string;
+    configJson: Record<string, any>;
+};
+declare const Page: React.FC<Props>;
+export default Page;
+export declare const getStaticProps: GetStaticProps;

package/build/pages/[slug]/index.d.ts

@@ -1,12 +1,18 @@
+/// <reference types="node" />
 import * as React from "react";
-import { GetStaticProps, GetStaticPaths } from "next";
+import { GetStaticPaths, GetStaticProps } from "next";
 import { IkasThemePage } from "../../models/index";
+import { ParsedUrlQuery } from "querystring";
 declare type Props = {
     propValuesStr: string;
     pageSpecificDataStr: string;
     page: IkasThemePage;
+    queryParams?: ParsedUrlQuery;
+    settingsStr: string;
+    merchantSettings: string;
+    configJson: Record<string, any>;
 };
-declare const Page: React.FC<Props>;
-export default Page;
+declare const _default: React.FunctionComponent<Props>;
+export default _default;
 export declare const getStaticPaths: GetStaticPaths;
 export declare const getStaticProps: GetStaticProps;

package/build/pages/account/addresses.d.ts

@@ -4,6 +4,8 @@ import { IkasThemePage } from "../../models/index";
 declare type Props = {
     propValuesStr: string;
     page: IkasThemePage;
+    settingsStr: string;
+    configJson: Record<string, any>;
 };
 declare const Page: React.FC<Props>;
 export default Page;

package/build/pages/account/favorite-products.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasThemePage } from "../../models/index";
+declare type Props = {
+    propValuesStr: string;
+    page: IkasThemePage;
+    settingsStr: string;
+    configJson: Record<string, any>;
+};
+declare const Page: React.FC<Props>;
+export default Page;
+export declare const getStaticProps: GetStaticProps;

package/build/pages/account/forgot-password.d.ts

@@ -4,6 +4,9 @@ import { IkasThemePage } from "../../models/index";
 declare type Props = {
     propValuesStr: string;
     page: IkasThemePage;
+    settingsStr: string;
+    merchantSettings: string;
+    configJson: Record<string, any>;
 };
 declare const Page: React.FC<Props>;
 export default Page;

package/build/pages/account/index.d.ts

@@ -4,6 +4,8 @@ import { IkasThemePage } from "../../models/index";
 declare type Props = {
     propValuesStr: string;
     page: IkasThemePage;
+    settingsStr: string;
+    configJson: Record<string, any>;
 };
 declare const Page: React.FC<Props>;
 export default Page;

package/build/pages/account/login.d.ts

@@ -4,6 +4,9 @@ import { IkasThemePage } from "../../models/index";
 declare type Props = {
     propValuesStr: string;
     page: IkasThemePage;
+    settingsStr: string;
+    merchantSettings: string;
+    configJson: Record<string, any>;
 };
 declare const Page: React.FC<Props>;
 export default Page;

package/build/pages/account/orders/[id].d.ts

@@ -4,6 +4,8 @@ import { IkasThemePage } from "../../../models/index";
 declare type Props = {
     propValuesStr: string;
     page: IkasThemePage;
+    settingsStr: string;
+    configJson: Record<string, any>;
 };
 declare const Page: React.FC<Props>;
 export default Page;

package/build/pages/account/orders/index.d.ts

@@ -4,6 +4,8 @@ import { IkasThemePage } from "../../../models/index";
 declare type Props = {
     propValuesStr: string;
     page: IkasThemePage;
+    settingsStr: string;
+    configJson: Record<string, any>;
 };
 declare const Page: React.FC<Props>;
 export default Page;