@pisell/pisellos 2.2.314 → 2.2.315

package/lib/solution/OrderInvoicePreview/index.js

@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OrderInvoicePreviewImpl = void 0;
+var _BaseModule = require("../../modules/BaseModule");
+var _loadCustomerInvoiceLayout = require("../../shared/receipt/loadCustomerInvoiceLayout");
+var _customerInvoiceLanguages = require("../../shared/receipt/customerInvoiceLanguages");
+var _smallTicket = require("../../shared/receipt/small-ticket");
+var _loadSalesOrderSnapshot = require("../../shared/sales/loadSalesOrderSnapshot");
+var _loadPaymentMethods = require("../../shared/payment/loadPaymentMethods");
+// Page-runtime cache shared by preview instances, scoped to host, shop and identity.
+const contextCaches = new WeakMap();
+/** Read-only, page-owned solution. No Order, Schedule, quotation or payment modules. */
+class OrderInvoicePreviewImpl extends _BaseModule.BaseModule {
+  isSolution = true;
+  request;
+  state = {
+    status: 'idle',
+    result: null,
+    error: null
+  };
+  listeners = new Set();
+  generation = 0;
+  disposed = false;
+  input;
+  activeKey = '';
+  // Hosts retain this readonly instance while the same order modal is closed.
+  languageSelection;
+  pending;
+  snapshotCache = new Map();
+  constructor(name = 'orderInvoicePreview') {
+    super(name);
+  }
+  initialize(core, _options) {
+    this.core = core;
+    const request = core.getPlugin('request');
+    if (!request) throw new Error('OrderInvoicePreview requires request plugin');
+    this.request = request;
+  }
+  getState = () => this.state;
+  subscribe = listener => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  publish(state) {
+    this.state = state;
+    this.listeners.forEach(listener => listener());
+  }
+  getScope(input) {
+    return JSON.stringify([input.tenantId, input.shopId, input.identity, input.businessCode, input.channel]);
+  }
+  loadContext(input) {
+    let cache = contextCaches.get(this.request);
+    if (!cache) {
+      cache = new Map();
+      contextCaches.set(this.request, cache);
+    }
+    const key = JSON.stringify([input.tenantId, input.shopId, input.identity]);
+    const cached = cache.get(key);
+    if (cached) return cached;
+    const task = Promise.all([this.request.get('/shop/show', {}, {
+      manualErrorHandling: true,
+      skipErrorHandler: true
+    }), (0, _loadPaymentMethods.loadPaymentMethods)(this.request, {
+      transport: 'remote',
+      filterPaymentMethods: false
+    })]).then(([response, methods]) => {
+      const shop = response?.data;
+      if (!shop || typeof shop !== 'object' || Array.isArray(shop)) throw new Error('Invoice shop information is unavailable');
+      if (String(shop.id) !== String(input.shopId)) throw new Error('Invoice shop identity mismatch');
+      return {
+        shop,
+        methods
+      };
+    }).catch(error => {
+      if (cache.get(key) === task) cache.delete(key);
+      throw error;
+    });
+    cache.set(key, task);
+    return task;
+  }
+  loadSource(input) {
+    const key = JSON.stringify([this.getScope(input), input.orderId, input.sourceRevision]);
+    const cached = this.snapshotCache.get(key);
+    if (cached) return cached;
+    const task = (0, _loadSalesOrderSnapshot.loadSalesOrderSnapshot)(this.request, {
+      lookup: input.orderId,
+      transport: 'remote'
+    }).then(response => {
+      if (response?.code !== 200 || !response.data || typeof response.data !== 'object' || Array.isArray(response.data)) {
+        throw new Error(response?.message || 'Invoice order is unavailable');
+      }
+      const source = response.data;
+      if (source.order_id != null && String(source.order_id) !== String(input.orderId)) {
+        throw new Error('Invoice order identity mismatch');
+      }
+      return source;
+    }).catch(error => {
+      if (this.snapshotCache.get(key) === task) this.snapshotCache.delete(key);
+      throw error;
+    });
+    this.snapshotCache.set(key, task);
+    return task;
+  }
+  prepare(input) {
+    if (this.disposed) return Promise.reject(new Error('Invoice preview disposed'));
+    const currentShop = this.core.getPlugin('app')?.getData?.()?.('shop_id');
+    if (currentShop != null && String(currentShop) !== String(input.shopId)) {
+      return Promise.reject(new Error('Invoice shop changed'));
+    }
+    const key = JSON.stringify([this.getScope(input), input.orderId, input.sourceRevision, input.locale]);
+    if (key === this.activeKey) {
+      if (this.pending) return this.pending;
+      if (this.state.status === 'ready' && this.state.result) return Promise.resolve(this.state.result);
+    }
+    if (this.input && this.getScope(this.input) !== this.getScope(input)) this.snapshotCache.clear();
+    if (this.languageSelection?.scope !== this.getSelectionScope(input)) this.languageSelection = undefined;
+    this.input = input;
+    this.activeKey = key;
+    const generation = ++this.generation;
+    this.publish({
+      status: 'loading',
+      result: null,
+      error: null
+    });
+    const task = (async () => {
+      const [snapshot, context, template] = await Promise.all([this.loadSource(input), this.loadContext(input), (0, _loadCustomerInvoiceLayout.loadCustomerInvoiceTemplate)(this.request, input)]);
+      const source = (0, _loadPaymentMethods.withPaymentMethodNames)(snapshot, context.methods);
+      const getData = this.core.getPlugin('app')?.getData?.();
+      if (getData?.('shop_id') != null && String(getData('shop_id')) !== String(input.shopId)) throw new Error('Invoice shop changed');
+      const coreData = getData?.('core');
+      const shop = {
+        ...(coreData?.core?.shop || coreData?.shop || {}),
+        ...(getData?.('shop_info') || {}),
+        ...input.shop,
+        ...context.shop,
+        ...(getData?.('tax_country_code') ? {
+          tax_country_code: getData('tax_country_code')
+        } : {})
+      };
+      if (generation !== this.generation || this.disposed) throw new Error('Invoice request superseded');
+      const languageOptions = (0, _customerInvoiceLanguages.resolveCustomerInvoiceLanguages)(template.language, input.locale);
+      const remembered = this.languageSelection?.code;
+      const selected = languageOptions.find(option => option.code === remembered) || languageOptions[0];
+      const locale = selected.locales[0];
+      const result = {
+        identity: this.documentIdentity(key, selected.code),
+        languageOptions,
+        selectedLanguage: selected.code,
+        ...(selected.locales[1] ? {
+          secondaryLocale: selected.locales[1]
+        } : {}),
+        orderId: input.orderId,
+        sourceRevision: input.sourceRevision,
+        generatedAt: new Date().toISOString(),
+        locale,
+        source,
+        shop,
+        layout: template.layout,
+        smallTicketData: (0, _smallTicket.buildSmallTicketData)({
+          order: source,
+          shopInfo: shop,
+          locales: [...new Set(languageOptions.flatMap(option => option.locales))],
+          includeReceiptKeys: true,
+          templateSettings: template.layout
+        })
+      };
+      this.publish({
+        status: 'ready',
+        result,
+        error: null
+      });
+      return result;
+    })().catch(error => {
+      if (generation === this.generation && !this.disposed) {
+        this.publish({
+          status: 'error',
+          result: null,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      throw error;
+    }).finally(() => {
+      if (this.pending === task) this.pending = undefined;
+    });
+    this.pending = task;
+    return task;
+  }
+  getSelectionScope(input) {
+    return JSON.stringify([this.getScope(input), input.orderId]);
+  }
+  documentIdentity(key, language) {
+    return JSON.stringify([key, language]);
+  }
+
+  /** Switch only the ready receipt projection; no fetching or rebuilding data. */
+  selectLanguage(code) {
+    if (this.disposed) throw new Error('Invoice preview disposed');
+    const current = this.state.result;
+    if (this.state.status !== 'ready' || !current || !this.input) throw new Error('Invoice preview is not ready');
+    const currentShop = this.core.getPlugin('app')?.getData?.()?.('shop_id');
+    if (currentShop != null && String(currentShop) !== String(this.input.shopId)) throw new Error('Invoice shop changed');
+    const selected = current.languageOptions.find(option => option.code === code);
+    if (!selected) throw new Error('Invoice language is unavailable');
+    this.languageSelection = {
+      scope: this.getSelectionScope(this.input),
+      code: selected.code
+    };
+    if (selected.code === current.selectedLanguage) return current;
+    const {
+      secondaryLocale: _previousSecondary,
+      ...rest
+    } = current;
+    const result = {
+      ...rest,
+      identity: this.documentIdentity(this.activeKey, selected.code),
+      selectedLanguage: selected.code,
+      locale: selected.locales[0],
+      ...(selected.locales[1] ? {
+        secondaryLocale: selected.locales[1]
+      } : {})
+    };
+    this.publish({
+      status: 'ready',
+      result,
+      error: null
+    });
+    return result;
+  }
+  retry() {
+    if (!this.input) return Promise.reject(new Error('Invoice input is missing'));
+    return this.prepare(this.input);
+  }
+  destroy() {
+    this.disposed = true;
+    this.generation++;
+    this.listeners.clear();
+    this.snapshotCache.clear();
+    if (this.core.getModule(this.name) === this) super.destroy();
+  }
+}
+exports.OrderInvoicePreviewImpl = OrderInvoicePreviewImpl;

package/lib/solution/RegisterAndLogin/config.js

@@ -305,6 +305,30 @@ function withH5AuthPrefix(config) {
   return nextConfig;
 }
 const h5OnlineStoreConfig = withH5AuthPrefix(onlineStoreConfig);
+function withKioskSalesChannel(config) {
+  return {
+    ...config,
+    options: params => {
+      const options = (typeof config.options === 'function' ? config.options(params) : config.options) || {};
+      const headers = typeof options.headers === 'function' ? options.headers(params) : options.headers;
+      return {
+        ...options,
+        headers: {
+          ...headers,
+          'Sales-Channel': 'kiosk'
+        }
+      };
+    }
+  };
+}
+
+// Kiosk 复用网店顾客认证接口，通过注册（含验证码登录自动注册）请求头标识会员归属渠道。
+const kioskConfig = {
+  ...h5OnlineStoreConfig,
+  emailCodeRegister: withKioskSalesChannel(h5OnlineStoreConfig.emailCodeRegister),
+  phoneCodeRegister: withKioskSalesChannel(h5OnlineStoreConfig.phoneCodeRegister),
+  phoneCodeLogin: withKioskSalesChannel(h5OnlineStoreConfig.phoneCodeLogin)
+};
 
 /**
  * 默认配置（通用配置）
@@ -564,6 +588,16 @@ const defaultConfig = {
 /**
  * webpos 渠道配置
  */
+const webposPasswordResetOptions = {
+  prefix: false,
+  isDefaultSaasDomain: true,
+  cache: false,
+  noToast: true,
+  headers: {
+    Accept: 'application/json',
+    'Content-Type': 'application/json'
+  }
+};
 const webposConfig = {
   sendEmailVerificationCode: {
     url: '/auth/email/register-code',
@@ -686,13 +720,20 @@ const webposConfig = {
     })
   },
   checkEmailCode: {
-    url: '/auth/email/check-email-code',
-    method: 'GET',
+    url: '/tenant/account/reset-password/email-code/verify',
+    method: 'POST',
     transformParams: params => ({
       email: params.email,
-      code: params.code,
-      action: params.action
-    })
+      code: params.code
+    }),
+    // SaaS 成功时 data 为 null，统一为既有验证码校验返回结构。
+    transformResponse: response => response?.status === true ? {
+      ...response,
+      data: {
+        valid: true
+      }
+    } : response,
+    options: webposPasswordResetOptions
   },
   checkMobileCode: {
     url: '/auth/mobile/check-mobile-code',
@@ -714,11 +755,12 @@ const webposConfig = {
     })
   },
   sendPasswordResetEmail: {
-    url: '/auth/email/reset-password-code',
-    method: 'GET',
+    url: '/tenant/account/reset-password/email-code/send',
+    method: 'POST',
     transformParams: params => ({
       email: params.email
-    })
+    }),
+    options: webposPasswordResetOptions
   },
   sendPasswordResetSms: {
     url: '/auth/mobile/sms-forget',
@@ -751,13 +793,16 @@ const webposConfig = {
     })
   },
   resetPasswordByEmail: {
-    url: '/auth/email/reset-password',
+    url: '/tenant/account/reset-password/email-code',
     method: 'POST',
     transformParams: params => ({
       email: params.email,
       password: params.password,
-      code: params.code
-    })
+      code: params.code,
+      // 页面先校验两次输入完全一致，SDK 保持原有重置参数。
+      password_confirmation: params.password
+    }),
+    options: webposPasswordResetOptions
   },
   resetPasswordByPhone: {
     url: '/auth/mobile/reset-password',
@@ -1094,6 +1139,7 @@ const shopWebposConfig = {
 const channelConfigMap = exports.channelConfigMap = {
   'online-store': onlineStoreConfig,
   'online-store-h5': h5OnlineStoreConfig,
+  'kiosk': kioskConfig,
   'default': defaultConfig,
   'webpos': webposConfig,
   'shop.webpos': shopWebposConfig

package/lib/solution/RegisterAndLogin/index.d.ts

@@ -4,6 +4,8 @@ import { RegisterParams, LoginParams, OAuthLoginParams, SendVerificationCodePara
 import { ApiCaller } from './config';
 export * from './types';
 export * from './config';
+export { validatePassword } from './utils';
+export type { PasswordValidationOptions } from './utils';
 /**
  * 注册登录解决方案实现
  */

package/lib/solution/RegisterAndLogin/index.js

@@ -4,9 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  RegisterAndLoginImpl: true
+  RegisterAndLoginImpl: true,
+  validatePassword: true
 };
 exports.RegisterAndLoginImpl = void 0;
+Object.defineProperty(exports, "validatePassword", {
+  enumerable: true,
+  get: function () {
+    return _utils.validatePassword;
+  }
+});
 var _BaseModule = require("../../modules/BaseModule");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
@@ -32,6 +39,7 @@ Object.keys(_config).forEach(function (key) {
     }
   });
 });
+var _utils = require("./utils");
 /**
  * 注册登录解决方案实现
  */

package/lib/solution/RegisterAndLogin/utils.d.ts

@@ -10,10 +10,18 @@ export declare function validateEmail(email: string): boolean;
  * 验证手机号格式（支持多种国际格式）
  */
 export declare function validatePhone(phone: string): boolean;
-/**
- * 验证密码强度
- */
-export declare function validatePassword(password: string): {
+export interface PasswordValidationOptions {
+    minLength?: number;
+    maxLength?: number;
+    requireLowercase?: boolean;
+    requireUppercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecialCharacters?: boolean;
+    specialCharactersPattern?: RegExp;
+    messages?: Partial<Record<'minLength' | 'maxLength' | 'requireLowercase' | 'requireUppercase' | 'requireNumber' | 'requireSpecialCharacters', string>>;
+}
+/** 验证密码强度；不传 options 时保持原有规则与返回格式。 */
+export declare function validatePassword(password: string, options?: PasswordValidationOptions): {
     isValid: boolean;
     errors: string[];
 };

package/lib/solution/RegisterAndLogin/utils.js

@@ -49,29 +49,36 @@ function validatePhone(phone) {
   const phoneRegex = /^(\+\d{1,3}[- ]?)?\d{10,14}$/;
   return phoneRegex.test(cleanPhone);
 }
-
-/**
- * 验证密码强度
- */
-function validatePassword(password) {
+/** 验证密码强度；不传 options 时保持原有规则与返回格式。 */
+function validatePassword(password, options = {}) {
   const errors = [];
-  if (password.length < 8) {
-    errors.push('密码长度至少为8位');
+  const {
+    minLength = 8,
+    maxLength = 128,
+    requireLowercase = true,
+    requireUppercase = true,
+    requireNumber = true,
+    requireSpecialCharacters = true,
+    specialCharactersPattern = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/,
+    messages = {}
+  } = options;
+  if (password.length < minLength) {
+    errors.push(messages.minLength ?? `密码长度至少为${minLength}位`);
   }
-  if (password.length > 128) {
-    errors.push('密码长度不能超过128位');
+  if (password.length > maxLength) {
+    errors.push(messages.maxLength ?? `密码长度不能超过${maxLength}位`);
   }
-  if (!/[a-z]/.test(password)) {
-    errors.push('密码必须包含至少一个小写字母');
+  if (requireLowercase && !/[a-z]/.test(password)) {
+    errors.push(messages.requireLowercase ?? '密码必须包含至少一个小写字母');
   }
-  if (!/[A-Z]/.test(password)) {
-    errors.push('密码必须包含至少一个大写字母');
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    errors.push(messages.requireUppercase ?? '密码必须包含至少一个大写字母');
   }
-  if (!/\d/.test(password)) {
-    errors.push('密码必须包含至少一个数字');
+  if (requireNumber && !/\d/.test(password)) {
+    errors.push(messages.requireNumber ?? '密码必须包含至少一个数字');
   }
-  if (!/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password)) {
-    errors.push('密码必须包含至少一个特殊字符');
+  if (requireSpecialCharacters && !specialCharactersPattern.test(password)) {
+    errors.push(messages.requireSpecialCharacters ?? '密码必须包含至少一个特殊字符');
   }
   return {
     isValid: errors.length === 0,

package/lib/solution/UnifiedBookingSales/businessAvailability.d.ts

@@ -0,0 +1,27 @@
+import { type BusinessAvailability } from '../../modules/BusinessAvailability';
+import type { ScheduleModule } from '../../modules/Schedule';
+interface BusinessAvailabilityHost {
+    loadOpenData: () => Promise<Record<string, unknown> | null>;
+    getSchedule: () => ScheduleModule | undefined;
+    getTimezone: () => string;
+    getScope: () => string;
+    now?: () => Date;
+}
+/** Read successful configuration once per business runtime; evaluate the clock on demand. */
+export declare class BusinessAvailabilityController {
+    private readonly host;
+    private runtime?;
+    constructor(host: BusinessAvailabilityHost);
+    invalidate(): void;
+    private now;
+    private getRuntime;
+    private assertCurrent;
+    private loadConfig;
+    private loadSchedules;
+    private error;
+    /** Synchronous final cart-commit check; deliberately never starts a load. */
+    getCachedAvailability(): BusinessAvailability;
+    getAvailability(): Promise<BusinessAvailability>;
+    assertAvailable(): void;
+}
+export {};

package/lib/solution/UnifiedBookingSales/businessAvailability.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BusinessAvailabilityController = void 0;
+var _lodashEs = require("lodash-es");
+var _BusinessAvailability = require("../../modules/BusinessAvailability");
+async function withTimeout(request) {
+  let timer;
+  try {
+    return await Promise.race([request, new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error('Unable to load business settings. Please try again.')), 30_000);
+    })]);
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+}
+
+/** Read successful configuration once per business runtime; evaluate the clock on demand. */
+class BusinessAvailabilityController {
+  runtime;
+  constructor(host) {
+    this.host = host;
+  }
+  invalidate() {
+    this.runtime = undefined;
+  }
+  now() {
+    return this.host.now?.() ?? new Date();
+  }
+  getRuntime() {
+    const scope = this.host.getScope();
+    if (this.runtime?.scope !== scope) this.runtime = {
+      scope
+    };
+    return this.runtime;
+  }
+  assertCurrent(runtime) {
+    if (this.runtime !== runtime || runtime.scope !== this.host.getScope()) {
+      throw new Error('Store settings changed. Please try again.');
+    }
+  }
+  async loadConfig(runtime) {
+    if (runtime.config) return runtime.config;
+    if (!runtime.configRequest) {
+      runtime.configRequest = (async () => {
+        const data = await withTimeout(this.host.loadOpenData());
+        this.assertCurrent(runtime);
+        if (!data) throw new Error('Business settings are unavailable. Please try again.');
+        const config = (0, _lodashEs.cloneDeep)((0, _BusinessAvailability.normalizeBusinessAvailabilityConfig)(data));
+        runtime.config = config;
+        return config;
+      })();
+    }
+    const request = runtime.configRequest;
+    try {
+      return await request;
+    } finally {
+      if (runtime.configRequest === request) runtime.configRequest = undefined;
+    }
+  }
+  async loadSchedules(runtime) {
+    if (runtime.schedules) return runtime.schedules;
+    if (!runtime.scheduleRequest) {
+      runtime.scheduleRequest = (async () => {
+        const schedule = this.host.getSchedule();
+        if (!schedule) throw new Error('Business operating-hours schedule is unavailable. Please try again.');
+        await withTimeout(schedule.loadAllSchedule({
+          useCache: true
+        }));
+        this.assertCurrent(runtime);
+        const schedules = (0, _lodashEs.cloneDeep)(schedule.getScheduleListByIds(runtime.config.scheduleIds) || []);
+        runtime.schedules = schedules;
+        return schedules;
+      })();
+    }
+    const request = runtime.scheduleRequest;
+    try {
+      return await request;
+    } finally {
+      if (runtime.scheduleRequest === request) runtime.scheduleRequest = undefined;
+    }
+  }
+  error(reason, runtime) {
+    return {
+      status: 'error',
+      behavior: 'hide_all',
+      message: null,
+      nextChangeAt: this.now().getTime() + 60_000,
+      requirePaymentOnSubmit: runtime?.config?.requirePaymentOnSubmit ?? true,
+      error: reason instanceof Error ? reason.message : 'Business settings are unavailable. Please try again.'
+    };
+  }
+
+  /** Synchronous final cart-commit check; deliberately never starts a load. */
+  getCachedAvailability() {
+    const runtime = this.getRuntime();
+    try {
+      this.assertCurrent(runtime);
+      if (!runtime.config) throw new Error('Business settings are still loading. Please try again.');
+      return (0, _BusinessAvailability.computeBusinessAvailability)({
+        config: runtime.config,
+        schedules: runtime.schedules || [],
+        timezone: this.host.getTimezone(),
+        now: this.now()
+      });
+    } catch (reason) {
+      return this.error(reason, runtime);
+    }
+  }
+  async getAvailability() {
+    const runtime = this.getRuntime();
+    try {
+      const config = await this.loadConfig(runtime);
+      this.assertCurrent(runtime);
+      if (!config.paused && !config.invalidScheduleIds && config.scheduleIds.length) {
+        await this.loadSchedules(runtime);
+      }
+      this.assertCurrent(runtime);
+      return this.getCachedAvailability();
+    } catch (reason) {
+      return this.error(reason, runtime);
+    }
+  }
+  assertAvailable() {
+    const availability = this.getCachedAvailability();
+    if (availability.status !== 'open') {
+      const error = new Error(availability.error || (availability.status === 'paused' ? 'Ordering is temporarily paused.' : 'Ordering is currently closed.'));
+      Object.assign(error, {
+        code: 'BUSINESS_UNAVAILABLE',
+        businessAvailability: availability
+      });
+      throw error;
+    }
+  }
+}
+exports.BusinessAvailabilityController = BusinessAvailabilityController;