@open-tender/store 0.1.10 → 0.1.281

package/dist/esm/hooks/useCardSwipe.js

@@ -0,0 +1,76 @@
+import { __awaiter, __generator } from "tslib";
+import { handleRespError } from '@open-tender/utils';
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+var parseSwipeCard = function (data) {
+    try {
+        var parts = data.split('?');
+        var code = parts[0].slice(1);
+        return code.length > 36 ? null : code;
+    }
+    catch (err) {
+        return null;
+    }
+};
+var useCardSwipe = function (api, parse) {
+    if (parse === void 0) { parse = true; }
+    var isAborted = useRef(false);
+    var _a = useState(null), code = _a[0], setCode = _a[1];
+    var _b = useState(null), error = _b[0], setError = _b[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var read = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var data, err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.getCardRead()];
+                case 1:
+                    data = (_a.sent()).data;
+                    if (parse)
+                        data = parseSwipeCard(data);
+                    data ? setCode(data) : setError('Could not read card. Please try again.');
+                    if (!isAborted.current) {
+                        data
+                            ? setCode(data)
+                            : setError('Could not read card. Please try again.');
+                    }
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_1 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_1).detail;
+                        setError(detail || 'Unknown erorr');
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api, parse]);
+    var cancel = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var err_2, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.postCardCancel()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_2 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_2).detail;
+                        setError(detail || 'Unknown erorr');
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    return useMemo(function () { return ({ code: code, error: error, read: read, cancel: cancel }); }, [code, error, read, cancel]);
+};
+export default useCardSwipe;

package/dist/esm/hooks/useChipDNATender/index.d.ts

@@ -0,0 +1,2 @@
+import useChipDNATender from './useChipDNATender';
+export default useChipDNATender;

package/dist/esm/hooks/useChipDNATender/index.js

@@ -0,0 +1,2 @@
+import useChipDNATender from './useChipDNATender';
+export default useChipDNATender;

package/dist/esm/hooks/useChipDNATender/useChipDNATender.d.ts

@@ -0,0 +1,8 @@
+declare const useChipDNATender: (amount: string | null) => {
+    message: string;
+    success: string | null;
+    canceled: string | null;
+    error: string | null;
+    cancel: () => Promise<void>;
+};
+export default useChipDNATender;

package/dist/esm/hooks/useChipDNATender/useChipDNATender.js

@@ -0,0 +1,111 @@
+import { __awaiter, __generator } from "tslib";
+import { handleRespError } from '@open-tender/utils';
+import { useEffect, useState } from 'react';
+import { useAppDispatch, useAppSelector } from '../../app/hooks';
+import { completeChipDNA, selectApi, selectOrder } from '../../slices';
+import { processMessage } from './useChipDNATender.utils';
+// JC Amex card token: 440abfc9cc7518f1ad76e2be56f19fe4
+var useChipDNATender = function (amount) {
+    var dispatch = useAppDispatch();
+    var orderId = useAppSelector(selectOrder).orderId;
+    var api = useAppSelector(selectApi);
+    var _a = useState(false), reading = _a[0], setReading = _a[1];
+    var _b = useState('Pending...'), message = _b[0], setMessage = _b[1];
+    var _c = useState(null), success = _c[0], setSuccess = _c[1];
+    var _d = useState(null), canceled = _d[0], setCanceled = _d[1];
+    var _e = useState(null), error = _e[0], setError = _e[1];
+    useEffect(function () {
+        var readChipDNA = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var data, response, reader_1, card_token_1, card_msg_1, err_1, error_1, detail;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setReading(true);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        if (!amount)
+                            return [2 /*return*/];
+                        data = { tender_type: 'CREDIT', amount: amount };
+                        if (!orderId)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, api.postChipDNATender(orderId, data)];
+                    case 2:
+                        response = _a.sent();
+                        reader_1 = response.getReader();
+                        card_token_1 = null;
+                        card_msg_1 = null;
+                        reader_1.read().then(function processText(_a) {
+                            var done = _a.done, value = _a.value;
+                            // done - true if the stream has already given you all its data.
+                            // value - some data. Always undefined when done is true.
+                            if (done) {
+                                if (card_token_1 || card_msg_1 === 'TENDER_CREATED') {
+                                    setSuccess('Card authorized!');
+                                }
+                                else if (card_msg_1 === 'TRANSACTION_DECLINED') {
+                                    setError('Transaction DECLINED. Please try again.');
+                                }
+                                else if (card_msg_1 !== 'TRANSACTION_CANCELED') {
+                                    setError('Card read error. Please try again.');
+                                }
+                                console.log('card_token', card_token_1);
+                                dispatch(completeChipDNA(card_token_1));
+                                return;
+                            }
+                            var _b = processMessage(value), msg = _b.msg, msgType = _b.msgType, token = _b.token;
+                            var decoded = new TextDecoder('utf-8').decode(value);
+                            console.log('done', done);
+                            console.log(decoded);
+                            console.log(msg, msgType, token);
+                            if (msg)
+                                setMessage(msg);
+                            card_token_1 = token;
+                            card_msg_1 = msgType;
+                            // console.log('card_msg', card_msg)
+                            // console.log('card_token', card_token)
+                            return reader_1.read().then(processText);
+                        });
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        error_1 = handleRespError(err_1);
+                        detail = error_1.detail;
+                        setError(detail || 'Unknown payment error. Please contact support.');
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        if (!reading && amount && amount !== '0.00')
+            readChipDNA();
+    }, [api, dispatch, reading, orderId, amount]);
+    var cancel = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var err_2, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.postChipDNACancel()];
+                case 1:
+                    _a.sent();
+                    setCanceled('EMV transaction canceled');
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_2 = _a.sent();
+                    detail = handleRespError(err_2).detail;
+                    setError(detail || 'Unknown cancellation error. Please contact support.');
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+    return {
+        message: message,
+        success: success,
+        canceled: canceled,
+        error: error,
+        cancel: cancel
+    };
+};
+export default useChipDNATender;

package/dist/esm/hooks/useChipDNATender/useChipDNATender.utils.d.ts

@@ -0,0 +1,5 @@
+export declare const processMessage: (value?: BufferSource) => {
+    msgType: string | null;
+    msg: string | null;
+    token: any;
+};

package/dist/esm/hooks/useChipDNATender/useChipDNATender.utils.js

@@ -0,0 +1,34 @@
+import { capitalize } from '@open-tender/utils';
+var makeMessage = function (event) {
+    if (!event)
+        return null;
+    var msgType = event.replace('event: ', '').trim();
+    var msg = msgType
+        .split('_')
+        .map(function (s) { return capitalize(s); })
+        .join(' ');
+    return { msgType: msgType, msg: msg };
+};
+var parseToken = function (data) {
+    if (!data)
+        return null;
+    try {
+        var tender = JSON.parse(data.replace('data: ', ''));
+        var token = (tender.credit_card || {}).token;
+        return token || null;
+    }
+    catch (err) {
+        return null;
+    }
+};
+export var processMessage = function (value) {
+    var decoded = new TextDecoder('utf-8').decode(value);
+    var lines = decoded.split('\n');
+    var events = lines.filter(function (i) { return i.startsWith('event:'); });
+    var event = events[events.length - 1];
+    var _a = makeMessage(event) || {}, _b = _a.msgType, msgType = _b === void 0 ? null : _b, _c = _a.msg, msg = _c === void 0 ? null : _c;
+    var datas = lines.filter(function (i) { return i.startsWith('data:'); });
+    var data = datas[datas.length - 1];
+    var token = parseToken(data);
+    return { msgType: msgType, msg: msg, token: token };
+};

package/dist/esm/hooks/useCustomerRewards.d.ts

@@ -0,0 +1,14 @@
+import { CustomerIdentify, Discounts, OrderCart } from '@open-tender/types';
+declare const useCustomerRewards: () => {
+    customer: CustomerIdentify | null;
+    hasDeals: boolean;
+    hasRewards: boolean;
+    hasPoints: boolean;
+    deals: Discounts;
+    rewards: Discounts;
+    items: OrderCart;
+    points: number;
+    pointsApplied: number;
+    pointsRemaining: number;
+};
+export default useCustomerRewards;

package/dist/esm/hooks/useCustomerRewards.js

@@ -0,0 +1,43 @@
+import { __assign } from "tslib";
+import { useAppSelector } from '../app/hooks';
+import { selectCustomer, selectCustomerIdentified, selectPosCheckout } from '../slices';
+var useCustomerRewards = function () {
+    var customer = useAppSelector(selectCustomerIdentified);
+    var _a = useAppSelector(selectCustomer), rewards = _a.rewards, deals = _a.deals;
+    var _b = useAppSelector(selectPosCheckout) || {}, check = _b.check, _c = _b.points, checkPoints = _c === void 0 ? [] : _c;
+    var _d = (check || {}).cart, cart = _d === void 0 ? [] : _d;
+    if (!customer) {
+        return {
+            customer: null,
+            hasDeals: false,
+            hasRewards: false,
+            hasPoints: false,
+            deals: [],
+            rewards: [],
+            items: [],
+            points: 0,
+            pointsApplied: 0,
+            pointsRemaining: 0
+        };
+    }
+    // const rewards = customer.rewards
+    var points = parseInt(customer.points);
+    var items = cart
+        .map(function (i, index) { return (__assign(__assign({}, i), { points: i.points ? __assign(__assign({}, i.points), { index: index }) : null })); })
+        .filter(function (i) { return i.points && i.points.per < points; });
+    var pointsApplied = checkPoints.reduce(function (t, i) { return (t += i.points); }, 0);
+    var pointsRemaining = points - pointsApplied;
+    return {
+        customer: customer,
+        hasDeals: deals.length > 0,
+        hasRewards: rewards.length > 0,
+        hasPoints: items.length > 0,
+        deals: deals,
+        rewards: rewards,
+        items: items,
+        points: points,
+        pointsApplied: pointsApplied,
+        pointsRemaining: pointsRemaining
+    };
+};
+export default useCustomerRewards;

package/dist/esm/hooks/useEmployee.d.ts

@@ -0,0 +1,8 @@
+import { Employee } from '@open-tender/types';
+declare const useEmployee: (api: any) => {
+    employee: Employee | null;
+    error: string | null;
+    fetch: (identifier: string | number, withPunches?: boolean) => Promise<void>;
+    reset: () => void;
+};
+export default useEmployee;

package/dist/esm/hooks/useEmployee.js

@@ -0,0 +1,62 @@
+import { __awaiter, __generator, __spreadArray } from "tslib";
+import { handleRespError } from '@open-tender/utils';
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+var useEmployee = function (api) {
+    var isAborted = useRef(false);
+    var _a = useState(null), employee = _a[0], setEmployee = _a[1];
+    var _b = useState(null), error = _b[0], setError = _b[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var fetch = useCallback(function (identifier_1) {
+        var args_1 = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args_1[_i - 1] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([identifier_1], args_1, true), void 0, function (identifier, withPunches) {
+            var employee_1, employee_id, response, err_1, detail;
+            if (withPunches === void 0) { withPunches = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, api.getEmployee(identifier)];
+                    case 1:
+                        employee_1 = _a.sent();
+                        if (!withPunches) return [3 /*break*/, 3];
+                        employee_id = employee_1.employee_id;
+                        return [4 /*yield*/, api.getTimePunchesReport(null, employee_id)];
+                    case 2:
+                        response = _a.sent();
+                        if (response.length)
+                            employee_1 = response[0];
+                        _a.label = 3;
+                    case 3:
+                        if (!isAborted.current) {
+                            setEmployee(employee_1);
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        if (!isAborted.current) {
+                            detail = handleRespError(err_1).detail;
+                            if (detail === null || detail === void 0 ? void 0 : detail.includes('does not exist')) {
+                                detail = 'Employee not found. Please try again.';
+                            }
+                            setError(detail || 'Unknown erorr');
+                        }
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    }, [api]);
+    var reset = useCallback(function () {
+        setEmployee(null);
+        setError(null);
+    }, []);
+    return useMemo(function () { return ({ employee: employee, error: error, fetch: fetch, reset: reset }); }, [employee, error, fetch, reset]);
+};
+export default useEmployee;

package/dist/esm/hooks/useGiftCardBalance.d.ts

@@ -0,0 +1,9 @@
+import { GiftCardBalance } from '@open-tender/types';
+declare const useGiftCardBalance: (api: any) => {
+    giftCard: GiftCardBalance | null;
+    loading: string;
+    error: string | null;
+    fetch: (code: string) => Promise<void>;
+    reset: () => void;
+};
+export default useGiftCardBalance;

package/dist/esm/hooks/useGiftCardBalance.js

@@ -0,0 +1,50 @@
+import { __awaiter, __generator } from "tslib";
+import { handleRespError } from '@open-tender/utils';
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+var useGiftCardBalance = function (api) {
+    var isAborted = useRef(false);
+    var _a = useState(null), giftCard = _a[0], setGiftCard = _a[1];
+    var _b = useState('idle'), loading = _b[0], setLoading = _b[1];
+    var _c = useState(null), error = _c[0], setError = _c[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var fetch = useCallback(function (code) { return __awaiter(void 0, void 0, void 0, function () {
+        var giftCard_1, err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setLoading('pending');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, api.getGiftCardBalance(code)];
+                case 2:
+                    giftCard_1 = _a.sent();
+                    if (!isAborted.current) {
+                        setGiftCard(giftCard_1);
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_1).detail;
+                        setError(detail || 'Unknown error');
+                    }
+                    return [3 /*break*/, 4];
+                case 4:
+                    setLoading('idle');
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    var reset = useCallback(function () {
+        setGiftCard(null);
+        setLoading('idle');
+        setError(null);
+    }, []);
+    return useMemo(function () { return ({ giftCard: giftCard, loading: loading, error: error, fetch: fetch, reset: reset }); }, [giftCard, loading, error, fetch, reset]);
+};
+export default useGiftCardBalance;

package/dist/esm/hooks/useKioskImageUrl.d.ts

@@ -0,0 +1,2 @@
+import { MenuCategory, MenuItem } from '@open-tender/types';
+export declare const useKioskImageUrl: (entity: MenuItem | MenuCategory) => string | null;

package/dist/esm/hooks/useKioskImageUrl.js

@@ -0,0 +1,10 @@
+import { useAppSelector } from '../app/hooks';
+import { selectKioskApi } from '../slices';
+export var useKioskImageUrl = function (entity) {
+    var apiUrl = useAppSelector(selectKioskApi);
+    var app_image_url = entity.app_image_url, small_image_url = entity.small_image_url, large_image_url = entity.large_image_url;
+    var imageUrl = small_image_url || app_image_url || large_image_url;
+    if (!imageUrl)
+        return null;
+    return imageUrl.startsWith('/cloud-files') ? apiUrl + imageUrl : imageUrl;
+};

package/dist/esm/hooks/useOrder.d.ts

@@ -0,0 +1,24 @@
+import { Order } from '@open-tender/types';
+declare const useOrder: (order: Order, callback?: () => void) => {
+    isInPrepQueue: boolean;
+    isUpcoming: boolean;
+    itemImages: {
+        title: string;
+        imageUrl: string;
+    }[];
+    itemNames: string;
+    status: import("@open-tender/types").OrderStatus;
+    orderId: number | null;
+    orderPrep: import("@open-tender/types").OrderPrep | null;
+    orderType: import("@open-tender/types").OrderType;
+    orderTypeName: string | undefined;
+    reorder: () => void;
+    requestedAt: string;
+    revenueCenter: import("@open-tender/types").OrderRevenueCenter;
+    serviceType: import("@open-tender/types").ServiceType;
+    subtitle: string;
+    orderNo: string;
+    title: string;
+    total: `${number}.${number}`;
+};
+export default useOrder;

package/dist/esm/hooks/useOrder.js

@@ -0,0 +1,51 @@
+import { formatDollars, isoToDate, isoToDateStr, makeOrderTypeName, timezoneMap } from '@open-tender/utils';
+import { useAppDispatch } from '../app/hooks';
+import { setOrderServiceType } from '../slices';
+var useOrder = function (order, callback) {
+    var dispatch = useAppDispatch();
+    var orderId = order.order_id, status = order.status, serviceType = order.service_type, orderType = order.order_type, revenueCenter = order.revenue_center, requested_at = order.requested_at, timezone = order.timezone, cart = order.cart, totals = order.totals, orderPrep = order.order_prep;
+    var _a = (orderPrep || {}).is_in_prep_queue, isInPrepQueue = _a === void 0 ? false : _a;
+    var orderTypeName = makeOrderTypeName(orderType, serviceType);
+    var orderPrepType = (orderPrep === null || orderPrep === void 0 ? void 0 : orderPrep.prep_type) === 'TAKE_OUT' ? 'Take Out' : 'Dine In';
+    var tz = timezoneMap[timezone];
+    var requestedAt = isoToDateStr(requested_at, tz, 'MMMM d, yyyy @ h:mma');
+    var isUpcoming = isoToDate(requested_at) > new Date();
+    var itemImages = cart
+        .map(function (i) {
+        return i.images
+            .filter(function (m) { return m.type === 'SMALL_IMAGE' && m.url; })
+            .map(function (image) { return ({ title: i.name, imageUrl: image.url }); });
+    })
+        .flat();
+    var itemNames = cart.map(function (i) { return i.name; }).join(', ');
+    var total = totals.total;
+    var orderNo = "Order #".concat(orderId);
+    var title = "".concat(orderPrepType, " from ").concat(revenueCenter.name);
+    var subtitle = "".concat(requestedAt, " | ").concat(formatDollars(total));
+    var reorder = function () {
+        // const { revenue_center_id: revenueCenterId } = revenueCenter
+        dispatch(setOrderServiceType({ orderType: 'OLO', serviceType: 'WALKIN' }));
+        if (callback)
+            callback();
+    };
+    return {
+        isInPrepQueue: isInPrepQueue,
+        isUpcoming: isUpcoming,
+        itemImages: itemImages,
+        itemNames: itemNames,
+        status: status,
+        orderId: orderId,
+        orderPrep: orderPrep,
+        orderType: orderType,
+        orderTypeName: orderTypeName,
+        reorder: reorder,
+        requestedAt: requestedAt,
+        revenueCenter: revenueCenter,
+        serviceType: serviceType,
+        subtitle: subtitle,
+        orderNo: orderNo,
+        title: title,
+        total: total
+    };
+};
+export default useOrder;

package/dist/esm/hooks/useOrderValidate.d.ts

@@ -0,0 +1,2 @@
+declare const useOrderValidate: () => void;
+export default useOrderValidate;

package/dist/esm/hooks/useOrderValidate.js

@@ -0,0 +1,20 @@
+import { __rest } from "tslib";
+import { useEffect } from 'react';
+import isEqual from 'react-fast-compare';
+import { useAppDispatch, useAppSelector } from '../app/hooks';
+import { prepareOrder, selectOrder, selectPosCheckout, validatePosOrder } from '../slices';
+import usePrevious from './usePrevious';
+var useOrderValidate = function () {
+    var dispatch = useAppDispatch();
+    var checkout = useAppSelector(selectPosCheckout);
+    var order = useAppSelector(selectOrder);
+    var preparedOrder = prepareOrder(order, checkout);
+    var orderCheckout = __rest(preparedOrder || {}, []);
+    var prevOrderCheckout = usePrevious(orderCheckout);
+    useEffect(function () {
+        if (preparedOrder && !isEqual(prevOrderCheckout, orderCheckout)) {
+            dispatch(validatePosOrder());
+        }
+    }, [dispatch, preparedOrder, prevOrderCheckout, orderCheckout]);
+};
+export default useOrderValidate;

package/dist/esm/hooks/usePrevious.d.ts

@@ -0,0 +1,2 @@
+declare const usePrevious: <T>(value: T) => T | undefined;
+export default usePrevious;

package/dist/esm/hooks/usePrevious.js

@@ -0,0 +1,9 @@
+import { useEffect, useRef } from 'react';
+var usePrevious = function (value) {
+    var ref = useRef();
+    useEffect(function () {
+        ref.current = value;
+    });
+    return ref.current;
+};
+export default usePrevious;

package/dist/esm/hooks/usePunch.d.ts

@@ -0,0 +1,12 @@
+import { Employee, Punch } from '@open-tender/types';
+import { ModalState } from '../slices';
+declare const usePunch: (api: any) => {
+    submit: (employee: Employee, blockPin: boolean) => void;
+    send: (data: Punch, employee: Employee) => Promise<void>;
+    print: (employeeId: number) => Promise<void>;
+    error: string | null;
+    msg: string | null;
+    modal: ModalState | null;
+    reset: () => void;
+};
+export default usePunch;