@feedmepos/mf-order-setting 0.0.4 → 0.0.6

package/src/components/type.ts

@@ -0,0 +1,103 @@
+import type { DefineComponent } from 'vue';
+
+export type InputModel = string | number | boolean | null;
+
+export enum AUTH_CODE_TYPE {
+  ALL = 'ALL',
+  ALPHA = 'ALPHA',
+  ALPHANUMERIC = 'ALPHANUMERIC',
+  NUMERIC = 'NUMERIC',
+}
+
+export interface GlobalDialogType extends DefineComponent {
+  onDialogOK: (v?: any) => void;
+  onDialogCancel: () => void;
+  validate: () => Promise<boolean>;
+  reset: () => void;
+}
+
+export type DatePickerData = Date | {
+  start: Date;
+  end: Date;
+}
+
+export interface PickerGroup {
+  label: string;
+  value: string;
+  options: PickerOption[];
+}
+
+export interface PickerOption {
+  label: string;
+  value: string;
+}
+
+export interface CheckboxOption {
+  key?: string;
+  label: string;
+  value: any;
+  disable?: boolean;
+  suffix?: {
+    text: string;
+    class: string;
+  },
+}
+
+export interface TableColumn<T> {
+  name: string;
+  label: string;
+  field: keyof T | ((v: T) => any);
+  sort?: boolean | ((a: { index: number; value: any }, b: { index: number; value: any }) => number);
+  hide?: boolean;
+  format?: (v: any) => string;
+  align?: 'left' | 'right' | 'center';
+  option?: {
+    style?: string;
+    class?: string;
+  };
+}
+
+export interface TableOption<T> {
+  columns: TableColumn<T>[];
+  data: T[];
+  rowId?: keyof T | ((v: T) => string);
+  initialSort?: {
+    key: string;
+    descending?: boolean;
+  };
+  pagination?: {
+    sortBy?: string;
+    descending?: boolean;
+    page?: number;
+    rowsPerPage?: number;
+  };
+}
+
+export interface MoreActionOption {
+  label: string;
+  class?: string;
+  disable?: boolean | string;
+  hide?: boolean;
+  callback: () => Promise<unknown>;
+}
+
+export interface MapCoordinate {
+  lat: number;
+  lng: number;
+}
+
+export interface MapPolygon {
+  paths: MapCoordinate[];
+  strokeColor?: string;
+  fillColor?: string;
+}
+
+export interface MarkerChangeEvent {
+  index: number;
+  position: MapCoordinate;
+}
+
+export interface PolygonChangeEvent {
+  index: number;
+  path: MapCoordinate[];
+}

package/src/composables/index.ts

@@ -0,0 +1,7 @@
+
+import useSearch from './search';
+
+export {
+
+  useSearch,
+};

package/src/composables/loading/index.ts

@@ -0,0 +1,51 @@
+import { ref } from 'vue';
+
+export const useLoading = () => {
+  const isLoading = ref(false);
+
+  function startLoading() {
+    isLoading.value = true;
+  }
+
+  function stopLoading() {
+    isLoading.value = false;
+  }
+
+  /**
+   * A more advance way that automatically calls startLoading() and stopLoading() based on callback
+   * @param cb Callback that performs asynchronous task.
+   * @returns Returns generic result based on passed callback.
+   */
+  async function startAsyncCall<T>(cb: () => Promise<T>): Promise<T> {
+    try {
+      startLoading();
+      return await cb();
+    } finally {
+      stopLoading();
+    }
+  }
+
+  /**
+   * A more advance way that automatically calls startLoading() and stopLoading() based on callback
+   * @param cb Callback that performs asynchronous task.
+   * @returns Returns generic result based on passed callback. Throw error if have
+   */
+  async function startAsyncCallWithErr<T>(cb: () => Promise<T>): Promise<T> {
+    try {
+      startLoading();
+      return await cb();
+    } catch(e) {
+      throw e;
+    } finally {
+      stopLoading();
+    }
+  }
+
+  return {
+    isLoading,
+    startLoading,
+    stopLoading,
+    startAsyncCall,
+    startAsyncCallWithErr
+  };
+};

package/src/composables/search.ts

@@ -0,0 +1,18 @@
+import { computed, ref } from 'vue';
+
+export default (initialValue?: string) => {
+  const searchKey = ref(initialValue || '');
+
+  function format(text: unknown) {
+    return `${text}`.trim().toLowerCase();
+  }
+
+  const formattedSearchKey = computed(() => format(searchKey.value));
+
+  function filter(arr: unknown[]): boolean {
+    if (!formattedSearchKey.value) return true;
+    return arr.some((el) => format(el).includes(formattedSearchKey.value));
+  }
+
+  return { searchKey, filter };
+};

package/src/helpers/currency.ts

@@ -0,0 +1,6 @@
+import { Dinero } from '@feedmepos/core';
+import { FdoDinero } from '@feedmepos/core/entity';
+
+export function formatCurrency(value: FdoDinero, withSymbol = true): string {
+  return Dinero.fromFdoDinero(value).toFormat(withSymbol).replace(/\s+/g, '');
+}

package/src/helpers/date.ts

@@ -0,0 +1,29 @@
+import Day from 'dayjs';
+
+
+export function formatDuration(totalMinutes: number): string {
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}h ${minutes.toString().padStart(2, '0')}m`;
+}
+
+export class DateRange {
+  private range: {
+    start: string;
+    end: string;
+  };
+  constructor(dateRange: { start: string; end: string }) {
+    this.range = dateRange;
+  }
+
+  private format(string: string, format?: string) {
+    return Day(string).format(format || 'DD/MM/YYYY');
+  }
+
+  formatWith(format?: string, divider?: string) {
+    const start = this.format(this.range.start, format);
+    const end = this.format(this.range.end, format);
+    return `${start} ${divider || '-'} ${end}`;
+  }
+}
+

package/src/helpers/iteration.ts

@@ -0,0 +1,87 @@
+import { utils } from '@feedmepos/core';
+const clone = utils.clone;
+
+type Selector<T> = keyof T | ((item: T) => string);
+
+function retrieveValue<T>(element: T, key?: Selector<T>) {
+  if (key === undefined) return element as any;
+  return typeof key === 'function' ? key(element) : `${element[key]}`;
+}
+
+function sort<T>(arr: T[], option?: { selector?: Selector<T>, descending?: boolean } | undefined): T[] {
+  const cloned = clone(arr);
+  return cloned.sort((a, b) => {
+    let keyA = retrieveValue(a, option?.selector);
+    let keyB = retrieveValue(b, option?.selector);
+    if (option?.descending) {
+      const [a, b] = [keyA, keyB];
+      keyA = b;
+      keyB = a;
+    }
+    return keyA.localeCompare(keyB, 'en', { numeric: true, sensitivity: 'base' });
+  });
+}
+
+function group<T>(arr: T[], by: Selector<T>): { [key: string]: T[] } {
+  return arr.reduce<{ [key: string]: T[] }>((pv, v) => {
+    const key = retrieveValue(v, by);
+    pv[key] = [...(pv[key] || []), v];
+    return pv;
+  }, {});
+}
+
+function insertIfNotExist<T>(arr: T[], value: T): T[] {
+  return !arr.includes(value)
+    ? [...arr, value]
+    : arr;
+}
+
+function remove<T>(arr: T[], target: T, selector?: Selector<T>) {
+  return arr.filter((v) => retrieveValue(v, selector) !== retrieveValue(target, selector));
+}
+
+function insertOrUpdate<T>(arr: T[], value: T, selector?: keyof T): T[] {
+  const index = arr.findIndex((el) => retrieveValue(el, selector) === retrieveValue(value, selector));
+  if (index < 0) {
+    return [...arr, value];
+  }
+  return arr.map((oldV, i) => i !== index ? oldV : value);
+}
+
+function insertOrRemove<T>(arr: T[], value: T): T[] {
+  const index = arr.findIndex((el) => el === value);
+  if (index < 0) {
+    return [...arr, value];
+  }
+  return arr.filter((_, i) => i !== index);
+}
+
+function* intersperse(iterable: any[], separator: any) {
+  const iterator = iterable[Symbol.iterator]();
+  const first = iterator.next();
+  if (first.done) return;
+  else yield first.value;
+  for (const value of iterator) {
+    yield separator;
+    yield value;
+  }
+}
+
+function chunk<T>(list: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < list.length; i += size) {
+    chunks.push(list.slice(i, i + size > list.length ? list.length : i + size));
+  }
+  return chunks;
+}
+
+export {
+  sort,
+  group,
+  insertIfNotExist,
+  remove,
+  insertOrUpdate,
+  insertOrRemove,
+  intersperse,
+  chunk
+};

package/src/helpers/map.ts

@@ -0,0 +1,92 @@
+import { type MapCoordinate } from '@/components/type';
+
+let googleMap: typeof google;
+
+export function setGoogleMap(map: typeof google) {
+  if (!googleMap) googleMap = map;
+}
+
+const coordinates = Object.freeze({
+  'jb': {
+    lat: 1.492659,
+    lng: 103.7413591
+  },
+});
+
+function coordinateToArray(v: { lat: number; lng: number }) {
+  return [v.lng, v.lat];
+}
+
+function arrayToCoordinate(arr: number[]) {
+  if (arr.length !== 2) throw Error('Invalid coordinate array');
+  return {
+    lat: arr[1],
+    lng: arr[0]
+  };
+}
+
+function generateAreaPaths({
+  center,
+  radius,
+}: {
+  radius: number;
+  center: {
+    lng: number;
+    lat: number;
+  }
+}): { lat: number; lng: number }[] {
+  const searchPoint = [];
+  const radiusLat = (radius / 6371) * (180 / Math.PI);
+  const radiusLng = radiusLat / Math.cos(center.lat * (Math.PI / 180));
+  for (let a = 0; a < 361; a += 45) {
+    const aRad = a * (Math.PI / 180);
+    const x = center.lng + (radiusLng * Math.cos(aRad));
+    const y = center.lat + (radiusLat * Math.sin(aRad));
+    const point = new googleMap.maps.LatLng(y, x, true);
+    searchPoint.push(point);
+  }
+  return searchPoint.map(v => ({ lat: v.lat(), lng: v.lng() }));
+}
+
+function pathToPolygon(path: MapCoordinate[]): number[][] {
+  return path.map((p) => coordinateToArray(p));
+}
+
+function polygonToPath(polygon: number[][]): MapCoordinate[] {
+  return polygon.map((vertex) => arrayToCoordinate(vertex));
+}
+
+function getPolygonCenter(polygon: number[][]): MapCoordinate | undefined {
+  if (!polygon.length) return undefined;
+
+  const { lat, lng } = arrayToCoordinate(polygon[0]);
+  const { maxLng, minLng, maxLat, minLat } = polygon.reduce((pv, path) => {
+    const { lng, lat } = arrayToCoordinate(path);
+    if (lng > pv.maxLng) pv.maxLng = lng;
+    if (lng < pv.minLng) pv.minLng = lng;
+    if (lat > pv.maxLat) pv.maxLat = lat;
+    if (lat < pv.minLat) pv.minLat = lat;
+    return pv;
+  }, {
+    maxLng: lng,
+    minLng: lng,
+    maxLat: lat,
+    minLat: lat
+  });
+
+  return {
+    lng: minLng + ((maxLng - minLng) / 2),
+    lat: minLat + ((maxLat - minLat) / 2),
+  };
+}
+
+export {
+  googleMap,
+  coordinates,
+  coordinateToArray,
+  arrayToCoordinate,
+  generateAreaPaths,
+  pathToPolygon,
+  polygonToPath,
+  getPolygonCenter,
+};

package/src/helpers/menu.ts

@@ -0,0 +1,166 @@
+import { fullVariantCombination } from '@feedmepos/menu';
+import { FdtoGetFallbackPriceReq, FdtoGetFallbackPriceRes, FdoItemOverriderV4, FdoMenuV4Item, FdoItemVariant, F_MENU_MODULE_V4_KEY, F_ORDER_FROM, FdoHasPosition, FdoMenuV4Category, FdoMenuV4VariantGroup, FdoProductTaxSetting, FdtoV4Tax } from '@feedmepos/menu/entity';
+
+import { sort } from './iteration';
+
+import { Country } from '@feedmepos/core';
+import { useMenuStore } from '@/stores/menu/menu';
+import type { CheckboxOption, PickerGroup } from '@/components/type';
+import { useLoading } from '@/composables/loading';
+import { useAppStore } from '@/stores/app';
+import { utils } from '@feedmepos/core';
+const clone = utils.clone;
+
+
+export interface Option {
+  label: string;
+  value: string | null;
+}
+
+// const { minor, checkIsLoading } = useLoading();
+// export const menuLoader = () => ({
+//   updateMenu: async (
+//     req: UpdateMenuModuleRequest | UpdateMenuModuleRequest[],
+//     name: string,
+//     isDelete = false,
+//     performValidate = false,
+//   ) => {
+//     const menuStore = useMenuStore();
+//     const action = isDelete ? 'removed' : 'saved';
+
+//     await minor(
+//       async () => {
+//         await menuStore.updateMenu(req, performValidate);
+//       },
+//       { successMessage: `${name} ${action}`, customId: menuStore.menu._id }
+//     );
+//   },
+//   saveMenuWithThumbnail: async (
+//     data: FdoMenuV4Item, operation: F_OPERATION_TYPE.update | F_OPERATION_TYPE.create, path: string, image?: File | null, performValidate = false) => {
+//     const menuStore = useMenuStore();
+
+//     await minor(
+//       async () => {
+//         let newImageUrl = '';
+//         if (image) {
+//           await firebaseStorage.update(path, image, appApi.imageBucketUrl);
+//           newImageUrl = generateItemThumbnailUrl(path);
+//         }
+
+//         const result = await menuStore.updateMenu({
+//           module: F_MENU_MODULE_V4_KEY.enum.item,
+//           operation: operation,
+//           data: {
+//             ...data,
+//             thumbnail: newImageUrl || data.thumbnail,
+//           },
+//         }, performValidate);
+
+
+//         //handle thumbnail
+//         if (operation === F_OPERATION_TYPE.create && result?.updateId) {
+//           const newPath = result?.updateId ? generateItemThumbnailPath(result.updateId) : generateItemThumbnailPath();
+//           const itemIndex = result?.menu.modules.item.findIndex((item) => item._id === result?.updateId);
+//           const item = menuStore.menu.modules.item[itemIndex];
+//           let newImageUrl = '';
+//           if (image) {
+//             await firebaseStorage.update(newPath, image, appApi.imageBucketUrl);
+//             newImageUrl = generateItemThumbnailUrl(newPath);
+//           }
+//           await menuStore.updateMenu({
+//             module: F_MENU_MODULE_V4_KEY.enum.item,
+//             operation: F_OPERATION_TYPE.update,
+//             data: {
+//               ...item,
+//               _id: result?.updateId,
+//               thumbnail: newImageUrl || data.thumbnail,
+//             },
+//           }, performValidate);
+//         }
+//       },
+//       { successMessage: `${data.name} saved`, customId: menuStore.menu._id }
+//     );
+
+//   },
+//   checkMenuIsLoading: () => checkIsLoading(useMenuStore().menu._id),
+// });
+
+
+type Item = Omit<FdoMenuV4Item, 'variant'> & {
+  codeName: string;
+  variant?: Omit<FdoItemVariant, 'variantCombinations'> & {
+    variantCombinations: (VariantItem & { codeName: string })[]
+  }
+};
+export interface CategorizedItem {
+  id: string | null;
+  name: string;
+  items: Item[];
+}
+
+interface VariantItem extends FdoItemOverriderV4 {
+  codeName: string;
+}
+
+
+export function mapVariant(
+  variantGroupIds: string[] = []
+): { [key: string]: string } {
+  const variants = variantGroupIds.map((id) => useMenuStore().variants.find((v) => v._id === id)).filter((v) => !!v) as FdoMenuV4VariantGroup[];
+  const combinations = fullVariantCombination(variants);
+  return combinations.reduce<{ [key: string]: string }>((pv, c) => {
+    pv[c.combinationKey] = c.selectionName.join(' / ');
+    return pv;
+  }, {});
+}
+
+export function updateBaseItemOverrider(
+  itemId: string,
+  items: FdoItemOverriderV4[],
+  updateFn: (i: FdoItemOverriderV4) => FdoItemOverriderV4,
+): FdoItemOverriderV4[] {
+  const base = items.find((i) => !i.combinationKey) ?? { _id: itemId };
+  const variants = items.filter((i) => !!i.combinationKey);
+  return [updateFn(base), ...variants];
+}
+
+export interface ProductOption extends CheckboxOption {
+  variant?: CheckboxOption[];
+}
+
+export interface Category {
+  id: string;
+  name: string;
+  items: ProductOption[];
+}
+
+
+export type Tax = FdtoV4Tax[] | null | undefined;
+export class ItemTax {
+  static encodeTax(tax: FdoProductTaxSetting) {
+    return `${tax.systemCode}/${tax.taxCode}`;
+  }
+
+  static decodeTax(identifier: string): FdoProductTaxSetting {
+    const [systemCode, taxCode] = identifier.split('/');
+    return { systemCode, taxCode };
+  }
+
+  // static taxSetting() {
+  //   const countryFlattenTaxes = Country.getCountryFlattenTaxes(useAppStore().country.code);
+
+  //   return {
+  //     systemCode: countryFlattenTaxes[0].systemCode,
+  //     countryTaxOptions: countryFlattenTaxes.map((tax) => ({
+  //       label: `${tax.name} (${FdoDecimalToPercentage(tax.rate)}%)`,
+  //       value: ItemTax.encodeTax(tax),
+  //     })),
+  //   };
+  // }
+
+  static getSelectedTax(tax: Tax, fallbackTax: Tax, taxOptions: { label: string, value: string }[]): string | undefined {
+    return (tax ?? fallbackTax ?? [])
+      .map((t) => ItemTax.encodeTax(t))
+      .find((tax) => taxOptions.some((opt) => opt.value === tax));
+  }
+}

package/src/helpers/number.ts

@@ -0,0 +1,25 @@
+
+
+export interface AdjustmentAmount {
+  amount: number;
+  precision: number;
+}
+
+export function toAdjustmentWithPrecision(
+  amt: string | number,
+  precision = 0,
+  allowNegative = false
+) {
+  let amount = 0;
+  if (!Number.isNaN(Number(amt))) {
+    if (allowNegative || Number(amt) >= 0) amount = Number(amt);
+  }
+  return {
+    amount: Number((amount * 10 ** precision).toFixed(0)),
+    precision
+  };
+}
+
+export function percentToAdjustment(v: number): AdjustmentAmount {
+  return toAdjustmentWithPrecision(Math.floor(v) / 100, 4);
+}

package/src/helpers/object.ts

@@ -0,0 +1,12 @@
+export function clone<T>(value: T, exceptKey: string[] = []): T {
+  const obj = JSON.parse(JSON.stringify(value));
+  if (exceptKey.length > 0) {
+    exceptKey.forEach((key): void => {
+      if (obj[key] !== undefined) {
+        delete obj[key];
+      }
+    });
+  }
+  return obj;
+}
+

package/src/helpers/profile.ts

@@ -0,0 +1,52 @@
+import { FdoProfile, FdoAddress } from '@feedmepos/core/entity';
+
+export interface Address extends FdoAddress {
+  formatted: string;
+  isValidPostcode: boolean;
+  isValid: boolean;
+  isValidCoordinate: boolean;
+}
+
+export interface Profile extends FdoProfile {
+  address: Address;
+}
+
+export function initAddress(): Address {
+  const v = {
+    line1: '',
+    line2: '',
+    city: '',
+    postcode: '',
+    state: '',
+    country: '',
+    coordinates: [],
+  };
+  return formatAddress(v);
+}
+
+export function formatAddress(address: any): Address {
+  return {
+    ...address,
+
+    get formatted(): string {
+      const { line1, line2, postcode, city, state, country } = address;
+      return [line1, (line2 || ''), postcode, city, state, country]
+        .map(v => v.replace(/,\s*$/, ''))
+        .filter(v => !!v.trim())
+        .join(', ');
+    },
+    get isValidPostcode(): boolean {
+      const res = Number.parseInt(address.postcode);
+      return !isNaN(res);
+    },
+    get isValid(): boolean {
+      const optionalFields: (keyof FdoAddress)[] = ['line2'];
+      return Object.keys(address)
+        .filter((key) => !optionalFields.includes(key as keyof FdoAddress))
+        .every(key => !!address[key as keyof FdoAddress]);
+    },
+    get isValidCoordinate(): boolean {
+      return (address.coordinates || []).length === 2;
+    },
+  };
+}

package/src/i18n.ts

@@ -0,0 +1,43 @@
+import type { App } from 'vue';
+import i18next from 'i18next';
+import I18NextVue from 'i18next-vue';
+
+export const appLocale = Object.freeze({
+  defaultLocale: 'en',
+  supportedLocales: [
+    {
+      label: 'English',
+      value: 'en',
+    },
+    {
+      label: '中文',
+      value: 'zh',
+    },
+  ],
+});
+
+export const i18nPromise = i18next
+  .init({
+    // debug: true,
+    ns: ['bill', 'business', 'common', 'device', 'inventory', 'kitchen', 'mall', 'marketing', 'menu', 'order', 'payment', 'printer', 'report', 'restaurant', 'system', 'table', 'transaction', 'user'],
+    backend: {
+      loadPath: '/locales/{{lng}}/{{ns}}.json',
+    },
+    fallbackLng: appLocale.defaultLocale,
+    i18nFormat: {
+      'capitalize': (value: string) => {
+        return value.charAt(0).toUpperCase() + value.slice(1);
+      },
+      'uppercase': (value: string) => {
+        return value.toUpperCase();
+      },
+      'lowercase': (value: string) => {
+        return value.toLowerCase();
+      },
+    }
+  });
+
+export default function (app: App) {
+  app.use(I18NextVue, { i18next });
+  return app;
+}