@pisell/pisellos 2.1.174 → 2.1.176

package/dist/solution/ScanOrder/resourceSchedule.js

@@ -0,0 +1,300 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import dayjs from 'dayjs';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import { getScheduleStartEndTimePoints } from "../../modules/Schedule/getDateIsInSchedule";
+// Schedule's date expander uses these methods but does not initialize them itself.
+dayjs.extend(isSameOrAfter);
+dayjs.extend(isSameOrBefore);
+var DAY = 24 * 60 * 60 * 1000;
+function dateScalar(value) {
+  if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    throw new Error('Invalid schedule date');
+  }
+  var _value$split$map = value.split('-').map(Number),
+    _value$split$map2 = _slicedToArray(_value$split$map, 3),
+    year = _value$split$map2[0],
+    month = _value$split$map2[1],
+    day = _value$split$map2[2];
+  var result = new Date(0);
+  result.setUTCFullYear(year, month - 1, day);
+  result.setUTCHours(0, 0, 0, 0);
+  if (year < 1 || result.getUTCFullYear() !== year || result.getUTCMonth() !== month - 1 || result.getUTCDate() !== day) {
+    throw new Error('Invalid schedule date');
+  }
+  return result.getTime();
+}
+function timeScalar(value) {
+  if (typeof value !== 'string') throw new Error('Invalid schedule time');
+  var match = /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(value);
+  if (!match) throw new Error('Invalid schedule time');
+  var _match = _slicedToArray(match, 4),
+    hours = _match[1],
+    minutes = _match[2],
+    _match$ = _match[3],
+    seconds = _match$ === void 0 ? '0' : _match$;
+  if (Number(hours) > 23 || Number(minutes) > 59 || Number(seconds) > 59) {
+    throw new Error('Invalid schedule time');
+  }
+  return ((Number(hours) * 60 + Number(minutes)) * 60 + Number(seconds)) * 1000;
+}
+function datetimeScalar(value) {
+  var allowDateOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (typeof value !== 'string') throw new Error('Invalid schedule datetime');
+  var parts = value.split(/[ T]/);
+  if (parts.length === 1 && allowDateOnly) return dateScalar(parts[0]);
+  if (parts.length !== 2) throw new Error('Invalid schedule datetime');
+  return dateScalar(parts[0]) + timeScalar(parts[1]);
+}
+function dayStart(value) {
+  return Math.floor(value / DAY) * DAY;
+}
+function dateLabel(value) {
+  return new Date(value).toISOString().slice(0, 10);
+}
+function absoluteRange(start, end, allDay) {
+  if (allDay) {
+    if (dayStart(end) < dayStart(start)) throw new Error('Reversed schedule');
+    start = dayStart(start);
+    // An explicit following-day midnight is already an exclusive day boundary.
+    end = end > start && end === dayStart(end) ? end : dayStart(end) + DAY;
+  }
+  if (end <= start) throw new Error('Empty or reversed schedule');
+  return {
+    start: start,
+    end: end
+  };
+}
+function contains(range, now) {
+  return range.start <= now && now < range.end;
+}
+function normalizeDateRanges(value) {
+  if (value === undefined || value === null) return [];
+  if (!Array.isArray(value)) throw new Error('Invalid schedule date ranges');
+  return value.map(function (range) {
+    if (!range || dateScalar(range.end) < dateScalar(range.start)) {
+      throw new Error('Invalid schedule date range');
+    }
+    return {
+      start: range.start,
+      end: range.end
+    };
+  });
+}
+
+/** Reuse Schedule's date/include/exclude rules without its truncated clock ranges. */
+function dateProbe(schedule, initialDate) {
+  var _rule$end, _rule$end2;
+  var probe = _objectSpread(_objectSpread({}, schedule), {}, {
+    type: 'time-slots',
+    start_time: "".concat(dateLabel(initialDate), " 00:00:00"),
+    time_slot: [{
+      id: 0,
+      start_time: '00:00',
+      end_time: '23:59'
+    }]
+  });
+  if (schedule.repeat_type === 'none') return probe;
+  if (schedule.repeat_type !== 'daily' && schedule.repeat_type !== 'weekly') {
+    throw new Error('Invalid schedule repeat type');
+  }
+  var rule = schedule.repeat_rule;
+  if (!rule || !Number.isInteger(rule.frequency) || rule.frequency < 1) {
+    throw new Error('Invalid schedule repeat frequency');
+  }
+  if (((_rule$end = rule.end) === null || _rule$end === void 0 ? void 0 : _rule$end.type) !== 'never' && ((_rule$end2 = rule.end) === null || _rule$end2 === void 0 ? void 0 : _rule$end2.type) !== 'date') {
+    throw new Error('Invalid schedule repeat end');
+  }
+  if (rule.end.type === 'date') dateScalar(rule.end.end_date);
+  var included = normalizeDateRanges(rule.included_date);
+  var excluded = normalizeDateRanges(rule.excluded_date);
+  if (schedule.repeat_type === 'weekly') {
+    if (!Array.isArray(rule.frequency_date) || !rule.frequency_date.length || rule.frequency_date.some(function (weekday) {
+      return !Number.isInteger(weekday) || weekday < 0 || weekday > 6;
+    })) {
+      throw new Error('Invalid schedule weekdays');
+    }
+    // Weekly frequency counts calendar weeks, not elapsed seven-day periods.
+    // Keep the real first date as an exclusion; included dates retain priority.
+    var weekStart = initialDate - new Date(initialDate).getUTCDay() * DAY;
+    probe.start_time = "".concat(dateLabel(weekStart), " 00:00:00");
+    if (weekStart < initialDate) {
+      excluded.push({
+        start: dateLabel(weekStart),
+        end: dateLabel(initialDate - DAY)
+      });
+    }
+  }
+  probe.repeat_rule = _objectSpread(_objectSpread({}, rule), {}, {
+    included_date: included,
+    excluded_date: excluded
+  });
+  return probe;
+}
+function recurringRangeAvailable(schedule, initialDate, offsets, now) {
+  var probe = dateProbe(schedule, initialDate);
+  var maxDaysBack = Math.ceil(Math.max.apply(Math, _toConsumableArray(offsets.map(function (range) {
+    return range.end;
+  }))) / DAY);
+  var today = dayStart(now);
+  var _loop = function _loop() {
+      var anchor = today - daysBack * DAY;
+      // Do not expand an entire year: only dates whose windows can contain now.
+      if (!offsets.some(function (range) {
+        return contains({
+          start: anchor + range.start,
+          end: anchor + range.end
+        }, now);
+      })) {
+        return 0; // continue
+      }
+      if (getScheduleStartEndTimePoints(dateLabel(anchor), [probe]).length > 0) return {
+        v: true
+      };
+    },
+    _ret;
+  for (var daysBack = 0; daysBack <= maxDaysBack; daysBack += 1) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+    if (_ret) return _ret.v;
+  }
+  return false;
+}
+function scheduleAvailable(schedule, now) {
+  if (!schedule || _typeof(schedule) !== 'object') throw new Error('Invalid schedule');
+  var allDay = schedule.is_all === 1;
+  if (schedule.type === 'designation') {
+    var entries = Array.isArray(schedule.designation) ? schedule.designation : [schedule.designation];
+    if (!entries.length) throw new Error('Missing designated schedule');
+    // Designation stores explicit absolute intervals, including multi-day spans.
+    var ranges = entries.map(function (entry) {
+      if (!entry) throw new Error('Invalid designated schedule');
+      return absoluteRange(dateScalar(entry.start_date) + (allDay ? 0 : timeScalar(entry.start_time)), dateScalar(entry.end_date) + (allDay ? timeScalar(entry.end_time || '00:00') : timeScalar(entry.end_time)), allDay);
+    });
+    return ranges.some(function (range) {
+      return contains(range, now);
+    });
+  }
+  if (schedule.type === 'standard') {
+    var range = absoluteRange(datetimeScalar(schedule.start_time, allDay), datetimeScalar(schedule.end_time, allDay), allDay);
+    if (schedule.repeat_type === 'none') return contains(range, now);
+    var initialDate = dayStart(range.start);
+    return recurringRangeAvailable(schedule, initialDate, [{
+      start: range.start - initialDate,
+      end: range.end - initialDate
+    }], now);
+  }
+  if (schedule.type === 'time-slots') {
+    var _initialDate = dayStart(datetimeScalar(schedule.start_time, true));
+    var offsets;
+    if (allDay) {
+      offsets = [{
+        start: 0,
+        end: DAY
+      }];
+    } else {
+      if (!Array.isArray(schedule.time_slot) || !schedule.time_slot.length) {
+        throw new Error('Missing schedule time slots');
+      }
+      offsets = schedule.time_slot.map(function (slot) {
+        var start = timeScalar(slot === null || slot === void 0 ? void 0 : slot.start_time);
+        var end = timeScalar(slot === null || slot === void 0 ? void 0 : slot.end_time);
+        if (start === end) throw new Error('Empty schedule time slot');
+        if (end < start) end += DAY;
+        return {
+          start: start,
+          end: end
+        };
+      });
+    }
+    return recurringRangeAvailable(schedule, _initialDate, offsets, now);
+  }
+  throw new Error('Unsupported schedule type');
+}
+
+/** Current time is projected into the shop's calendar; host timezone is not used. */
+export function evaluateResourceSchedules(_ref) {
+  var schedules = _ref.schedules,
+    timeZone = _ref.timeZone,
+    now = _ref.now;
+  var formatter;
+  try {
+    if (typeof timeZone !== 'string' || !timeZone.trim()) throw new Error('Missing timezone');
+    var options = {
+      timeZone: timeZone,
+      calendar: 'gregory',
+      numberingSystem: 'latn',
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hourCycle: 'h23'
+    };
+    formatter = new Intl.DateTimeFormat('en-GB', options);
+  } catch (_unused) {
+    return {
+      available: false,
+      reason: 'invalid_timezone'
+    };
+  }
+  if (!(now instanceof Date) || !Number.isFinite(now.getTime()) || !Array.isArray(schedules) || !schedules.length) {
+    return {
+      available: false,
+      reason: 'invalid_schedule'
+    };
+  }
+  var parts = {};
+  formatter.formatToParts(now).forEach(function (part) {
+    parts[part.type] = part.value;
+  });
+  var localNow;
+  try {
+    localNow = datetimeScalar("".concat(parts.year, "-").concat(parts.month, "-").concat(parts.day, " ").concat(parts.hour, ":").concat(parts.minute, ":").concat(parts.second)) + now.getUTCMilliseconds();
+  } catch (_unused2) {
+    return {
+      available: false,
+      reason: 'invalid_schedule'
+    };
+  }
+  var invalid = false;
+  var _iterator = _createForOfIteratorHelper(schedules),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var schedule = _step.value;
+      try {
+        if (scheduleAvailable(schedule, localNow)) return {
+          available: true
+        };
+      } catch (_unused3) {
+        invalid = true;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    available: false,
+    reason: invalid ? 'invalid_schedule' : 'outside_schedule'
+  };
+}

package/dist/solution/ScanOrder/types.d.ts

@@ -27,6 +27,12 @@ export interface ScanOrderConfig {
         verifyResource: boolean;
     };
 }
+export interface ScanOrderFulfillmentModes {
+    enablePickup: boolean;
+    enableTableService: boolean;
+    /** Present only when fulfillment.handover_mode is configured, including an empty list. */
+    handoverModes?: string[];
+}
 export interface ScanOrderOrderProductIdentity {
     product_id: number | null;
     product_variant_id: number;
@@ -186,8 +192,10 @@ export interface ScanOrderSubmitPayload extends Omit<ScanOrderTempOrder, 'platfo
     }>;
     products: ScanOrderSubmitProduct[];
 }
-export type ScanOrderAvailabilityMode = 'idle' | 'shop_closed' | 'submit_disabled' | 'resource_busy' | 'multiple_orders' | 'additional_order_with_code' | 'additional_order';
+export type ScanOrderAvailabilityMode = 'idle' | 'shop_closed' | 'submit_disabled' | 'resource_busy' | 'resource_block' | 'multiple_orders' | 'additional_order_with_code' | 'additional_order';
 export interface ScanOrderTableFormRecord {
+    /** 桌台可用日程；未配置时不限制可用时段。 */
+    schedule?: Array<number | string> | null;
     policy?: string | null;
     partyroom_booking?: string | null;
     capacity?: number | string | null;

package/dist/solution/ShopDiscount/index.d.ts

@@ -12,8 +12,6 @@ export declare class ShopDiscountImpl extends BaseModule implements Module {
     private store;
     private options;
     private hooks?;
-    private entitlementPassEnabled;
-    setEntitlementPassEnabled(enabled: boolean): void;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: any): Promise<void>;
     destroy(): Promise<void>;
@@ -44,7 +42,6 @@ export declare class ShopDiscountImpl extends BaseModule implements Module {
     batchSearchByProductIds(productIds: number[]): Promise<Discount[]>;
     scanCode(code: string, customerId?: number): Promise<{
         isAvailable: boolean;
-        isAccepted?: boolean;
         productList: Record<string, any>[];
         discountList: Discount[];
         type: "server" | "clientCalc";