@pisell/pisellos 2.2.147 → 2.2.149

package/lib/model/strategy/adapter/promotion/index.js

@@ -0,0 +1,49 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/model/strategy/adapter/promotion/index.ts
+var promotion_exports = {};
+__export(promotion_exports, {
+  BUY_X_GET_Y_FREE_STRATEGY: () => import_examples.BUY_X_GET_Y_FREE_STRATEGY,
+  PromotionAdapter: () => import_adapter.PromotionAdapter,
+  PromotionEvaluator: () => import_evaluator.PromotionEvaluator,
+  X_ITEMS_FOR_Y_PRICE_STRATEGY: () => import_examples.X_ITEMS_FOR_Y_PRICE_STRATEGY,
+  default: () => import_adapter2.default
+});
+module.exports = __toCommonJS(promotion_exports);
+var import_evaluator = require("./evaluator");
+var import_adapter = require("./adapter");
+var import_adapter2 = __toESM(require("./adapter"));
+var import_examples = require("./examples");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUY_X_GET_Y_FREE_STRATEGY,
+  PromotionAdapter,
+  PromotionEvaluator,
+  X_ITEMS_FOR_Y_PRICE_STRATEGY
+});

package/lib/modules/Cart/types.d.ts

@@ -148,6 +148,8 @@ export interface CartItem {
     _optionsOrigin?: any[];
     /** 操作系统提示 */
     osWarnTips?: string[];
+    /** 金额差值 */
+    totalDifference?: number;
 }
 /**
  * 购物车状态接口

package/lib/modules/Cart/utils/cartProduct.js

@@ -45,6 +45,7 @@ module.exports = __toCommonJS(cartProduct_exports);
 var import_decimal = __toESM(require("decimal.js"));
 var import_utils = require("../../Product/utils");
 var import_utils2 = require("../../../solution/ShopDiscount/utils");
+var import_utils3 = require("../../Summary/utils");
 var toDiscountPayload = (discountItem) => {
   var _a, _b;
   return {
@@ -92,6 +93,7 @@ var formatProductToCartItem = (params) => {
     cartItem.price = product == null ? void 0 : product.price;
     cartItem.num = num;
     cartItem.total = getProductTotalPrice({ product, bundle, options, num, discounts });
+    cartItem.totalDifference = getTotalDifference({ product, bundle, discounts });
     cartItem.summaryTotal = cartItem.total * (num || 1);
     cartItem.origin_total = getProductOriginTotalPrice({
       product,
@@ -235,6 +237,18 @@ var getProductTotalPrice = (params) => {
   }
   return Math.max(0, price);
 };
+var getTotalDifference = (params) => {
+  const { bundle, discounts } = params;
+  const bundleDiscountList = [];
+  if (bundle == null ? void 0 : bundle.length) {
+    bundle.forEach((currentValue) => {
+      bundleDiscountList.push(...(currentValue == null ? void 0 : currentValue.discount_list) || []);
+    });
+  }
+  const allDiscounts = [...discounts || [], ...bundleDiscountList];
+  const productDiscountProductDiscountDifference = (0, import_utils3.calcDiscountListDifference)(allDiscounts);
+  return productDiscountProductDiscountDifference || 0;
+};
 var getProductOriginTotalPrice = (params) => {
   const { product, bundle, options, discounts } = params;
   const num = (params == null ? void 0 : params.num) || 1;
@@ -299,7 +313,8 @@ var formatBundle = (bundle) => {
       options: formatOptions(item == null ? void 0 : item.option),
       _bundle_product_id: item._bundle_product_id,
       discount_list: item.discount_list,
-      originBundleItem: item.originBundleItem || item
+      originBundleItem: item.originBundleItem || item,
+      is_charge_tax: item == null ? void 0 : item.is_charge_tax
     };
   });
 };
@@ -326,6 +341,7 @@ var formatBundleToOrigin = (bundle) => {
       option: formatOptionsToOrigin(getBundleValueByKey("option")),
       discount_list: d.discount_list,
       "bundle_selling_price": d == null ? void 0 : d.price,
+      "custom_price": d == null ? void 0 : d.price,
       metadata: {
         custom_product_bundle_map_id: d._id,
         product_discount_difference

package/lib/modules/Cart/utils/changePrice.js

@@ -60,6 +60,11 @@ async function updateAllCartItemPrice(cartItems, priceData, getProduct, updateCa
         if (targetBundleItem.price_type === "markdown") {
           targetBundleItem.price = new import_decimal.default(targetBundleItem.price || 0).mul(-1).toNumber();
         }
+        if (n.option) {
+          targetBundleItem.price = new import_decimal.default(targetBundleItem.price || 0).add(n.option.reduce((pre, cur) => {
+            return pre + new import_decimal.default(cur.price || 0).mul(cur.num || 1).toNumber();
+          }, 0)).toNumber();
+        }
         if (targetBundleItem) {
           return {
             ...n,

package/lib/modules/Date/index.d.ts

@@ -37,5 +37,5 @@ export declare class DateModule extends BaseModule implements Module, DateModule
     getResourceAvailableTimeList(params: IGetAvailableTimeListParams): Promise<ITime[]>;
     clearDateRange(): void;
     storeChange(): void;
-    getResourcesListByDate(date: string): any[] | undefined;
+    getResourcesListByDate(date: string): any[];
 }

package/lib/modules/Date/index.js

@@ -64,6 +64,12 @@ var DateModule = class extends import_BaseModule.BaseModule {
     }
   }
   setDateRange(dateRange) {
+    dateRange.forEach((item) => {
+      var _a;
+      if (!((_a = item.resource) == null ? void 0 : _a.length)) {
+        item.resource = this.getResourcesListByDate(item.date);
+      }
+    });
     this.store.dateRange = dateRange;
   }
   getDateRange() {
@@ -252,7 +258,7 @@ var DateModule = class extends import_BaseModule.BaseModule {
   getResourcesListByDate(date) {
     var _a;
     const dateList = this.store.dateList;
-    const resourcesList = (_a = dateList.find((item) => item.date === date)) == null ? void 0 : _a.resource;
+    const resourcesList = ((_a = dateList == null ? void 0 : dateList.find((item) => item.date === date)) == null ? void 0 : _a.resource) || [];
     return resourcesList;
   }
 };

package/lib/modules/Date/types.d.ts

@@ -20,7 +20,9 @@ export interface ITime {
     date: string;
     week: string;
     weekNum: number;
-    status: 'unavailable' | 'available';
+    status: 'unavailable' | 'available' | 'lots_of_space' | 'filling_up_fast' | 'sold_out';
+    summaryCount?: number;
+    availableCount?: number;
     resource?: any[];
     color?: string[];
 }

package/lib/modules/OpenData/index.d.ts

@@ -0,0 +1,24 @@
+import { Module, PisellCore, ModuleOptions } from '../../types';
+import { BaseModule } from '../BaseModule';
+import type { ScheduleModule } from '../Schedule';
+import type { OpenDataConfig, OpenDataFetchParams, OpenDataAvailabilityResult } from './types';
+export * from './types';
+export { computeAvailability } from './utils';
+export declare class OpenDataModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private request;
+    private window;
+    private store;
+    private cacheId;
+    private openCache;
+    private fatherModule;
+    private otherParams;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    fetchOpenData(params: OpenDataFetchParams): Promise<OpenDataConfig>;
+    getOpenData(): OpenDataConfig | null;
+    getLastFetchedAt(): number | null;
+    checkAvailability(scheduleModule?: ScheduleModule): OpenDataAvailabilityResult;
+    storeChange(): void;
+}

package/lib/modules/OpenData/index.js

@@ -0,0 +1,119 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/OpenData/index.ts
+var OpenData_exports = {};
+__export(OpenData_exports, {
+  OpenDataModule: () => OpenDataModule,
+  computeAvailability: () => import_utils2.computeAvailability
+});
+module.exports = __toCommonJS(OpenData_exports);
+var import_BaseModule = require("../BaseModule");
+var import_utils = require("./utils");
+__reExport(OpenData_exports, require("./types"), module.exports);
+var import_utils2 = require("./utils");
+var OpenDataModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "openData";
+    this.defaultVersion = "1.0.0";
+    this.openCache = false;
+    this.otherParams = {};
+  }
+  async initialize(core, options) {
+    var _a, _b;
+    this.core = core;
+    this.store = options.store;
+    this.store.data = ((_a = options.initialState) == null ? void 0 : _a.data) ?? null;
+    this.store.lastFetchedAt = ((_b = options.initialState) == null ? void 0 : _b.lastFetchedAt) ?? null;
+    this.otherParams = options.otherParams || {};
+    if (this.otherParams.cacheId) {
+      this.openCache = this.otherParams.openCache ?? false;
+      this.cacheId = this.otherParams.cacheId;
+    }
+    if (this.otherParams.fatherModule) {
+      this.fatherModule = this.otherParams.fatherModule;
+    }
+    this.request = core.getPlugin("request");
+    this.window = core.getPlugin("window");
+    if (!this.request)
+      throw new Error("OpenDataModule 需要 request 插件支持");
+    if (!this.window)
+      throw new Error("OpenDataModule 需要 window 插件支持");
+    console.log("[OpenDataModule] 初始化完成");
+  }
+  async fetchOpenData(params) {
+    var _a, _b, _c, _d;
+    const shopId = (_b = (_a = this.otherParams) == null ? void 0 : _a.getStateData) == null ? void 0 : _b.call(_a, "shop_id");
+    if (!shopId)
+      throw new Error("[OpenDataModule] 无法获取 shop_id");
+    const tenantId = (_d = (_c = this.otherParams) == null ? void 0 : _c.getStateData) == null ? void 0 : _d.call(_c, "tenant_id");
+    const headers = {};
+    if (tenantId)
+      headers["Tenant-Id"] = String(tenantId);
+    const response = await this.request.post(
+      `/open/my-pisell/${shopId}/setting`,
+      {
+        scope: params.scope,
+        target: params.target,
+        section_code: params.section_code
+      },
+      { pisell2: true, headers }
+    );
+    if ((response == null ? void 0 : response.status) === false) {
+      throw new Error((response == null ? void 0 : response.message) || "获取 OpenData 配置失败");
+    }
+    const data = (response == null ? void 0 : response.data) || {};
+    this.store.data = data;
+    this.store.lastFetchedAt = Date.now();
+    return data;
+  }
+  getOpenData() {
+    return this.store.data;
+  }
+  getLastFetchedAt() {
+    return this.store.lastFetchedAt ?? null;
+  }
+  checkAvailability(scheduleModule) {
+    var _a;
+    const scheduleList = scheduleModule ? scheduleModule.getScheduleListByIds(
+      ((_a = this.store.data) == null ? void 0 : _a["availability.operating_hours"]) || []
+    ) : void 0;
+    return (0, import_utils.computeAvailability)({
+      config: this.store.data,
+      scheduleList
+    });
+  }
+  storeChange() {
+    if (this.openCache) {
+      this.checkSaveCache({
+        cacheId: this.cacheId,
+        fatherModule: this.fatherModule,
+        store: this.store,
+        cacheKey: ["data", "lastFetchedAt"]
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenDataModule,
+  computeAvailability,
+  ...require("./types")
+});

package/lib/modules/OpenData/types.d.ts

@@ -0,0 +1,73 @@
+import type { ScheduleItem } from '../Schedule/types';
+export interface MultiLangObject {
+    en?: string;
+    ja?: string;
+    pt?: string;
+    'zh-CN'?: string;
+    'zh-HK'?: string;
+    original?: string;
+    [key: string]: string | undefined;
+}
+export interface OpenDataConfig {
+    'basic.enable'?: boolean;
+    'basic.code'?: string | null;
+    'basic.name'?: string | MultiLangObject;
+    'basic.unavailable_message'?: string | MultiLangObject;
+    'availability.paused'?: boolean;
+    'availability.pause_message'?: string | MultiLangObject;
+    'availability.pause_behavior'?: string;
+    'availability.closed_behavior'?: string;
+    'availability.closed_message'?: string | MultiLangObject;
+    'availability.operating_hours'?: number[];
+    'reservation.enable'?: boolean;
+    'reservation.auto_confirm'?: boolean;
+    'reservation.auto_confirm_mode'?: string;
+    'reservation.auto_confirm_delay_seconds'?: number;
+    'sale.allow_item_notes'?: boolean;
+    'sale.allow_order_notes'?: boolean;
+    'sale.enable_item_rules'?: boolean;
+    'sale.enable_short_number'?: boolean;
+    'sale.short_number_daily_reset'?: boolean;
+    'sale.short_number_start_number'?: number;
+    'sale.short_number_prefix'?: string | null;
+    'sale.sale_number_prefix'?: string | null;
+    'sale.enabled_item_rules'?: number[];
+    'fulfillment.enable_pickup'?: boolean;
+    'fulfillment.overdue_reminder'?: boolean;
+    'fulfillment.manual_input_type'?: string;
+    'fulfillment.enable_auto_complete'?: boolean;
+    'fulfillment.enable_table_service'?: boolean;
+    'fulfillment.fulfillment_ref_mode'?: string;
+    'fulfillment.advance_warning_minutes'?: number;
+    'fulfillment.update_end_time_on_auto_complete'?: string;
+    'menu.associated_menus'?: Array<{
+        label: string;
+        value: number;
+    }>;
+    [key: string]: any;
+}
+export interface OpenDataState {
+    data: OpenDataConfig | null;
+    lastFetchedAt: number | null;
+}
+export interface OpenDataFetchParams {
+    scope: string;
+    target: string;
+    section_code: string[];
+}
+export interface OpenDataApiResponse {
+    status: boolean;
+    code: number;
+    message: string;
+    data: OpenDataConfig;
+}
+export type OpenDataUnavailableReason = 'shop_disabled' | 'paused' | 'closed' | 'reservation_disabled';
+export interface OpenDataAvailabilityResult {
+    available: boolean;
+    reason: OpenDataUnavailableReason | null;
+    message: string | MultiLangObject | null;
+}
+export interface ComputeAvailabilityParams {
+    config: OpenDataConfig | null;
+    scheduleList?: ScheduleItem[];
+}

package/lib/modules/OpenData/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/OpenData/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/modules/OpenData/utils.d.ts

@@ -0,0 +1,2 @@
+import type { OpenDataAvailabilityResult, ComputeAvailabilityParams } from './types';
+export declare function computeAvailability(params: ComputeAvailabilityParams): OpenDataAvailabilityResult;

package/lib/modules/OpenData/utils.js

@@ -0,0 +1,111 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/OpenData/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  computeAvailability: () => computeAvailability
+});
+module.exports = __toCommonJS(utils_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_getDateIsInSchedule = require("../Schedule/getDateIsInSchedule");
+function toBoolean(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string")
+    return value === "true" || value === "1";
+  if (typeof value === "number")
+    return value !== 0;
+  return false;
+}
+function resolveMessage(...candidates) {
+  for (const val of candidates) {
+    if (!val)
+      continue;
+    if (typeof val === "string" && val.length > 0)
+      return val;
+    if (typeof val === "object" && val !== null && !Array.isArray(val))
+      return val;
+  }
+  return null;
+}
+function computeAvailability(params) {
+  const { config, scheduleList } = params;
+  if (!config) {
+    return { available: true, reason: null, message: null };
+  }
+  if (config["basic.enable"] === false) {
+    return {
+      available: false,
+      reason: "shop_disabled",
+      message: resolveMessage(
+        config["basic.unavailable_message"],
+        config["availability.closed_message"]
+      )
+    };
+  }
+  if (toBoolean(config["availability.paused"])) {
+    return {
+      available: false,
+      reason: "paused",
+      message: resolveMessage(
+        config["availability.pause_message"],
+        config["availability.closed_message"]
+      )
+    };
+  }
+  const operatingHourIds = config["availability.operating_hours"];
+  if (Array.isArray(operatingHourIds) && operatingHourIds.length > 0 && (scheduleList == null ? void 0 : scheduleList.length)) {
+    const relevantSchedules = scheduleList.filter(
+      (s) => operatingHourIds.includes(s.id)
+    );
+    if (relevantSchedules.length > 0) {
+      const now = (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss");
+      const isOpen = (0, import_getDateIsInSchedule.getDateIsInSchedule)(now, relevantSchedules);
+      if (!isOpen) {
+        return {
+          available: false,
+          reason: "closed",
+          message: resolveMessage(config["availability.closed_message"])
+        };
+      }
+    }
+  }
+  if (config["reservation.enable"] === false) {
+    return {
+      available: false,
+      reason: "reservation_disabled",
+      message: resolveMessage(config["availability.closed_message"])
+    };
+  }
+  return { available: true, reason: null, message: null };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeAvailability
+});