@unchainedshop/plugins 3.0.0-alpha7 → 3.0.0-rc2

package/src/pricing/order-discount.ts

@@ -1,9 +1,14 @@
-import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/core-orders';
 import {
+  IOrderPricingAdapter,
+  OrderPricingRowCategory,
   OrderPricingDirector,
   OrderPricingAdapter,
   OrderDiscountConfiguration,
-} from '@unchainedshop/core-orders';
+  DeliveryPricingSheet,
+  PaymentPricingSheet,
+  ProductPricingSheet,
+  resolveRatioAndTaxDivisorForPricingSheet,
+} from '@unchainedshop/core';
 import { calculation as calcUtils } from '@unchainedshop/utils';
 
 export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
@@ -20,7 +25,7 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
 
   actions: (params) => {
     const pricingAdapter = OrderPricingAdapter.actions(params);
-    const { order, orderDelivery, orderPositions, orderPayment, modules } = params.context;
+    const { order, orderDelivery, orderPositions, orderPayment } = params.context;
 
     return {
       ...pricingAdapter,
@@ -40,19 +45,29 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
             useNetPrice: false,
           }).amount;
         const itemShares = orderPositions.map((orderPosition) =>
-          calcUtils.resolveRatioAndTaxDivisorForPricingSheet(
-            modules.orders.positions.pricingSheet(orderPosition, order.currency, params.context),
+          resolveRatioAndTaxDivisorForPricingSheet(
+            ProductPricingSheet({
+              calculation: orderPosition.calculation,
+              currency: order.currency,
+              quantity: orderPosition.quantity,
+            }),
             totalAmountOfItems,
           ),
         );
-        const deliveryShare = calcUtils.resolveRatioAndTaxDivisorForPricingSheet(
-          orderDelivery &&
-            modules.orders.deliveries.pricingSheet(orderDelivery, order.currency, params.context),
+
+        const deliveryShare = resolveRatioAndTaxDivisorForPricingSheet(
+          DeliveryPricingSheet({
+            calculation: orderDelivery.calculation || [],
+            currency: order.currency,
+          }),
           totalAmountOfPaymentAndDelivery,
         );
-        const paymentShare = calcUtils.resolveRatioAndTaxDivisorForPricingSheet(
-          orderPayment &&
-            modules.orders.payments.pricingSheet(orderPayment, order.currency, params.context),
+
+        const paymentShare = resolveRatioAndTaxDivisorForPricingSheet(
+          PaymentPricingSheet({
+            calculation: orderPayment.calculation || [],
+            currency: order.currency,
+          }),
           totalAmountOfPaymentAndDelivery,
         );
         let amountLeft = totalAmountOfPaymentAndDelivery + totalAmountOfItems;

package/src/pricing/order-items-discount.ts

@@ -1,9 +1,12 @@
-import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/core-orders';
 import {
+  ProductPricingSheet,
   OrderPricingDirector,
   OrderPricingAdapter,
   OrderDiscountConfiguration,
-} from '@unchainedshop/core-orders';
+  IOrderPricingAdapter,
+  OrderPricingRowCategory,
+  resolveRatioAndTaxDivisorForPricingSheet,
+} from '@unchainedshop/core';
 import { calculation as calcUtils } from '@unchainedshop/utils';
 
 const OrderItemsDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
@@ -20,7 +23,7 @@ const OrderItemsDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
 
   actions: (params) => {
     const pricingAdapter = OrderPricingAdapter.actions(params);
-    const { order, orderPositions, modules } = params.context;
+    const { order, orderPositions } = params.context;
 
     return {
       ...pricingAdapter,
@@ -36,8 +39,12 @@ const OrderItemsDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
         }).amount;
 
         const itemShares = orderPositions.map((orderPosition) =>
-          calcUtils.resolveRatioAndTaxDivisorForPricingSheet(
-            modules.orders.positions.pricingSheet(orderPosition, order.currency, params.context),
+          resolveRatioAndTaxDivisorForPricingSheet(
+            ProductPricingSheet({
+              calculation: orderPosition.calculation,
+              currency: order.currency,
+              quantity: orderPosition.quantity,
+            }),
             totalAmountOfItems,
           ),
         );

package/src/pricing/order-items.ts

@@ -1,5 +1,9 @@
-import { IOrderPricingAdapter } from '@unchainedshop/core-orders';
-import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
+import {
+  IOrderPricingAdapter,
+  OrderPricingDirector,
+  OrderPricingAdapter,
+  ProductPricingSheet,
+} from '@unchainedshop/core';
 
 const OrderItems: IOrderPricingAdapter = {
   ...OrderPricingAdapter,
@@ -15,7 +19,7 @@ const OrderItems: IOrderPricingAdapter = {
 
   actions: (params) => {
     const pricingAdapter = OrderPricingAdapter.actions(params);
-    const { order, orderPositions, modules } = params.context;
+    const { order, orderPositions } = params.context;
 
     return {
       ...pricingAdapter,
@@ -24,11 +28,11 @@ const OrderItems: IOrderPricingAdapter = {
         // just sum up all products items prices, taxes & fees
         const totalAndTaxesOfAllItems = orderPositions.reduce(
           (current, orderPosition) => {
-            const pricing = modules.orders.positions.pricingSheet(
-              orderPosition,
-              order.currency,
-              params.context,
-            );
+            const pricing = ProductPricingSheet({
+              calculation: orderPosition.calculation,
+              currency: order.currency,
+              quantity: orderPosition.quantity,
+            });
             const tax = pricing.taxSum();
             const items = pricing.gross();
             return {

package/src/pricing/order-payment.ts

@@ -1,5 +1,9 @@
-import { IOrderPricingAdapter } from '@unchainedshop/core-orders';
-import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
+import {
+  IOrderPricingAdapter,
+  OrderPricingDirector,
+  OrderPricingAdapter,
+  PaymentPricingSheet,
+} from '@unchainedshop/core';
 
 const OrderPayment: IOrderPricingAdapter = {
   ...OrderPricingAdapter,
@@ -15,7 +19,7 @@ const OrderPayment: IOrderPricingAdapter = {
 
   actions: (params) => {
     const pricingAdapter = OrderPricingAdapter.actions(params);
-    const { order, orderPayment, modules } = params.context;
+    const { order, orderPayment } = params.context;
 
     return {
       ...pricingAdapter,
@@ -24,11 +28,10 @@ const OrderPayment: IOrderPricingAdapter = {
         // just add tax + net price to order pricing
         if (!orderPayment) return null;
 
-        const pricing = modules.orders.payments.pricingSheet(
-          orderPayment,
-          order.currency,
-          params.context,
-        );
+        const pricing = PaymentPricingSheet({
+          calculation: orderPayment.calculation,
+          currency: order.currency,
+        });
         const tax = pricing.taxSum();
         const paymentFees = pricing.gross();
 

package/src/pricing/order-round.ts

@@ -1,5 +1,9 @@
-import { OrderPricingAdapter, OrderPricingDirector } from '@unchainedshop/core-orders';
-import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/core-orders';
+import {
+  OrderPricingAdapter,
+  OrderPricingDirector,
+  IOrderPricingAdapter,
+  OrderPricingRowCategory,
+} from '@unchainedshop/core';
 
 interface PriceRoundSettings {
   defaultPrecision: number;

package/src/pricing/product-catalog-price.ts

@@ -1,11 +1,17 @@
-import { IProductPricingAdapter } from '@unchainedshop/core-products';
-import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+import {
+  ProductPricingDirector,
+  ProductPricingAdapter,
+  IProductPricingAdapter,
+} from '@unchainedshop/core';
 import { resolveBestCurrency } from '@unchainedshop/utils';
-import memoizee from 'memoizee';
+import pMemoize from 'p-memoize';
+import ExpiryMap from 'expiry-map';
 
 const { NODE_ENV } = process.env;
 
-export const resolveCurrency = memoizee(
+const memoizeCache = new ExpiryMap(NODE_ENV === 'production' ? 1000 * 60 : 100); // Cached values expire after 10 seconds
+
+export const resolveCurrency = pMemoize(
   async (context) => {
     const { country, currency: forcedCurrency, modules } = context;
     const countryObject = await modules.countries.findCountry({ isoCode: country });
@@ -15,9 +21,8 @@ export const resolveCurrency = memoizee(
     return currency;
   },
   {
-    maxAge: NODE_ENV === 'production' ? 1000 * 60 : 100, // minute or 100ms
-    promise: true,
-    normalizer(args) {
+    cache: memoizeCache,
+    cacheKey(args) {
       return `${args[0].currency}-${args[0].country}`;
     },
   },

package/src/pricing/product-discount.ts

@@ -1,11 +1,12 @@
-import type { Discount } from '@unchainedshop/utils';
-import { IProductPricingAdapter, ProductPricingRowCategory } from '@unchainedshop/core-products';
+import { calculation as calcUtils } from '@unchainedshop/utils';
 import {
   ProductPricingDirector,
   ProductPricingAdapter,
   ProductDiscountConfiguration,
-} from '@unchainedshop/core-products';
-import { calculation as calcUtils } from '@unchainedshop/utils';
+  IProductPricingAdapter,
+  ProductPricingRowCategory,
+  Discount,
+} from '@unchainedshop/core';
 
 const ProductDiscount: IProductPricingAdapter<ProductDiscountConfiguration> = {
   ...ProductPricingAdapter,

package/src/pricing/product-price-rateconversion.ts

@@ -1,5 +1,8 @@
-import { IProductPricingAdapter } from '@unchainedshop/core-products';
-import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+import {
+  IProductPricingAdapter,
+  ProductPricingDirector,
+  ProductPricingAdapter,
+} from '@unchainedshop/core';
 
 export const ProductPriceRateConversion: IProductPricingAdapter = {
   ...ProductPricingAdapter,

package/src/pricing/product-round.ts

@@ -1,5 +1,8 @@
-import { IProductPricingAdapter } from '@unchainedshop/core-products';
-import { ProductPricingAdapter, ProductPricingDirector } from '@unchainedshop/core-products';
+import {
+  ProductPricingAdapter,
+  ProductPricingDirector,
+  IProductPricingAdapter,
+} from '@unchainedshop/core';
 
 interface PriceRoundSettings {
   defaultPrecision: number;

package/src/pricing/product-swiss-tax.ts

@@ -2,8 +2,10 @@ import {
   ProductPricingDirector,
   ProductPricingAdapter,
   ProductPricingAdapterContext,
-} from '@unchainedshop/core-products';
-import { IProductPricingAdapter, ProductPricingRowCategory } from '@unchainedshop/core-products';
+  IProductPricingAdapter,
+  ProductPricingRowCategory,
+  UnchainedCore,
+} from '@unchainedshop/core';
 import { SwissTaxCategories } from './tax/ch.js';
 
 export const getTaxRate = (context: ProductPricingAdapterContext) => {
@@ -24,7 +26,7 @@ export const isDeliveryAddressInSwitzerland = async ({
   order,
   country,
   modules,
-}: ProductPricingAdapterContext) => {
+}: ProductPricingAdapterContext & { modules: UnchainedCore['modules'] }) => {
   let countryCode = country?.toUpperCase().trim();
 
   if (order) {

package/src/quotations/manual.ts

@@ -1,5 +1,4 @@
-import { IQuotationAdapter } from '@unchainedshop/core-quotations';
-import { QuotationDirector, QuotationAdapter } from '@unchainedshop/core-quotations';
+import { IQuotationAdapter, QuotationDirector, QuotationAdapter } from '@unchainedshop/core';
 
 const ManualOffering: IQuotationAdapter = {
   ...QuotationAdapter,

package/src/warehousing/eth-minter.ts

@@ -1,18 +1,16 @@
 import {
-  WarehousingDirector,
-  WarehousingAdapter,
-  WarehousingProviderType,
-} from '@unchainedshop/core-warehousing';
-import { ProductContractStandard } from '@unchainedshop/core-products';
-import {
+  UnchainedCore,
   IWarehousingAdapter,
   WarehousingContext,
   WarehousingError,
-} from '@unchainedshop/core-warehousing';
+  WarehousingDirector,
+  WarehousingAdapter,
+} from '@unchainedshop/core';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { ProductContractStandard, ProductTypes } from '@unchainedshop/core-products';
 import { systemLocale } from '@unchainedshop/utils';
 import { generateDbObjectId } from '@unchainedshop/mongodb';
-import { UnchainedCore } from '@unchainedshop/core';
-import { ProductTypes } from '@unchainedshop/core-products';
+import { getFileAdapter } from '@unchainedshop/core-files';
 
 const { MINTER_TOKEN_OFFSET = '0' } = process.env;
 
@@ -115,7 +113,10 @@ const ETHMinter: IWarehousingAdapter = {
           limit: 1,
         });
         const file = firstMedia && (await modules.files.findFile({ fileId: firstMedia.mediaId }));
-        const url = file && (await modules.files.getUrl(file, {}));
+
+        const fileUploadAdapter = getFileAdapter();
+        const signedUrl = await fileUploadAdapter.createDownloadURL(file);
+        const url = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
         const text = await modules.products.texts.findLocalizedText({
           productId: product._id,
           locale: locale?.baseName || systemLocale.baseName,

package/src/warehousing/store.ts

@@ -1,9 +1,5 @@
-import {
-  WarehousingDirector,
-  WarehousingAdapter,
-  WarehousingProviderType,
-} from '@unchainedshop/core-warehousing';
-import { IWarehousingAdapter } from '@unchainedshop/core-warehousing';
+import { WarehousingDirector, WarehousingAdapter, IWarehousingAdapter } from '@unchainedshop/core';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 
 const Store: IWarehousingAdapter = {
   ...WarehousingAdapter,

package/src/worker/BaseWorker.ts

@@ -0,0 +1,119 @@
+import later from '@breejs/later';
+import { log } from '@unchainedshop/logger';
+import { Work, WorkData } from '@unchainedshop/core-worker';
+import { WorkerDirector } from '@unchainedshop/core';
+
+export type IWorker<P extends { workerId?: string }> = {
+  key: string;
+  label: string;
+  version: string;
+  type: string;
+  external: boolean;
+
+  getFloorDate: (date?: Date) => Date;
+
+  actions: (
+    params: P,
+    unchainedAPI,
+  ) => {
+    autorescheduleTypes: (options: { referenceDate: Date }) => Promise<Array<Work | null>>;
+    process: (options: { maxWorkItemCount?: number; referenceDate?: Date }) => Promise<void>;
+    reset: () => Promise<void>;
+    start: () => void;
+    stop: () => void;
+  };
+};
+
+interface WorkerParams {
+  workerId?: string;
+  worker: IWorker<any>;
+}
+
+export const BaseWorker: IWorker<WorkerParams> = {
+  key: 'shop.unchained.worker.base',
+  label: 'Base worker. Do not use this directly.',
+  version: '1.0.0',
+  type: 'BASE',
+  external: false,
+
+  getFloorDate: (date = new Date()) => {
+    const floored = new Date(Math.floor(date.getTime() / 1000) * 1000);
+    return floored;
+  },
+
+  actions: ({ workerId, worker }: WorkerParams, unchainedAPI) => {
+    log(`${worker.key} -> Initialized ${worker.type}`);
+
+    const workerActions = {
+      start() {
+        throw new Error(`Not implemented on ${this.constructor.key}`);
+      },
+
+      stop() {
+        throw new Error(`Not implemented on ${this.constructor.key}`);
+      },
+
+      reset: async (referenceDate = new Date()) => {
+        await unchainedAPI.modules.worker.markOldWorkAsFailed({
+          types: WorkerDirector.getActivePluginTypes({ external: false }),
+          worker: workerId,
+          referenceDate,
+        });
+      },
+
+      autorescheduleTypes: async ({ referenceDate }) => {
+        return Promise.all(
+          WorkerDirector.getAutoSchedules().map(async ([scheduleId, workConfig]) => {
+            if (!workConfig.schedule) {
+              await unchainedAPI.modules.worker.ensureNoWork({
+                type: workConfig.type,
+                priority: workConfig.priority || 0,
+                scheduleId,
+              });
+              return null;
+            }
+
+            const fixedSchedule = { ...workConfig.schedule };
+            fixedSchedule.schedules[0].s = [0]; // ignore seconds, always run on second 0
+            const nextDate = later.schedule(fixedSchedule).next(1, referenceDate) as Date;
+            nextDate.setMilliseconds(0);
+            const workData: WorkData = {
+              type: workConfig.type,
+              scheduleId,
+              scheduled: nextDate,
+              timeout: workConfig.timeout,
+              priority: workConfig.priority || 0,
+              retries: workConfig.retries || 0,
+            };
+            if (workConfig.input) {
+              workData.input = await workConfig.input(workData);
+              // A work input fn can skip auto scheduling a new record
+              // when it explicitly returns a falsish input instead of a dictionary
+              if (!workData.input) return null;
+            }
+            return unchainedAPI.modules.worker.ensureOneWork(workData);
+          }),
+        );
+      },
+
+      process: async ({ maxWorkItemCount, referenceDate }) => {
+        await workerActions.autorescheduleTypes({
+          referenceDate,
+        });
+
+        const processRecursively = async (recursionCounter = 0) => {
+          if (maxWorkItemCount && maxWorkItemCount < recursionCounter) return null;
+          const doneWork = await WorkerDirector.processNextWork(unchainedAPI, workerId);
+          if (doneWork) return processRecursively(recursionCounter + 1);
+          return null;
+        };
+
+        await processRecursively();
+      },
+    };
+
+    workerActions.reset();
+
+    return workerActions;
+  },
+};

package/src/worker/EventListenerWorker.ts

@@ -0,0 +1,61 @@
+import { subscribe } from '@unchainedshop/events';
+import { BaseWorker, IWorker } from './BaseWorker.js';
+import { WorkerEventTypes } from '@unchainedshop/core-worker';
+
+function debounce<T extends (...args: any) => any>(func: T, wait) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = null;
+      func(...args);
+    }, wait);
+  };
+}
+
+export interface EventListenerWorkerParams {
+  workerId?: string;
+}
+
+export const EventListenerWorker: IWorker<EventListenerWorkerParams> = {
+  ...BaseWorker,
+
+  key: 'shop.unchained.worker.event-listener',
+  label: 'Allocates work on events. This worker does not make sense on multiple containers.',
+  version: '1.0.0',
+  type: 'EVENT_LISTENER',
+
+  actions: ({ workerId }, unchainedAPI) => {
+    const baseWorkerActions = BaseWorker.actions(
+      { workerId, worker: EventListenerWorker },
+      unchainedAPI,
+    );
+
+    // Debounce in the event of many work queue events conflicting with each other
+    const processWorkQueue = debounce<() => Promise<void>>(async () => {
+      await baseWorkerActions.process({
+        maxWorkItemCount: 1, // only one work item at a time, else we could end up in a loop
+        referenceDate: EventListenerWorker.getFloorDate(),
+      });
+    }, 300);
+
+    return {
+      ...baseWorkerActions,
+
+      start() {
+        subscribe(WorkerEventTypes.ADDED, processWorkQueue);
+        subscribe(WorkerEventTypes.FINISHED, processWorkQueue);
+
+        setTimeout(async () => {
+          await baseWorkerActions.autorescheduleTypes({
+            referenceDate: EventListenerWorker.getFloorDate(),
+          });
+        }, 300);
+      },
+
+      stop() {
+        /* */
+      },
+    };
+  },
+};

package/src/worker/FailedRescheduler.ts

@@ -0,0 +1,80 @@
+import { log } from '@unchainedshop/logger';
+import { subscribe } from '@unchainedshop/events';
+import { Work, WorkData, WorkerEventTypes } from '@unchainedshop/core-worker';
+
+export interface FailedReschedulerParams {
+  retryInput?: (
+    workData: WorkData,
+    priorInput: Record<string, any>,
+  ) => Promise<Record<string, any> | null>;
+}
+
+export type IScheduler<P> = {
+  key: string;
+  label: string;
+  version: string;
+
+  actions: (
+    params: P,
+    unchainedAPI,
+  ) => {
+    start: () => void;
+    stop: () => void;
+  };
+};
+
+export const FailedRescheduler: IScheduler<FailedReschedulerParams> = {
+  key: 'shop.unchained.scheduler.failed',
+  label: 'Reschedule failed works',
+  version: '1.0.0',
+
+  actions: ({ retryInput }, unchainedAPI) => {
+    const handleFinishedWork = async ({ payload: work }: { payload: Work }) => {
+      if (!work.success && work.retries > 0) {
+        const now = new Date();
+        const workDelayMs = work.scheduled.getTime() - work.created.getTime();
+
+        // In short: Double the delay of the old work or delay for 5 seconds
+        const scheduled =
+          workDelayMs > 1000
+            ? new Date(now.getTime() + workDelayMs * 2)
+            : new Date(now.setSeconds(now.getSeconds() + 5));
+
+        log(
+          `${FailedRescheduler.key} -> Reschedule failed work ${work._id} ${
+            work.type
+          } for ${scheduled.toISOString()} (in ${Math.round(workDelayMs / 1000)}). Remaining retries: ${
+            work.retries
+          }`,
+        );
+
+        const workData: WorkData = {
+          type: work.type,
+          priority: work.priority,
+          originalWorkId: work.originalWorkId || work._id,
+          retries: work.retries - 1,
+          timeout: work.timeout,
+          scheduled,
+        };
+
+        if (retryInput) {
+          workData.input = await retryInput(workData, work.input);
+        } else {
+          workData.input = work.input;
+        }
+
+        unchainedAPI.modules.worker.addWork(workData);
+      }
+    };
+
+    return {
+      start() {
+        subscribe<Work>(WorkerEventTypes.FINISHED, handleFinishedWork);
+      },
+
+      stop() {
+        /* */
+      },
+    };
+  },
+};

package/src/worker/IntervalWorker.ts

@@ -0,0 +1,54 @@
+import later, { ScheduleData } from '@breejs/later';
+import { BaseWorker, IWorker } from './BaseWorker.js';
+
+const { NODE_ENV } = process.env;
+
+export interface IntervalWorkerParams {
+  workerId?: string;
+  batchCount?: number;
+  schedule?: ScheduleData;
+}
+
+const defaultSchedule = later.parse.text(
+  NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds',
+);
+
+export const scheduleToInterval = (schedule: ScheduleData) => {
+  const referenceDate = new Date(1000);
+  const [one, two] = later.schedule(schedule).next(2, referenceDate) as Date[];
+  const diff = new Date(two).getTime() - new Date(one).getTime();
+  return Math.min(1000 * 60 * 60, diff); // at least once every hour!
+};
+
+export const IntervalWorker: IWorker<IntervalWorkerParams> = {
+  ...BaseWorker,
+
+  key: 'shop.unchained.worker.cron',
+  label: 'Allocates work on fixed intervals with native node setInterval',
+  version: '1.0.0',
+  type: 'CRON',
+
+  actions: ({ workerId, batchCount = 0, schedule = defaultSchedule }, unchainedAPI) => {
+    const baseWorkerActions = BaseWorker.actions({ workerId, worker: IntervalWorker }, unchainedAPI);
+
+    const intervalDelay = scheduleToInterval(schedule);
+    let intervalHandle: NodeJS.Timeout;
+
+    return {
+      ...baseWorkerActions,
+
+      start() {
+        intervalHandle = setInterval(() => {
+          baseWorkerActions.process({
+            maxWorkItemCount: batchCount,
+            referenceDate: IntervalWorker.getFloorDate(),
+          });
+        }, intervalDelay);
+      },
+
+      stop() {
+        clearInterval(intervalHandle);
+      },
+    };
+  },
+};