v3.5.1 版本更新

apps/mini-user/src/lib/client-location.weapp.ts

@@ -0,0 +1,25 @@
+import Taro from '@tarojs/taro';
+
+export type ClientGpsLocation = {
+  province?: string;
+  city?: string;
+  district?: string;
+  latitude: number;
+  longitude: number;
+  address?: string;
+};
+
+export async function tryGetClientGpsLocation(): Promise<ClientGpsLocation | null> {
+  try {
+    const loc = await new Promise<{ latitude: number; longitude: number }>((resolve, reject) => {
+      Taro.getLocation({
+        type: 'gcj02',
+        success: resolve,
+        fail: reject,
+      });
+    });
+    return { latitude: loc.latitude, longitude: loc.longitude };
+  } catch {
+    return null;
+  }
+}

apps/mini-user/src/lib/pay-ready.weapp.ts

@@ -0,0 +1,25 @@
+import { goLogin } from './auth-nav';
+import { isLoggedIn } from './api';
+import { fetchClientConfig, fetchUserProfile, needsWechatAuthForPay } from './pay-wechat';
+
+export async function ensurePayReady(returnPath: string): Promise<boolean> {
+  if (!isLoggedIn()) {
+    goLogin(returnPath);
+    return false;
+  }
+
+  try {
+    const [config, profile] = await Promise.all([fetchClientConfig(), fetchUserProfile()]);
+    if (!needsWechatAuthForPay(config, profile)) {
+      return true;
+    }
+    goLogin(returnPath, { needWechat: '1' });
+    return false;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : '';
+    if (/登录已过期|重新登录|401/.test(msg) || !isLoggedIn()) {
+      goLogin(returnPath);
+    }
+    return false;
+  }
+}

apps/mini-user/src/lib/pay-wechat.weapp.ts

@@ -0,0 +1,89 @@
+import type {
+  ClientRuntimeConfig,
+  WechatJsapiPrepayParams,
+  WechatLoginResult,
+  WechatPayOrderResult,
+} from '@dukang/shared-types';
+import { WECHAT_AUTH_REQUIRED, isWxAuthorizeEnabled } from '@dukang/shared-types';
+import Taro from '@tarojs/taro';
+import { request, saveAuth, type UserProfile } from './api';
+import { isWechatEnv } from './weixin';
+
+export function isMiniWechatEnv(): boolean {
+  return true;
+}
+
+export function isWechatAuthRequiredError(err: unknown): boolean {
+  return err instanceof Error && err.message === WECHAT_AUTH_REQUIRED;
+}
+
+export async function fetchClientConfig(): Promise<ClientRuntimeConfig> {
+  return request<ClientRuntimeConfig>('/common/client-config');
+}
+
+export async function fetchUserProfile(): Promise<UserProfile> {
+  return request<UserProfile>('/auth/me');
+}
+
+export function needsWechatAuthForPay(
+  config: ClientRuntimeConfig,
+  profile: UserProfile | null,
+): boolean {
+  if (!isWxAuthorizeEnabled(config)) return false;
+  return !config.mockPay && config.wechatPayEnabled && isWechatEnv() && !profile?.hasWechat;
+}
+
+export function saveWechatLoginResult(result: WechatLoginResult): boolean {
+  if (!result.accessToken) return false;
+  saveAuth({
+    accessToken: result.accessToken,
+    refreshToken: result.refreshToken,
+  });
+  return true;
+}
+
+export async function authorizeWechatForPay(): Promise<WechatLoginResult | void> {
+  throw new Error('请使用小程序微信授权');
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function waitOrderPaid(orderId: string, maxAttempts = 15): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i += 1) {
+    const order = await request<{ payStatus?: string }>(`/trade/orders/${orderId}`);
+    if (order.payStatus === 'PAID') return true;
+    await sleep(2000);
+  }
+  return false;
+}
+
+async function invokeMiniPay(prepay: WechatJsapiPrepayParams) {
+  await Taro.requestPayment({
+    timeStamp: prepay.timeStamp,
+    nonceStr: prepay.nonceStr,
+    package: prepay.package,
+    signType: prepay.signType,
+    paySign: prepay.paySign,
+  });
+}
+
+export async function payOrder(orderId: string): Promise<'paid' | 'pending'> {
+  const result = await request<WechatPayOrderResult>(`/trade/orders/${orderId}/pay`, {
+    method: 'POST',
+  });
+
+  if (result.mode === 'jsapi' && result.prepay) {
+    await invokeMiniPay(result.prepay as WechatJsapiPrepayParams);
+    const paid = await waitOrderPaid(orderId);
+    return paid ? 'paid' : 'pending';
+  }
+
+  return 'paid';
+}
+
+export type WechatBindResult =
+  | { ok: true; profile?: UserProfile }
+  | { ok: false; needBindPhone: true; wxSessionKey: string }
+  | { ok: false; redirecting: true };

apps/mini-user/src/lib/region-data.ts

@@ -1,20 +1,8 @@
-import { regionData } from 'element-china-area-data';
+import rawTree from './region-tree.json';
 
 export type RegionTree = Record<string, Record<string, string[]>>;
 
-function buildRegionTree(): RegionTree {
-  const tree: RegionTree = {};
-  for (const province of regionData) {
-    const cities: Record<string, string[]> = {};
-    for (const city of province.children ?? []) {
-      cities[city.label] = (city.children ?? []).map((district) => district.label);
-    }
-    tree[province.label] = cities;
-  }
-  return tree;
-}
-
-export const REGION_TREE: RegionTree = buildRegionTree();
+export const REGION_TREE = rawTree as RegionTree;
 export const PROVINCES = Object.keys(REGION_TREE);
 export const REGION_ALL = '全市';
 

apps/mini-user/src/lib/user-location.weapp.ts

@@ -0,0 +1,232 @@
+import Taro from '@tarojs/taro';
+import { request } from './api';
+import { DEFAULT_REGION, REGION_ALL, regionFromGeo, type RegionSelection } from './region-data';
+import { FALLBACK_CITY_CODE } from './product-images';
+
+export const GPS_CITY_STORAGE_KEY = 'dukang_gps_city';
+const USER_COORDS_KEY = 'dukang_user_coords';
+const LOCATION_DENIED_KEY = 'dukang_location_denied';
+
+export type ResolvedUserCity = {
+  province: string;
+  city: string;
+  district: string;
+  cityCode?: string;
+  cityName?: string;
+  openCity: boolean;
+  region: RegionSelection;
+  displayCity: string;
+};
+
+export type UserCoords = { latitude: number; longitude: number };
+
+type GpsCityCache = ResolvedUserCity & { timestamp: number };
+
+const FALLBACK_CITY: ResolvedUserCity = {
+  province: DEFAULT_REGION.province,
+  city: DEFAULT_REGION.city,
+  district: REGION_ALL,
+  cityCode: FALLBACK_CITY_CODE,
+  cityName: '郑州市',
+  openCity: true,
+  region: DEFAULT_REGION,
+  displayCity: '郑州市',
+};
+
+function isLocationDenied(): boolean {
+  try {
+    return Taro.getStorageSync(LOCATION_DENIED_KEY) === '1';
+  } catch {
+    return false;
+  }
+}
+
+function markLocationDenied() {
+  try {
+    Taro.setStorageSync(LOCATION_DENIED_KEY, '1');
+  } catch {
+    /* ignore */
+  }
+}
+
+function clearLocationDenied() {
+  try {
+    Taro.removeStorageSync(LOCATION_DENIED_KEY);
+  } catch {
+    /* ignore */
+  }
+}
+
+function isDenyMessage(errMsg?: string): boolean {
+  return /auth deny|authorize|permission|denied|拒绝|用户拒绝|getLocation:fail/i.test(
+    errMsg || '',
+  );
+}
+
+function readCache(): GpsCityCache | null {
+  try {
+    const raw = Taro.getStorageSync(GPS_CITY_STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(String(raw)) as GpsCityCache;
+    if (Date.now() - parsed.timestamp > 30 * 60 * 1000) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(data: ResolvedUserCity) {
+  try {
+    Taro.setStorageSync(
+      GPS_CITY_STORAGE_KEY,
+      JSON.stringify({ ...data, timestamp: Date.now() } satisfies GpsCityCache),
+    );
+  } catch {
+    /* ignore */
+  }
+}
+
+export function writeUserCoords(latitude: number, longitude: number) {
+  try {
+    Taro.setStorageSync(
+      USER_COORDS_KEY,
+      JSON.stringify({ latitude, longitude, timestamp: Date.now() }),
+    );
+  } catch {
+    /* ignore */
+  }
+}
+
+export function readCachedUserCoords(): UserCoords | null {
+  try {
+    const raw = Taro.getStorageSync(USER_COORDS_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(String(raw)) as UserCoords & { timestamp?: number };
+    if (parsed.timestamp && Date.now() - parsed.timestamp > 30 * 60 * 1000) return null;
+    if (!Number.isFinite(parsed.latitude) || !Number.isFinite(parsed.longitude)) return null;
+    return { latitude: parsed.latitude, longitude: parsed.longitude };
+  } catch {
+    return null;
+  }
+}
+
+export function toCityWideRegion(region: RegionSelection): RegionSelection {
+  return {
+    province: region.province,
+    city: region.city,
+    district: REGION_ALL,
+  };
+}
+
+function cacheFallbackAndMaybeDeny(denied: boolean) {
+  if (denied) markLocationDenied();
+  writeCache(FALLBACK_CITY);
+}
+
+async function reportLocationToServer(payload: {
+  latitude?: number;
+  longitude?: number;
+  sdk: 'jssdk' | 'geolocation';
+  status: 'success' | 'fail';
+  errMsg?: string;
+}) {
+  return request<{
+    province?: string;
+    city?: string;
+    district?: string;
+    cityCode?: string;
+    cityName?: string;
+    openCity?: boolean;
+  }>('/common/wechat/location', {
+    method: 'POST',
+    data: payload,
+  });
+}
+
+function toResolved(data: {
+  province?: string;
+  city?: string;
+  district?: string;
+  cityCode?: string;
+  cityName?: string;
+  openCity?: boolean;
+}): ResolvedUserCity | null {
+  if (!data.province || !data.city) return null;
+  const region = regionFromGeo(data.province, data.city, data.district);
+  const displayCity = data.cityName ?? (data.city.endsWith('市') ? data.city : `${data.city}市`);
+  return {
+    province: data.province,
+    city: data.city,
+    district: data.district ?? '',
+    cityCode: data.cityCode,
+    cityName: data.cityName,
+    openCity: !!data.openCity,
+    region,
+    displayCity,
+  };
+}
+
+async function promptLocationAuthOnce() {
+  await Taro.showModal({
+    title: '位置授权',
+    content: '需要获取您的位置以展示所在城市的商品与门店。拒绝后将默认使用郑州市，不会再次弹窗。',
+    confirmText: '知道了',
+    showCancel: false,
+  }).catch(() => {});
+}
+
+function getMiniLocation(): Promise<Taro.getLocation.SuccessCallbackResult> {
+  return new Promise((resolve, reject) => {
+    Taro.getLocation({
+      type: 'gcj02',
+      success: resolve,
+      fail: reject,
+    });
+  });
+}
+
+export async function resolveUserCity(force = false): Promise<ResolvedUserCity> {
+  if (!force) {
+    if (isLocationDenied()) {
+      const cached = readCache();
+      return cached ?? FALLBACK_CITY;
+    }
+    const cached = readCache();
+    if (cached) return cached;
+  }
+
+  try {
+    const loc = await getMiniLocation();
+    writeUserCoords(loc.latitude, loc.longitude);
+    const data = await reportLocationToServer({
+      latitude: loc.latitude,
+      longitude: loc.longitude,
+      sdk: 'jssdk',
+      status: 'success',
+    });
+    const resolved = toResolved(data);
+    if (resolved) {
+      clearLocationDenied();
+      writeCache(resolved);
+      return resolved;
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const denied = isDenyMessage(errMsg);
+    if (denied && !isLocationDenied()) {
+      await promptLocationAuthOnce();
+    }
+    await reportLocationToServer({
+      sdk: 'jssdk',
+      status: 'fail',
+      errMsg: errMsg.slice(0, 200),
+    }).catch(() => {});
+    cacheFallbackAndMaybeDeny(denied);
+  }
+
+  return FALLBACK_CITY;
+}
+
+export function getCityCodeForCatalog(resolved: ResolvedUserCity): string {
+  return resolved.openCity && resolved.cityCode ? resolved.cityCode : FALLBACK_CITY_CODE;
+}

apps/mini-user/src/lib/wechat-auth.weapp.ts

@@ -0,0 +1,80 @@
+import type { WechatLoginResult } from '@dukang/shared-types';
+import Taro from '@tarojs/taro';
+import {
+  fetchMiniWechatUserInfo,
+  mergeWxDisplayProfile,
+  needsWxProfileFill,
+  syncMiniWechatProfile,
+} from './mini-wechat-profile';
+import {
+  fetchClientConfig,
+  fetchUserProfile,
+  needsWechatAuthForPay,
+  saveWechatLoginResult,
+  type WechatBindResult,
+} from './pay-wechat';
+import { isWechatEnv } from './weixin';
+
+export { fetchMiniWechatUserInfo, mergeWxDisplayProfile, needsWxProfileFill };
+
+export type WechatAuthEnsureResult =
+  | { ok: true }
+  | { ok: false; redirecting: true }
+  | { ok: false; needBindPhone: true; wxSessionKey: string };
+
+export async function loginWithWechat(): Promise<WechatLoginResult | void> {
+  const res = await Taro.login();
+  if (!res.code) {
+    throw new Error(res.errMsg || '微信登录失败，未获取到 code');
+  }
+  const { request } = await import('./api');
+  return request<WechatLoginResult>('/auth/login/wechat', {
+    method: 'POST',
+    data: { code: res.code, platform: 'mini' },
+  });
+}
+
+export async function checkNeedsWechatAuth(): Promise<boolean> {
+  const [config, profile] = await Promise.all([fetchClientConfig(), fetchUserProfile()]);
+  return needsWechatAuthForPay(config, profile);
+}
+
+export async function ensureWechatAuthForPay(): Promise<WechatAuthEnsureResult> {
+  if (!isWechatEnv()) return { ok: true };
+  if (!(await checkNeedsWechatAuth())) return { ok: true };
+  return { ok: false, redirecting: true };
+}
+
+export async function handleWechatAuthCallback(): Promise<WechatLoginResult | null> {
+  return null;
+}
+
+export async function loginWithWechatSdk(): Promise<WechatLoginResult | void> {
+  throw new Error('请使用小程序微信授权');
+}
+
+export function applyWechatLoginResult(result: WechatLoginResult): boolean {
+  return saveWechatLoginResult(result);
+}
+
+export async function bindWechatForUser(
+  prefetchedWxProfile?: { nickname?: string; avatarUrl?: string } | null,
+): Promise<WechatBindResult> {
+  const res = await Taro.login();
+  if (!res.code) {
+    throw new Error(res.errMsg || '微信授权失败');
+  }
+  const { request } = await import('./api');
+  const data = await request<WechatLoginResult>('/auth/wechat/bind', {
+    method: 'POST',
+    data: { code: res.code, platform: 'mini' },
+  });
+  if (data.needBindPhone && data.wxSessionKey) {
+    return { ok: false, needBindPhone: true, wxSessionKey: data.wxSessionKey };
+  }
+  await syncMiniWechatProfile(prefetchedWxProfile);
+  const profile = await fetchUserProfile();
+  return { ok: true, profile };
+}
+
+export type { WechatBindResult };

apps/mini-user/src/lib/wechat-share.weapp.ts

@@ -0,0 +1,165 @@
+import Taro from '@tarojs/taro';
+import {
+  applyShareTitleTemplate,
+  DEFAULT_SHARE_DESC,
+  DEFAULT_SHARE_HINT,
+  DEFAULT_SHARE_TITLE,
+  resolveMiniShareRuntime,
+  type ClientRuntimeConfig,
+  type MiniShareRuntime,
+  type MiniShareSceneConfig,
+} from '@dukang/shared-types';
+import { toast } from './api';
+import { getBrandAssetsSync, loadBrandAssets } from './brand-assets';
+import { fetchClientConfig } from './pay-wechat';
+
+export type ShareScene =
+  | 'home'
+  | 'stores'
+  | 'storeDetail'
+  | 'benefit'
+  | 'mine'
+  | 'productDetail'
+  | 'orderDetail';
+
+export { DEFAULT_SHARE_TITLE, DEFAULT_SHARE_DESC };
+
+export const WECHAT_SHARE_HINT = DEFAULT_SHARE_HINT;
+
+const FALLBACK_SHARE: MiniShareRuntime = resolveMiniShareRuntime({});
+
+let shareCached: MiniShareRuntime | null = null;
+
+export function getShareRuntimeSync(): MiniShareRuntime {
+  return shareCached ?? FALLBACK_SHARE;
+}
+
+export function applyShareFromClientConfig(config?: ClientRuntimeConfig | null) {
+  if (config?.share) {
+    shareCached = config.share;
+    return shareCached;
+  }
+  return getShareRuntimeSync();
+}
+
+export async function loadShareConfig(force = false): Promise<MiniShareRuntime> {
+  if (!force && shareCached) return shareCached;
+  try {
+    const cfg = await fetchClientConfig();
+    if (cfg?.share) {
+      shareCached = cfg.share;
+      return shareCached;
+    }
+  } catch {
+    /* ignore */
+  }
+  shareCached = FALLBACK_SHARE;
+  return shareCached;
+}
+
+export function getDefaultShareImageUrl(): string {
+  const share = getShareRuntimeSync();
+  return share.default.imageUrl || getBrandAssetsSync().brandLogoUrl;
+}
+
+export function getShareHint(): string {
+  return getShareRuntimeSync().hint || DEFAULT_SHARE_HINT;
+}
+
+export function prefetchShareBrandAssets() {
+  void loadBrandAssets();
+  void loadShareConfig();
+}
+
+function sceneConfig(scene?: ShareScene): MiniShareSceneConfig {
+  const runtime = getShareRuntimeSync();
+  if (!scene) return runtime.default;
+  return runtime[scene] ?? runtime.default;
+}
+
+export type PageSharePayload = {
+  title?: string;
+  desc?: string;
+  path?: string;
+  imgUrl?: string;
+  link?: string;
+};
+
+export function buildSceneSharePayload(
+  scene: ShareScene,
+  options?: {
+    path?: string;
+    dynamicTitle?: string | null;
+    dynamicDesc?: string | null;
+    dynamicImageUrl?: string | null;
+    titleVars?: Record<string, string | undefined | null>;
+  },
+): PageSharePayload {
+  const def = getShareRuntimeSync().default;
+  const sc = sceneConfig(scene);
+  let title = (sc.title || '').trim();
+  if (title && options?.titleVars) {
+    const vars = options.titleVars;
+    const missingRequired = Object.entries(vars).some(
+      ([key, value]) => title.includes(`{${key}}`) && !(value != null && String(value).trim()),
+    );
+    title = missingRequired ? '' : applyShareTitleTemplate(title, vars);
+  }
+  if (!title) {
+    title = (options?.dynamicTitle || '').trim() || def.title;
+  }
+  const desc = (sc.desc || '').trim() || (options?.dynamicDesc || '').trim() || def.desc;
+  const imgUrl =
+    (sc.imageUrl || '').trim() ||
+    (options?.dynamicImageUrl || '').trim() ||
+    def.imageUrl ||
+    getDefaultShareImageUrl();
+  return {
+    title,
+    desc,
+    path: options?.path,
+    imgUrl,
+  };
+}
+
+export async function applyWechatShare(): Promise<void> {
+  /* weapp 使用原生分享菜单，无 H5 JSSDK */
+}
+
+export async function handleShareButtonClick(
+  payload?: PageSharePayload,
+): Promise<{ showGuide: boolean }> {
+  try {
+    await Taro.showShareMenu({
+      withShareTicket: true,
+      showShareItems: ['shareAppMessage', 'shareTimeline'],
+    });
+  } catch {
+    try {
+      await Taro.showShareMenu({ withShareTicket: true });
+    } catch {
+      /* ignore */
+    }
+  }
+  toast(getShareHint());
+  void payload;
+  return { showGuide: false };
+}
+
+export function toWeappShareMessage(payload?: PageSharePayload) {
+  const def = getShareRuntimeSync().default;
+  return {
+    title: payload?.title || def.title,
+    path: payload?.path || '/pages/home/index',
+    imageUrl: payload?.imgUrl || getDefaultShareImageUrl(),
+  };
+}
+
+export function toWeappShareTimeline(payload?: PageSharePayload, query = '') {
+  const def = getShareRuntimeSync().default;
+  return {
+    title: payload?.title || def.title,
+    query,
+    imageUrl: payload?.imgUrl || getDefaultShareImageUrl(),
+  };
+}

apps/mini-user/src/lib/weixin.weapp.ts

@@ -0,0 +1,4 @@
+/** 小程序端恒为微信环境，避免引入 H5 JSSDK 门面 */
+export function isWechatEnv() {
+  return true;
+}