@ancon/wildcat-utils 1.2.0 → 1.2.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './shared';
+export * from './outlet';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./shared"), exports);
+__exportStar(require("./outlet"), exports);

package/dist/outlet/getListOutletOpeningHoursTable.d.ts

@@ -0,0 +1,31 @@
+import { ListOutlet } from './types';
+declare type ReadableOrderFormat = {
+    id: number;
+    name: string;
+};
+declare type ISOString = string;
+export declare type FormattedInterval = {
+    id: string;
+    start: ISOString;
+    end: ISOString;
+    reason?: string;
+};
+declare type OpeningHours = {
+    isoWeekday: number;
+    key: string;
+    open: FormattedInterval[];
+    adjusted: FormattedInterval[];
+    closed: FormattedInterval[];
+};
+export declare type OpeningHoursTable = {
+    orderFormats: ReadableOrderFormat[];
+    openingHours: OpeningHours[];
+};
+/**
+ * Get an array of opening hours divided by order formats
+ * @param outlet Outlet from nearby endpoint
+ * @param nowISOString Optional ISO date string of current datetime
+ * @returns Opening hours table
+ */
+export default function getListOutletOpeningHoursTable(outlet: ListOutlet, nowISOString?: string): OpeningHoursTable[];
+export {};

package/dist/outlet/getListOutletOpeningHoursTable.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment_1 = __importDefault(require("moment"));
+const __1 = require("..");
+const ORDER_FORMATS = [
+    { id: __1.OrderFormat.EatIn, name: 'eatIn' },
+    { id: __1.OrderFormat.Takeaway, name: 'takeaway' },
+    { id: __1.OrderFormat.TableOrder, name: 'tableOrder' },
+    { id: __1.OrderFormat.Delivery, name: 'delivery' },
+];
+function generateWeekFromToday(nowISOString) {
+    const today = moment_1.default.utc(nowISOString).subtract(1, 'day').startOf('day');
+    const result = [];
+    for (let i = 0, current = today; i < 7; i += 1) {
+        current = current.clone().add(1, 'day').startOf('day');
+        result.push(current.clone());
+    }
+    return result;
+}
+function sortByIsoWeekday(moments) {
+    return [...moments].sort((a, b) => a.isoWeekday() - b.isoWeekday());
+}
+function getIntervalTimestampAsNumbers(timestamp) {
+    return timestamp.split(':').map(Number);
+}
+function formatInterval(interval, weekdayMoment) {
+    const [startHour, startMinute] = getIntervalTimestampAsNumbers(interval.start);
+    const [durationHour, durationMinute] = getIntervalTimestampAsNumbers(interval.duration);
+    if (interval.type === __1.IntervalType.Interval) {
+        const startMoment = weekdayMoment
+            .clone()
+            .add(startHour, 'hour')
+            .add(startMinute, 'minute');
+        const endMoment = startMoment
+            .clone()
+            .add(durationHour, 'hour')
+            .add(durationMinute, 'minute');
+        return {
+            id: interval.id,
+            start: startMoment.toISOString(),
+            end: endMoment.toISOString(),
+        };
+    }
+    if (interval.type === __1.IntervalType.Exception) {
+        const fromDateMoment = (0, moment_1.default)(interval.fromDate);
+        const toDateMoment = (0, moment_1.default)(interval.toDate);
+        if (weekdayMoment.isBetween(fromDateMoment, toDateMoment, undefined, '[]')) {
+            const startMoment = weekdayMoment
+                .clone()
+                .add(startHour, 'hour')
+                .add(startMinute, 'minute');
+            const endMoment = startMoment
+                .clone()
+                .add(durationHour, 'hour')
+                .add(durationMinute, 'minute');
+            return {
+                id: interval.id,
+                start: startMoment.toISOString(),
+                end: endMoment.toISOString(),
+                reason: interval.reason,
+            };
+        }
+        return null;
+    }
+    throw new Error('Invalid interval type');
+}
+function collectReadableInterval(interval, week, collector) {
+    var _a;
+    const weekdayIsoMap = {
+        [__1.DayOfWeek.Monday]: 1,
+        [__1.DayOfWeek.Tuesday]: 2,
+        [__1.DayOfWeek.Wednesday]: 3,
+        [__1.DayOfWeek.Thursday]: 4,
+        [__1.DayOfWeek.Friday]: 5,
+        [__1.DayOfWeek.Saturday]: 6,
+        [__1.DayOfWeek.Sunday]: 7,
+    };
+    for (let i = 0; i < week.length; i += 1) {
+        const weekdayMoment = week[i];
+        const momentIsoWeekday = weekdayMoment.isoWeekday();
+        const intervalWeekdayEnum = interval.dayOfWeek;
+        const intervalIsoWeekday = (_a = weekdayIsoMap[intervalWeekdayEnum]) !== null && _a !== void 0 ? _a : null;
+        const intervalIsApplicableToday = intervalIsoWeekday === momentIsoWeekday ||
+            intervalWeekdayEnum === __1.DayOfWeek.Everyday;
+        if (!collector[momentIsoWeekday]) {
+            // eslint-disable-next-line no-param-reassign
+            collector[momentIsoWeekday] = {
+                isoWeekday: momentIsoWeekday,
+                key: '',
+                open: [],
+                adjusted: [],
+                closed: [],
+            };
+        }
+        if (intervalIsApplicableToday) {
+            const formattedInterval = formatInterval(interval, weekdayMoment);
+            if (formattedInterval) {
+                // eslint-disable-next-line no-param-reassign
+                collector[momentIsoWeekday].key += formattedInterval.id;
+                if (interval.type === __1.IntervalType.Interval &&
+                    interval.state === __1.IntervalState.Open) {
+                    collector[momentIsoWeekday].open.push(formattedInterval);
+                }
+                else if (interval.type === __1.IntervalType.Interval &&
+                    interval.state === __1.IntervalState.Closed) {
+                    collector[momentIsoWeekday].closed.push(formattedInterval);
+                }
+                else if (interval.type === __1.IntervalType.Exception &&
+                    interval.state === __1.IntervalState.Open) {
+                    collector[momentIsoWeekday].adjusted.push(formattedInterval);
+                }
+                else if (interval.type === __1.IntervalType.Exception &&
+                    interval.state === __1.IntervalState.Closed) {
+                    collector[momentIsoWeekday].closed.push(formattedInterval);
+                }
+            }
+        }
+    }
+}
+function generateIntervalId(interval) {
+    switch (interval.type) {
+        case __1.IntervalType.Exception:
+            return (0, __1.generateId)('interval-exception');
+        case __1.IntervalType.Interval:
+            return (0, __1.generateId)('interval-normal');
+        default:
+            return (0, __1.generateId)('interval-unknown');
+    }
+}
+function splitServiceDateTimes(serviceDateTimes) {
+    const flattenedMap = serviceDateTimes.reduce((acc, serviceDateTime) => {
+        ORDER_FORMATS.forEach(readableOrderFormat => {
+            if ((0, __1.isWithinFlag)(readableOrderFormat.id, serviceDateTime.orderFormats)) {
+                if (!acc[readableOrderFormat.id]) {
+                    acc[readableOrderFormat.id] = {
+                        orderFormat: readableOrderFormat,
+                        intervals: [],
+                    };
+                }
+                acc[readableOrderFormat.id].intervals.push(...serviceDateTime.intervals.sort((a, b) => a.dayOfWeek - b.dayOfWeek));
+            }
+        });
+        return acc;
+    }, {});
+    return Object.values(flattenedMap);
+}
+function mergeDuplicateOpeningHours(tables) {
+    return tables.reduce((acc, table, index) => {
+        const duplicateIndex = acc.findIndex((otherTable) => otherTable !== table &&
+            !otherTable.orderFormats.some(otherOrderFormat => table.orderFormats.some(orderFormat => orderFormat.id === otherOrderFormat.id)) &&
+            otherTable.openingHours.every(openingHours => table.openingHours.some(o => o.key === openingHours.key)) &&
+            table.openingHours.every(openingHours => otherTable.openingHours.some(o => o.key === openingHours.key)));
+        if (duplicateIndex >= 0) {
+            const duplicate = acc[duplicateIndex];
+            acc.splice(duplicateIndex, 1, Object.assign(Object.assign({}, duplicate), { orderFormats: [...table.orderFormats, ...duplicate.orderFormats] }));
+            acc.splice(index, 1);
+            return acc;
+        }
+        return acc;
+    }, [...tables]);
+}
+function identifyIntervals(serviceDateTimes) {
+    return serviceDateTimes.map(serviceDateTime => (Object.assign(Object.assign({}, serviceDateTime), { intervals: serviceDateTime.intervals.map(interval => (Object.assign(Object.assign({}, interval), { id: generateIntervalId(interval) }))) })));
+}
+/**
+ * Get an array of opening hours divided by order formats
+ * @param outlet Outlet from nearby endpoint
+ * @param nowISOString Optional ISO date string of current datetime
+ * @returns Opening hours table
+ */
+function getListOutletOpeningHoursTable(outlet, nowISOString) {
+    // Split service date times into one array for each order format
+    const splittedServiceDateTimes = splitServiceDateTimes(identifyIntervals(outlet.serviceDateTimes));
+    // Get next 7 days including today
+    const generatedWeekFromToday = generateWeekFromToday(nowISOString);
+    // Sort days by ISO weekday (Monday first)
+    const sortedWeek = sortByIsoWeekday(generatedWeekFromToday);
+    const intervalsOrderFormatMap = splittedServiceDateTimes.reduce((acc, serviceDateTime) => {
+        if (!acc[serviceDateTime.orderFormat.id]) {
+            acc[serviceDateTime.orderFormat.id] = {};
+        }
+        serviceDateTime.intervals.reduce((intervalsAcc, interval) => {
+            collectReadableInterval(interval, sortedWeek, intervalsAcc);
+            return intervalsAcc;
+        }, acc[serviceDateTime.orderFormat.id]);
+        return acc;
+    }, {});
+    const readableOrderFormatMap = {
+        [__1.OrderFormat.EatIn]: ORDER_FORMATS[0],
+        [__1.OrderFormat.Takeaway]: ORDER_FORMATS[1],
+        [__1.OrderFormat.TableOrder]: ORDER_FORMATS[2],
+        [__1.OrderFormat.Delivery]: ORDER_FORMATS[3],
+    };
+    const openingHoursTable = Object.entries(intervalsOrderFormatMap).map(([orderFormatId, intervals]) => ({
+        orderFormats: [readableOrderFormatMap[Number(orderFormatId)]],
+        openingHours: Object.entries(intervals).map(([isoWeekday, readableInterval]) => ({
+            isoWeekday: Number(isoWeekday),
+            key: readableInterval.key,
+            open: readableInterval.open.sort((a, b) => a.start.localeCompare(b.start)),
+            adjusted: readableInterval.adjusted.sort((a, b) => a.start.localeCompare(b.start)),
+            closed: readableInterval.closed.sort((a, b) => a.start.localeCompare(b.start)),
+        })),
+    }));
+    const mergedOpeningHours = mergeDuplicateOpeningHours(openingHoursTable);
+    return mergedOpeningHours.sort((a, b) => a.orderFormats[0].id - b.orderFormats[0].id);
+}
+exports.default = getListOutletOpeningHoursTable;

package/dist/outlet/index.d.ts

@@ -0,0 +1 @@
+export { default as getListOutletOpeningHoursTable } from './getListOutletOpeningHoursTable';

package/dist/outlet/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListOutletOpeningHoursTable = void 0;
+var getListOutletOpeningHoursTable_1 = require("./getListOutletOpeningHoursTable");
+Object.defineProperty(exports, "getListOutletOpeningHoursTable", { enumerable: true, get: function () { return __importDefault(getListOutletOpeningHoursTable_1).default; } });

package/dist/outlet/types.d.ts

@@ -0,0 +1,26 @@
+import { DayOfWeek, IntervalState, IntervalType, OrderFormat } from '..';
+/** HH:mm:ss */
+export declare type IntervalTimestamp = string;
+export declare type Interval = {
+    type: IntervalType;
+    state: IntervalState;
+    orderFormat: OrderFormat;
+    dayOfWeek: DayOfWeek;
+    start: IntervalTimestamp;
+    duration: IntervalTimestamp;
+    fromDate: string;
+    toDate: string;
+    reason: string;
+    position: number;
+};
+export declare type ServiceDateTime = {
+    orderFormats: OrderFormat;
+    intervals: Interval[];
+    isDefault: boolean;
+};
+export declare type ListOutlet = {
+    serviceDateTimes: ServiceDateTime[];
+};
+export declare type DetailedOutlet = {
+    openingHours: Interval[];
+};

package/dist/outlet/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/enums.d.ts

@@ -0,0 +1,24 @@
+export declare enum OrderFormat {
+    EatIn = 1,
+    Takeaway = 2,
+    TableOrder = 4,
+    Delivery = 8
+}
+export declare enum DayOfWeek {
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 4,
+    Thursday = 8,
+    Friday = 16,
+    Saturday = 32,
+    Sunday = 64,
+    Everyday = 127
+}
+export declare enum IntervalState {
+    Open = 0,
+    Closed = 1
+}
+export declare enum IntervalType {
+    Interval = 0,
+    Exception = 1
+}

package/dist/shared/enums.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntervalType = exports.IntervalState = exports.DayOfWeek = exports.OrderFormat = void 0;
+var OrderFormat;
+(function (OrderFormat) {
+    OrderFormat[OrderFormat["EatIn"] = 1] = "EatIn";
+    OrderFormat[OrderFormat["Takeaway"] = 2] = "Takeaway";
+    OrderFormat[OrderFormat["TableOrder"] = 4] = "TableOrder";
+    OrderFormat[OrderFormat["Delivery"] = 8] = "Delivery";
+})(OrderFormat = exports.OrderFormat || (exports.OrderFormat = {}));
+var DayOfWeek;
+(function (DayOfWeek) {
+    DayOfWeek[DayOfWeek["Monday"] = 1] = "Monday";
+    DayOfWeek[DayOfWeek["Tuesday"] = 2] = "Tuesday";
+    DayOfWeek[DayOfWeek["Wednesday"] = 4] = "Wednesday";
+    DayOfWeek[DayOfWeek["Thursday"] = 8] = "Thursday";
+    DayOfWeek[DayOfWeek["Friday"] = 16] = "Friday";
+    DayOfWeek[DayOfWeek["Saturday"] = 32] = "Saturday";
+    DayOfWeek[DayOfWeek["Sunday"] = 64] = "Sunday";
+    DayOfWeek[DayOfWeek["Everyday"] = 127] = "Everyday";
+})(DayOfWeek = exports.DayOfWeek || (exports.DayOfWeek = {}));
+var IntervalState;
+(function (IntervalState) {
+    IntervalState[IntervalState["Open"] = 0] = "Open";
+    IntervalState[IntervalState["Closed"] = 1] = "Closed";
+})(IntervalState = exports.IntervalState || (exports.IntervalState = {}));
+var IntervalType;
+(function (IntervalType) {
+    IntervalType[IntervalType["Interval"] = 0] = "Interval";
+    IntervalType[IntervalType["Exception"] = 1] = "Exception";
+})(IntervalType = exports.IntervalType || (exports.IntervalType = {}));

package/dist/shared/generateId.d.ts

@@ -0,0 +1 @@
+export default function generateId(name?: string): string;

package/dist/shared/generateId.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function generateId(name) {
+    const rnd = Math.random().toString();
+    return `${name ? `${name}-` : ''}${rnd.substring(2)}`;
+}
+exports.default = generateId;

package/dist/shared/index.d.ts

@@ -0,0 +1,3 @@
+export { IntervalState, DayOfWeek, IntervalType, OrderFormat } from './enums';
+export { default as isWithinFlag } from './isWithinFlag';
+export { default as generateId } from './generateId';

package/dist/shared/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateId = exports.isWithinFlag = exports.OrderFormat = exports.IntervalType = exports.DayOfWeek = exports.IntervalState = void 0;
+var enums_1 = require("./enums");
+Object.defineProperty(exports, "IntervalState", { enumerable: true, get: function () { return enums_1.IntervalState; } });
+Object.defineProperty(exports, "DayOfWeek", { enumerable: true, get: function () { return enums_1.DayOfWeek; } });
+Object.defineProperty(exports, "IntervalType", { enumerable: true, get: function () { return enums_1.IntervalType; } });
+Object.defineProperty(exports, "OrderFormat", { enumerable: true, get: function () { return enums_1.OrderFormat; } });
+var isWithinFlag_1 = require("./isWithinFlag");
+Object.defineProperty(exports, "isWithinFlag", { enumerable: true, get: function () { return __importDefault(isWithinFlag_1).default; } });
+var generateId_1 = require("./generateId");
+Object.defineProperty(exports, "generateId", { enumerable: true, get: function () { return __importDefault(generateId_1).default; } });

package/dist/shared/isWithinFlag.d.ts

@@ -0,0 +1 @@
+export default function isWithinFlag(needle: number, haystack: number): boolean;

package/dist/shared/isWithinFlag.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isWithinFlag(needle, haystack) {
+    return (haystack & needle) === needle;
+}
+exports.default = isWithinFlag;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ancon/wildcat-utils",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "",
   "repository": "git@bitbucket.org:anconab/wildcat.utils.git",
   "main": "dist/index.js",