@jetshop/core 5.13.12-0 → 5.14.0

package/components/ProductConfigurationProvider/ProductConfigurationContext.d.ts

@@ -1,13 +1,13 @@
-import { Context } from 'react';
-import { ProductConfiguration, ProductConfigurationPrice, ProductConfigurationOption } from '../../types';
-export interface ProductConfigurationState {
-    configurations: ProductConfiguration[];
-    configurationPrice: ProductConfigurationPrice;
-    loading: boolean;
-    selectOption: (option: ProductConfigurationOption, config: ProductConfiguration) => void;
-    getSelectedValue: (config: ProductConfiguration) => string;
-    ids: string[];
-}
-declare const ProductConfigurationContext: Context<ProductConfigurationState>;
-export declare const ProductConfigurationConsumer: import("react").Consumer<ProductConfigurationState>;
-export default ProductConfigurationContext;
+import { Context } from 'react';
+import { ProductConfiguration, ProductConfigurationPrice, ProductConfigurationOption } from '../../types';
+export interface ProductConfigurationState {
+    configurations: ProductConfiguration[];
+    configurationPrice: ProductConfigurationPrice;
+    loading: boolean;
+    selectOption: (option: ProductConfigurationOption, config: ProductConfiguration) => void;
+    getSelectedValue: (config: ProductConfiguration) => string;
+    ids: string[];
+}
+declare const ProductConfigurationContext: Context<ProductConfigurationState>;
+export declare const ProductConfigurationConsumer: import("react").Consumer<ProductConfigurationState>;
+export default ProductConfigurationContext;

package/components/ProductConfigurationProvider/ProductConfigurationContext.js

@@ -1,5 +1,5 @@
-import { createContext } from 'react';
-const ProductConfigurationContext = createContext(undefined);
-export const ProductConfigurationConsumer = ProductConfigurationContext.Consumer;
-export default ProductConfigurationContext;
+import { createContext } from 'react';
+const ProductConfigurationContext = createContext(undefined);
+export const ProductConfigurationConsumer = ProductConfigurationContext.Consumer;
+export default ProductConfigurationContext;
 //# sourceMappingURL=ProductConfigurationContext.js.map

package/components/ProductConfigurationProvider/ProductConfigurationProvider.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
-import { Product } from '../../types';
-declare const ConditionalProvider: React.FC<{
-    product: Product;
-}>;
-export default ConditionalProvider;
+import React from 'react';
+import { Product } from '../../types';
+declare const ConditionalProvider: React.FC<{
+    product: Product;
+}>;
+export default ConditionalProvider;

package/components/ProductConfigurationProvider/ProductConfigurationProvider.js

@@ -1,50 +1,50 @@
-import React, { useCallback, useState, useMemo } from 'react';
-import ProductConfigurationContext from './ProductConfigurationContext';
-import { useQuery } from '@apollo/react-hooks';
-import ConfigPrice from './ConfigPrice.gql';
-import produce from 'immer';
-const ProductConfigurationProvider = ({ product, children }) => {
-    const { configurations } = product;
-    const [ids, setIds] = useState(configurations.map(config => config.options[0].id));
-    const selectOption = useCallback(function selectOption(option, config) {
-        const idx = configurations.indexOf(config);
-        setIds(curr => produce(curr, draft => {
-            draft[idx] = option.id;
-        }));
-    }, [configurations]);
-    const getSelectedValue = useCallback(function getSelectedValue(config) {
-        const idx = configurations.indexOf(config);
-        const id = ids[idx];
-        return config.options.find(option => option.id === id).name;
-    }, [configurations, ids]);
-    // Creating the variables for the product price query (with configs)
-    const priceQueryVars = useMemo(() => {
-        return { id: product.id, options: ids.map(id => ({ optionId: id })) };
-    }, [product.id, ids]);
-    const priceQuery = useQuery(ConfigPrice, {
-        variables: priceQueryVars,
-        partialRefetch: true
-    });
-    const value = useMemo(() => {
-        var _a;
-        return ({
-            configurations,
-            configurationPrice: (_a = priceQuery.data) === null || _a === void 0 ? void 0 : _a.product.configurationPrice,
-            loading: priceQuery.loading,
-            selectOption,
-            getSelectedValue,
-            ids
-        });
-    }, [
-        configurations,
-        priceQuery.data,
-        priceQuery.loading,
-        selectOption,
-        getSelectedValue,
-        ids
-    ]);
-    return (React.createElement(ProductConfigurationContext.Provider, { value: value }, children));
-};
-const ConditionalProvider = ({ product, children }) => (product === null || product === void 0 ? void 0 : product.hasConfigurations) ? (React.createElement(ProductConfigurationProvider, { product: product }, children)) : (React.createElement(React.Fragment, null, children));
-export default ConditionalProvider;
+import React, { useCallback, useState, useMemo } from 'react';
+import ProductConfigurationContext from './ProductConfigurationContext';
+import { useQuery } from '@apollo/react-hooks';
+import ConfigPrice from './ConfigPrice.gql';
+import produce from 'immer';
+const ProductConfigurationProvider = ({ product, children }) => {
+    const { configurations } = product;
+    const [ids, setIds] = useState(configurations.map(config => config.options[0].id));
+    const selectOption = useCallback(function selectOption(option, config) {
+        const idx = configurations.indexOf(config);
+        setIds(curr => produce(curr, draft => {
+            draft[idx] = option.id;
+        }));
+    }, [configurations]);
+    const getSelectedValue = useCallback(function getSelectedValue(config) {
+        const idx = configurations.indexOf(config);
+        const id = ids[idx];
+        return config.options.find(option => option.id === id).name;
+    }, [configurations, ids]);
+    // Creating the variables for the product price query (with configs)
+    const priceQueryVars = useMemo(() => {
+        return { id: product.id, options: ids.map(id => ({ optionId: id })) };
+    }, [product.id, ids]);
+    const priceQuery = useQuery(ConfigPrice, {
+        variables: priceQueryVars,
+        partialRefetch: true
+    });
+    const value = useMemo(() => {
+        var _a;
+        return ({
+            configurations,
+            configurationPrice: (_a = priceQuery.data) === null || _a === void 0 ? void 0 : _a.product.configurationPrice,
+            loading: priceQuery.loading,
+            selectOption,
+            getSelectedValue,
+            ids
+        });
+    }, [
+        configurations,
+        priceQuery.data,
+        priceQuery.loading,
+        selectOption,
+        getSelectedValue,
+        ids
+    ]);
+    return (React.createElement(ProductConfigurationContext.Provider, { value: value }, children));
+};
+const ConditionalProvider = ({ product, children }) => (product === null || product === void 0 ? void 0 : product.hasConfigurations) ? (React.createElement(ProductConfigurationProvider, { product: product }, children)) : (React.createElement(React.Fragment, null, children));
+export default ConditionalProvider;
 //# sourceMappingURL=ProductConfigurationProvider.js.map

package/components/Query/CartProvider.d.ts

@@ -1,22 +1,22 @@
-import { DocumentNode } from 'graphql';
-import { QueryResult } from 'react-apollo';
-import { Cart } from '../../types';
-interface Data {
-    /**
-     * Properties of `Cart` are not _guaranteed_ - depends on `cartFragment`
-     */
-    cart?: Cart;
-}
-interface Variables {
-    cartId: string;
-}
-interface CartProviderProps {
-    children(result: QueryResult): any;
-    query: DocumentNode;
-}
-export declare function useCart(cartQuery: DocumentNode): {
-    result: QueryResult<Data, Variables>;
-    cart: Cart;
-};
-export default function CartProvider({ children, query }: CartProviderProps): any;
-export {};
+import { DocumentNode } from 'graphql';
+import { QueryResult } from 'react-apollo';
+import { Cart } from '../../types';
+interface Data {
+    /**
+     * Properties of `Cart` are not _guaranteed_ - depends on `cartFragment`
+     */
+    cart?: Cart;
+}
+interface Variables {
+    cartId: string;
+}
+interface CartProviderProps {
+    children(result: QueryResult): any;
+    query: DocumentNode;
+}
+export declare function useCart(cartQuery: DocumentNode): {
+    result: QueryResult<Data, Variables>;
+    cart: Cart;
+};
+export default function CartProvider({ children, query }: CartProviderProps): any;
+export {};

package/components/Query/CartProvider.js

@@ -1,68 +1,68 @@
-import { useQuery } from '@apollo/react-hooks';
-import { useContext, useEffect, useRef } from 'react';
-import throwErrorInDev from '../../helpers/throwErrorInDev';
-import { CartIdContext } from '../Cart/CartIdContext';
-import debounce from 'lodash.debounce';
-import { useTracker } from '../../analytics/Analytics';
-import { trackCartEvent } from '../../analytics/tracking';
-// We only want a single tracker to be attached even if we use `useCart` in multiple places in our app
-let trackerAttached = false;
-function useSingleCartTracker(result) {
-    var _a;
-    const track = useTracker();
-    useEffect(() => {
-        var _a, _b;
-        if (!trackerAttached) {
-            trackerAttached = true;
-            if (result.loading) {
-            }
-            else if ((_a = result.data) === null || _a === void 0 ? void 0 : _a.cart) {
-                if (result.data.cart.__optimistic) {
-                }
-                else {
-                    track(trackCartEvent({ cart: (_b = result.data) === null || _b === void 0 ? void 0 : _b.cart }));
-                }
-            }
-            return () => {
-                trackerAttached = false;
-            };
-        }
-    }, [result.loading, (_a = result.data) === null || _a === void 0 ? void 0 : _a.cart, track]);
-}
-export function useCart(cartQuery) {
-    const { cartId } = useContext(CartIdContext);
-    const result = useQuery(cartQuery, {
-        variables: { cartId },
-        skip: __IN_SERVER__
-    });
-    useSingleCartTracker(result);
-    return { result, cart: result.data && result.data.cart };
-}
-const useLocalStorageCart = (refetch) => {
-    const debounceRefetch = useRef(null);
-    useEffect(() => {
-        const listener = (e) => {
-            const localStorageCart = localStorage.getItem('cartChange');
-            if (e.storageArea === localStorage &&
-                e.key === 'cartChange' &&
-                localStorageCart) {
-                if (debounceRefetch.current)
-                    debounceRefetch.current.cancel();
-                debounceRefetch.current = debounce(() => refetch(), 1500);
-                debounceRefetch.current();
-                localStorage.removeItem('cartChange');
-            }
-        };
-        window.addEventListener('storage', listener);
-        return () => {
-            window.removeEventListener('storage', listener);
-        };
-    });
-};
-export default function CartProvider({ children, query }) {
-    throwErrorInDev(!query, `You forgot to pass 'query' to CartProvider`);
-    const { result } = useCart(query);
-    useLocalStorageCart(result.refetch);
-    return children(result);
-}
+import { useQuery } from '@apollo/react-hooks';
+import { useContext, useEffect, useRef } from 'react';
+import throwErrorInDev from '../../helpers/throwErrorInDev';
+import { CartIdContext } from '../Cart/CartIdContext';
+import debounce from 'lodash.debounce';
+import { useTracker } from '../../analytics/Analytics';
+import { trackCartEvent } from '../../analytics/tracking';
+// We only want a single tracker to be attached even if we use `useCart` in multiple places in our app
+let trackerAttached = false;
+function useSingleCartTracker(result) {
+    var _a;
+    const track = useTracker();
+    useEffect(() => {
+        var _a, _b;
+        if (!trackerAttached) {
+            trackerAttached = true;
+            if (result.loading) {
+            }
+            else if ((_a = result.data) === null || _a === void 0 ? void 0 : _a.cart) {
+                if (result.data.cart.__optimistic) {
+                }
+                else {
+                    track(trackCartEvent({ cart: (_b = result.data) === null || _b === void 0 ? void 0 : _b.cart }));
+                }
+            }
+            return () => {
+                trackerAttached = false;
+            };
+        }
+    }, [result.loading, (_a = result.data) === null || _a === void 0 ? void 0 : _a.cart, track]);
+}
+export function useCart(cartQuery) {
+    const { cartId } = useContext(CartIdContext);
+    const result = useQuery(cartQuery, {
+        variables: { cartId },
+        skip: __IN_SERVER__
+    });
+    useSingleCartTracker(result);
+    return { result, cart: result.data && result.data.cart };
+}
+const useLocalStorageCart = (refetch) => {
+    const debounceRefetch = useRef(null);
+    useEffect(() => {
+        const listener = (e) => {
+            const localStorageCart = localStorage.getItem('cartChange');
+            if (e.storageArea === localStorage &&
+                e.key === 'cartChange' &&
+                localStorageCart) {
+                if (debounceRefetch.current)
+                    debounceRefetch.current.cancel();
+                debounceRefetch.current = debounce(() => refetch(), 1500);
+                debounceRefetch.current();
+                localStorage.removeItem('cartChange');
+            }
+        };
+        window.addEventListener('storage', listener);
+        return () => {
+            window.removeEventListener('storage', listener);
+        };
+    });
+};
+export default function CartProvider({ children, query }) {
+    throwErrorInDev(!query, `You forgot to pass 'query' to CartProvider`);
+    const { result } = useCart(query);
+    useLocalStorageCart(result.refetch);
+    return children(result);
+}
 //# sourceMappingURL=CartProvider.js.map

package/components/SortOrder/SortOrderContainer.d.ts

@@ -1,40 +1,40 @@
-import * as React from 'react';
-import { RouteComponentProps } from 'react-router-dom';
-import type { History, Location } from 'history';
-import { Direction, ISortOrderContext } from '@jetshop/core/components/SortOrder/SortOrderContext';
-export interface SortOrderContainerProps extends RouteComponentProps<{}> {
-    children(context: ISortOrderContext): React.ReactNode;
-}
-export declare const sortTypes: {
-    [key: string]: string;
-};
-export declare const sortValues: {
-    [key: string]: {
-        text: () => {
-            text: React.FunctionComponent;
-        };
-        direction: string;
-    }[];
-};
-export declare function getSortOrderFromQueryString(search: Location['search']): {
-    sortOrder: any;
-    direction: any;
-};
-interface SortOrderUpdate {
-    value: string;
-    direction: Direction;
-    history: History;
-    location: Location;
-}
-export declare function updateSortOrderHistory({ value, direction, history, location }: SortOrderUpdate): void;
-declare class SortOrderContainer extends React.Component<SortOrderContainerProps, ISortOrderContext> {
-    state: ISortOrderContext;
-    constructor(props: SortOrderContainerProps);
-    componentDidMount(): void;
-    onSelect: (value: string, direction: Direction) => boolean;
-    render(): JSX.Element;
-}
-declare const _default: React.ComponentClass<Pick<SortOrderContainerProps, "children"> & {
-    wrappedComponentRef?: React.Ref<SortOrderContainer>;
-}, any> & import("react-router").WithRouterStatics<typeof SortOrderContainer>;
-export default _default;
+import * as React from 'react';
+import { RouteComponentProps } from 'react-router-dom';
+import type { History, Location } from 'history';
+import { Direction, ISortOrderContext } from '@jetshop/core/components/SortOrder/SortOrderContext';
+export interface SortOrderContainerProps extends RouteComponentProps<{}> {
+    children(context: ISortOrderContext): React.ReactNode;
+}
+export declare const sortTypes: {
+    [key: string]: string;
+};
+export declare const sortValues: {
+    [key: string]: {
+        text: () => {
+            text: React.FunctionComponent;
+        };
+        direction: string;
+    }[];
+};
+export declare function getSortOrderFromQueryString(search: Location['search']): {
+    sortOrder: any;
+    direction: any;
+};
+interface SortOrderUpdate {
+    value: string;
+    direction: Direction;
+    history: History;
+    location: Location;
+}
+export declare function updateSortOrderHistory({ value, direction, history, location }: SortOrderUpdate): void;
+declare class SortOrderContainer extends React.Component<SortOrderContainerProps, ISortOrderContext> {
+    state: ISortOrderContext;
+    constructor(props: SortOrderContainerProps);
+    componentDidMount(): void;
+    onSelect: (value: string, direction: Direction) => boolean;
+    render(): JSX.Element;
+}
+declare const _default: React.ComponentClass<Pick<SortOrderContainerProps, "children"> & {
+    wrappedComponentRef?: React.Ref<SortOrderContainer>;
+}, any> & import("react-router").WithRouterStatics<typeof SortOrderContainer>;
+export default _default;

package/components/SortOrder/SortOrderContainer.js

@@ -1,102 +1,102 @@
-import * as React from 'react';
-import { withRouter } from 'react-router-dom';
-import qs from 'qs';
-import SortOrderContext from '@jetshop/core/components/SortOrder/SortOrderContext';
-import t from '@jetshop/intl';
-import { pushHistory } from '@jetshop/core/components/Filters/utils/updateHistory';
-// Temporary sort type mapping until API returns this
-export const sortTypes = {
-    NAME: 'string',
-    ARTICLE_NUMBER: 'number',
-    PUBLISH_DATE: 'date',
-    PRICE: 'number',
-    SUB_HEADING: 'string',
-    BESTSELLER: 'custom',
-    CUSTOM: 'custom'
-};
-export const sortValues = {
-    string: [
-        {
-            text: t('A to Z'),
-            direction: 'ASCENDING'
-        },
-        {
-            text: t('Z to A'),
-            direction: 'DESCENDING'
-        }
-    ],
-    number: [
-        {
-            text: t('low to high'),
-            direction: 'ASCENDING'
-        },
-        {
-            text: t('high to low'),
-            direction: 'DESCENDING'
-        }
-    ],
-    date: [
-        {
-            text: t(''),
-            direction: 'DESCENDING'
-        }
-    ],
-    custom: [
-        {
-            text: t(''),
-            direction: 'ASCENDING'
-        }
-    ]
-};
-export function getSortOrderFromQueryString(search) {
-    const parsedSearch = qs.parse(search, {
-        ignoreQueryPrefix: true
-    });
-    if (Object.keys(parsedSearch).includes('orderBy')) {
-        return {
-            sortOrder: parsedSearch.orderBy,
-            direction: parsedSearch.direction
-        };
-    }
-}
-export function updateSortOrderHistory({ value, direction, history, location }) {
-    const currentSearch = qs.parse(window.location.search, { ignoreQueryPrefix: true }) || {};
-    const newSearch = Object.assign(Object.assign({}, currentSearch), { orderBy: value, direction });
-    pushHistory({
-        history,
-        pathname: location.pathname,
-        hash: location.hash,
-        search: newSearch,
-        resetPage: true,
-        routeType: 'sortOrderChange'
-    });
-}
-class SortOrderContainer extends React.Component {
-    constructor(props) {
-        super(props);
-        this.onSelect = (value, direction) => {
-            const { location, history } = this.props;
-            updateSortOrderHistory({ location, history, value, direction });
-            this.setState({ sortOrder: value, direction });
-            return true;
-        };
-        this.state = {
-            sortOrder: null,
-            direction: 'DESCENDING',
-            changeSortOrder: this.onSelect
-        };
-    }
-    componentDidMount() {
-        if (this.props.location.search) {
-            const sortOrder = getSortOrderFromQueryString(this.props.location.search);
-            if (sortOrder) {
-                this.setState(sortOrder);
-            }
-        }
-    }
-    render() {
-        return (React.createElement(SortOrderContext.Provider, { value: this.state }, this.props.children(this.state)));
-    }
-}
-export default withRouter(SortOrderContainer);
+import * as React from 'react';
+import { withRouter } from 'react-router-dom';
+import qs from 'qs';
+import SortOrderContext from '@jetshop/core/components/SortOrder/SortOrderContext';
+import t from '@jetshop/intl';
+import { pushHistory } from '@jetshop/core/components/Filters/utils/updateHistory';
+// Temporary sort type mapping until API returns this
+export const sortTypes = {
+    NAME: 'string',
+    ARTICLE_NUMBER: 'number',
+    PUBLISH_DATE: 'date',
+    PRICE: 'number',
+    SUB_HEADING: 'string',
+    BESTSELLER: 'custom',
+    CUSTOM: 'custom'
+};
+export const sortValues = {
+    string: [
+        {
+            text: t('A to Z'),
+            direction: 'ASCENDING'
+        },
+        {
+            text: t('Z to A'),
+            direction: 'DESCENDING'
+        }
+    ],
+    number: [
+        {
+            text: t('low to high'),
+            direction: 'ASCENDING'
+        },
+        {
+            text: t('high to low'),
+            direction: 'DESCENDING'
+        }
+    ],
+    date: [
+        {
+            text: t(''),
+            direction: 'DESCENDING'
+        }
+    ],
+    custom: [
+        {
+            text: t(''),
+            direction: 'ASCENDING'
+        }
+    ]
+};
+export function getSortOrderFromQueryString(search) {
+    const parsedSearch = qs.parse(search, {
+        ignoreQueryPrefix: true
+    });
+    if (Object.keys(parsedSearch).includes('orderBy')) {
+        return {
+            sortOrder: parsedSearch.orderBy,
+            direction: parsedSearch.direction
+        };
+    }
+}
+export function updateSortOrderHistory({ value, direction, history, location }) {
+    const currentSearch = qs.parse(window.location.search, { ignoreQueryPrefix: true }) || {};
+    const newSearch = Object.assign(Object.assign({}, currentSearch), { orderBy: value, direction });
+    pushHistory({
+        history,
+        pathname: location.pathname,
+        hash: location.hash,
+        search: newSearch,
+        resetPage: true,
+        routeType: 'sortOrderChange'
+    });
+}
+class SortOrderContainer extends React.Component {
+    constructor(props) {
+        super(props);
+        this.onSelect = (value, direction) => {
+            const { location, history } = this.props;
+            updateSortOrderHistory({ location, history, value, direction });
+            this.setState({ sortOrder: value, direction });
+            return true;
+        };
+        this.state = {
+            sortOrder: null,
+            direction: 'DESCENDING',
+            changeSortOrder: this.onSelect
+        };
+    }
+    componentDidMount() {
+        if (this.props.location.search) {
+            const sortOrder = getSortOrderFromQueryString(this.props.location.search);
+            if (sortOrder) {
+                this.setState(sortOrder);
+            }
+        }
+    }
+    render() {
+        return (React.createElement(SortOrderContext.Provider, { value: this.state }, this.props.children(this.state)));
+    }
+}
+export default withRouter(SortOrderContainer);
 //# sourceMappingURL=SortOrderContainer.js.map

package/components/SortOrder/SortOrderContext.d.ts

@@ -1,9 +1,9 @@
-import React from 'react';
-export declare type Direction = 'ASCENDING' | 'DESCENDING';
-export interface ISortOrderContext {
-    changeSortOrder: (value: string, direction: Direction) => void;
-    direction: Direction;
-    sortOrder: string;
-}
-declare const SortOrderContext: React.Context<ISortOrderContext>;
-export default SortOrderContext;
+import React from 'react';
+export declare type Direction = 'ASCENDING' | 'DESCENDING';
+export interface ISortOrderContext {
+    changeSortOrder: (value: string, direction: Direction) => void;
+    direction: Direction;
+    sortOrder: string;
+}
+declare const SortOrderContext: React.Context<ISortOrderContext>;
+export default SortOrderContext;

package/components/SortOrder/SortOrderContext.js

@@ -1,9 +1,9 @@
-import React from 'react';
-const initialSortOrderState = {
-    changeSortOrder: () => { },
-    direction: null,
-    sortOrder: null
-};
-const SortOrderContext = React.createContext(initialSortOrderState);
-export default SortOrderContext;
+import React from 'react';
+const initialSortOrderState = {
+    changeSortOrder: () => { },
+    direction: null,
+    sortOrder: null
+};
+const SortOrderContext = React.createContext(initialSortOrderState);
+export default SortOrderContext;
 //# sourceMappingURL=SortOrderContext.js.map