@ikas/storefront 2.0.0-alpha.25 → 2.0.0-alpha.3

package/build/scripts/generators/models/ui/category-list/index.d.ts

@@ -0,0 +1,61 @@
+import { IkasCategory } from "../../../models/data";
+import { IkasCategoryListPropValue } from "../../../models/theme/page/component/prop-value/category-list";
+export declare class IkasCategoryList {
+    data: IkasCategory[];
+    private _type;
+    private _sort;
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _categoryListPropValue;
+    private _isLoading;
+    constructor(data: IkasCategoryListParams);
+    get sort(): IkasCategoryListSortType;
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get isStatic(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private getSortParams;
+    getInitial: () => Promise<void>;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    setSortType(sortType: IkasCategoryListSortType): Promise<void>;
+    toJSON(): {
+        data: IkasCategory[];
+        type: IkasCategoryListType;
+        sort: IkasCategoryListSortType;
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        categoryListPropValue: IkasCategoryListPropValue;
+    };
+}
+export declare type IkasCategoryListParams = {
+    data?: IkasCategory[];
+    type?: IkasCategoryListType;
+    sort?: IkasCategoryListSortType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    categoryListPropValue: IkasCategoryListPropValue;
+};
+export declare enum IkasCategoryListType {
+    ALL = "ALL",
+    STATIC = "STATIC"
+}
+export declare enum IkasCategoryListSortType {
+    A_Z = "A_Z",
+    Z_A = "Z_A"
+}

package/build/scripts/generators/models/ui/component-renderer/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+declare type RenderFunction = () => React.ReactNode;
+export declare class IkasComponentRenderer {
+    render: RenderFunction;
+    constructor(render: RenderFunction);
+}
+export {};

package/build/scripts/generators/models/ui/customer-review-list/index.d.ts

@@ -0,0 +1,43 @@
+import { IkasCustomerReview } from "../../../models/data/customer-review";
+export declare class IkasCustomerReviewList {
+    data: IkasCustomerReview[];
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _productId;
+    private _isLoading;
+    constructor(data: IkasCustomerReviewListParams);
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private listCustomerReviews;
+    private getInitial;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    toJSON(): {
+        data: IkasCustomerReview[];
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        productId: string;
+    };
+}
+export declare type IkasCustomerReviewListParams = {
+    data?: IkasCustomerReview[];
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    productId: string;
+};

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

@@ -0,0 +1,26 @@
+export * from "./blog-list";
+export * from "./blog-category-list";
+export { IkasBrandList, IkasBrandListType, IkasBrandListSortType, } from "./brand-list";
+export { IkasCategoryList, IkasCategoryListType, IkasCategoryListSortType, } from "./category-list";
+export type { IkasBrandListParams } from "./brand-list";
+export { IkasNavigationLink } from "./navigation-link";
+export { IkasProductDetail } from "./product-detail";
+export type { IkasDisplayedVariantType, IkasDisplayedVariantValue, } from "./product-detail";
+export { IkasProductList, IkasProductListType, IkasProductListSortType, } from "./product-list";
+export * from "./product-attribute-detail";
+export * from "./product-attribute-list";
+export * from "./customer-review-list";
+export { Validator } from "./validator";
+export type { ValidationStatus } from "./validator";
+export * from "./validator/rules";
+export { LoginForm } from "./validator/form/login";
+export { AddressForm } from "./validator/form/address";
+export { RegisterForm } from "./validator/form/register";
+export { ContactForm } from "./validator/form/contact-form";
+export { ForgotPasswordForm } from "./validator/form/forgot-password";
+export { RecoverPasswordForm } from "./validator/form/recover-password";
+export { AccountInfoForm } from "./validator/form/account-info";
+export { RaffleForm } from "./validator/form/raffle-form";
+export { CustomerReviewForm } from "./validator/form/customer-review";
+export * from "./component-renderer";
+export { IkasRaffleList } from "./raffle-list";

package/build/scripts/generators/models/ui/navigation-link/index.d.ts

@@ -0,0 +1,8 @@
+export declare class IkasNavigationLink {
+    href: string;
+    label: string;
+    subLinks: IkasNavigationLink[];
+    isExternal?: boolean | null;
+    itemId?: string;
+    constructor(href: string, label: string, subLinks: IkasNavigationLink[], isExternal?: boolean);
+}

package/build/scripts/generators/models/ui/product-attribute-detail/index.d.ts

@@ -0,0 +1,8 @@
+import { IkasAttributePropValue } from "../../../models/theme/page/component/prop-value/attribute";
+import { IkasProductDetail } from "../product-detail";
+export declare class IkasAttributeDetail {
+    productDetail: IkasProductDetail | null;
+    attributePropValue: IkasAttributePropValue;
+    constructor(productDetail: IkasProductDetail | null, attributePropValue: IkasAttributePropValue);
+    get values(): import("../..").IkasProductAttributeValue[];
+}

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

@@ -0,0 +1,9 @@
+import { IkasProductAttributeMap } from "../../../models/data";
+import { IkasProductDetail } from "../product-detail";
+import { IkasAttributeListPropValue } from "../../../models/theme/page/component/prop-value/attribute-list";
+export declare class IkasAttributeList {
+    productDetail: IkasProductDetail | null;
+    attributeListPropValue: IkasAttributeListPropValue;
+    constructor(productDetail: IkasProductDetail | null, attributeListPropValue: IkasAttributeListPropValue);
+    get values(): IkasProductAttributeMap[];
+}

package/build/scripts/generators/models/ui/product-detail/index.d.ts

@@ -0,0 +1,28 @@
+import { IkasProduct, IkasVariantValue, IkasCustomerReviewList } from "../../../models";
+import { NextRouter } from "next/router.js";
+import { IkasProductVariant, IkasVariantType } from "../../../models/data";
+export declare class IkasProductDetail {
+    product: IkasProduct;
+    selectedVariantValues: IkasVariantValue[];
+    private router?;
+    constructor(product: IkasProduct, selectedVariantValues: IkasVariantValue[], router?: NextRouter);
+    get mainVariantValue(): IkasVariantValue | undefined;
+    get selectedVariant(): IkasProductVariant;
+    get href(): string;
+    get hasStock(): boolean;
+    get displayedVariantTypes(): IkasDisplayedVariantType[];
+    get isCustomerReviewEnabled(): boolean;
+    get isCustomerReviewLoginRequired(): boolean;
+    getCustomerReviews(): Promise<IkasCustomerReviewList>;
+    selectVariantValue(variantValue: IkasVariantValue): void;
+}
+export declare type IkasDisplayedVariantValue = {
+    variant: IkasProductVariant;
+    variantValue: IkasVariantValue;
+    hasStock: boolean;
+    isSelected: boolean;
+};
+export declare type IkasDisplayedVariantType = {
+    variantType: IkasVariantType;
+    displayedVariantValues: IkasDisplayedVariantValue[];
+};

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

@@ -0,0 +1,132 @@
+import { IkasProductListPropValue, IkasThemePageType } from "../../../models/theme";
+import { IkasProductDetail } from "../product-detail";
+import { IkasProductFilter } from "../../../models/data/product-filter";
+import { NextRouter } from "next/router.js";
+import { IkasCategory, IkasFilterCategory } from "../../../models/data/category";
+import { IkasBrand } from "../../../models/data";
+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 _filterBrandId?;
+    private _filterCategoryId?;
+    private pageSpecificData?;
+    private _recommendFor?;
+    private _isLoading;
+    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;
+    get filterQueryParams(): string;
+    get filterCategories(): IkasFilterCategory[] | undefined;
+    get hasAppliedfilter(): boolean | undefined;
+    get isFeaturedSortEnabled(): boolean;
+    private setPageSpecificSort;
+    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>;
+    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;
+        filterBrandId: string | null | undefined;
+        filterCategoryId: string | null | undefined;
+        filterCategories: IkasFilterCategory[] | null | undefined;
+        filters: IkasProductFilter[] | null | undefined;
+        recommendFor: string | null | undefined;
+        productListPropValue: IkasProductListPropValue;
+        pageSpecificData: IkasBrand | IkasCategory | null | undefined;
+    };
+    setVisibleInfiniteScrollPage: (page: number) => void;
+    private restoreInfiniteScrollPage;
+    private getQueryParams;
+    private isBrowser;
+    private waitForCustomerStoreInit;
+    private handleListingEvent;
+    private searchDebouncer;
+    private searchAnalyticsDebouncer;
+}
+export declare type IkasProductListParams = {
+    data?: IkasProductDetail[];
+    type?: IkasProductListType;
+    pageType: IkasThemePageType;
+    sort?: IkasProductListSortType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    searchKeyword?: string;
+    initialized?: boolean;
+    minPage?: number;
+    filterBrandId?: string;
+    filterCategoryId?: string;
+    filters?: IkasProductFilter[];
+    filterCategories?: IkasFilterCategory[];
+    recommendFor?: string;
+    productListPropValue: IkasProductListPropValue;
+    pageSpecificData?: IkasCategory | IkasBrand | null;
+};
+export declare enum IkasProductListType {
+    ALL = "ALL",
+    STATIC = "STATIC",
+    DISCOUNTED = "DISCOUNTED",
+    RECOMMENDED = "RECOMMENDED",
+    CATEGORY = "CATEGORY",
+    SEARCH = "SEARCH",
+    LAST_VIEWED = "LAST_VIEWED"
+}
+export declare enum IkasProductListSortType {
+    INCREASING_PRICE = "INCREASING_PRICE",
+    DECREASING_PRICE = "DECREASING_PRICE",
+    LAST_ADDED = "LAST_ADDED",
+    FIRST_ADDED = "FIRST_ADDED",
+    INCREASING_DISCOUNT = "INCREASING_DISCOUNT",
+    DECRASING_DISCOUNT = "DECRASING_DISCOUNT",
+    FEATURED = "FEATURED"
+}

package/build/scripts/generators/models/ui/raffle-list/index.d.ts

@@ -0,0 +1,54 @@
+import { IkasRaffle } from "../../../models";
+export declare class IkasRaffleList {
+    data: IkasRaffle[];
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _start;
+    private _end;
+    private _includeDeleted;
+    private _name;
+    private _search;
+    private _id;
+    private _isLoading;
+    constructor(data?: IkasRaffleListParams);
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    get minPage(): number;
+    private getRaffleList;
+    private getInitial;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    toJSON(): {
+        data: IkasRaffle[];
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+    };
+}
+export declare type IkasRaffleListParams = {
+    data?: IkasRaffle[];
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    start?: number;
+    end?: number;
+    includeDeleted?: boolean;
+    name?: string;
+    search?: string;
+    id?: string;
+    customerId?: string;
+};

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

@@ -0,0 +1,40 @@
+import { PhoneRule, RequiredRule } from "../rules";
+import { IkasBaseStore } from "../../../../store";
+import { IkasCustomer } from "../../../../models";
+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/scripts/generators/models/ui/validator/form/address.d.ts

@@ -0,0 +1,75 @@
+import { IkasCity, IkasCountry, IkasCustomerAddress, IkasDistrict, IkasState } from "../../../../models/data";
+import { IkasBaseStore } from "../../../../store";
+import { PhoneRule, RequiredRule } from "../rules";
+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("..").ValidationResults;
+    validateAll: () => Promise<boolean>;
+    submit: () => Promise<{
+        isFormError: boolean;
+        isSuccess: boolean;
+    }>;
+}
+export {};

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

@@ -0,0 +1,45 @@
+import { IkasBaseStore } from "../../../../store";
+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/scripts/generators/models/ui/validator/form/customer-review.d.ts

@@ -0,0 +1,37 @@
+import { IkasBaseStore } from "../../../../store";
+declare type CustomerReviewFormProps<T> = {
+    productId: string;
+    message: {
+        starRule: ((model: T) => string) | string;
+    };
+    store: IkasBaseStore;
+};
+declare type CustomerReviewFormModel = {
+    title: string;
+    comment: string;
+    star: number;
+};
+export declare class CustomerReviewForm {
+    private productId;
+    private model;
+    private validator;
+    private store;
+    constructor(props: CustomerReviewFormProps<CustomerReviewFormModel>);
+    get title(): string;
+    set title(value: string);
+    get comment(): string;
+    set comment(value: string);
+    get star(): number;
+    set star(value: number);
+    get hasError(): boolean;
+    get starErrorMessage(): string | undefined;
+    onTitleChange: (value: string) => void;
+    onCommentChange: (value: string) => void;
+    onStarChange: (value: number) => void;
+    validateAll(): Promise<boolean>;
+    submit(): Promise<{
+        isFormError: boolean;
+        isSuccess: boolean;
+    }>;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { IkasBaseStore } from "../../../../store";
+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/scripts/generators/models/ui/validator/form/login.d.ts

@@ -0,0 +1,35 @@
+import { IkasBaseStore } from "../../../../store";
+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 {};