R524809
267 lines
7.5 KiB
TypeScript
267 lines
7.5 KiB
TypeScript
import { getJson } from '../../utils/http';
|
|
|
|
/**
|
|
* SVG汉字数据缓存配置
|
|
*/
|
|
const CACHE_CONFIG = {
|
|
key: 'svgWordsData', // 缓存键名
|
|
expireDays: 7, // 缓存过期天数
|
|
// url: 'https://cdn.joeyone.cn/doodle/words-svg-all.json' // 远程数据地址
|
|
// url: 'https://cdn.joeyone.cn/doodle/words-svg-3000.json' // 远程数据地址
|
|
// url: 'https://cdn.joeyone.cn/doodle/char_svg_3500.json' // 远程数据地址
|
|
url: 'https://cdn.joeyone.cn/doodle/hanzi/hanzi_stroke_3500.json', // 远程数据地址
|
|
hanziReadingsUrl:
|
|
'https://cdn.joeyone.cn/doodle/hanzi/hanzi_readings_3500.json', // 远程数据地址
|
|
};
|
|
|
|
/**
|
|
* 汉字读音数据缓存配置
|
|
*/
|
|
const READINGS_CACHE_CONFIG = {
|
|
key: 'hanziReadingsData',
|
|
expireDays: 7,
|
|
url: CACHE_CONFIG.hanziReadingsUrl,
|
|
};
|
|
|
|
/**
|
|
* 汉字读音原始数据条目：
|
|
* - 单音字：[pinyin, gloss, introduce]
|
|
* - 多音字：[[pinyin, gloss, introduce], ...]
|
|
*/
|
|
export type HanziReadingEntry =
|
|
| [string, string, string]
|
|
| [string, string, string][];
|
|
export type HanziReadingsMap = Record<string, HanziReadingEntry>;
|
|
|
|
/**
|
|
* 缓存数据结构
|
|
*/
|
|
interface CacheData {
|
|
data: Record<string, string[]>; // SVG汉字数据
|
|
timestamp: number; // 缓存时间戳
|
|
version?: string; // 数据版本（可选）
|
|
}
|
|
|
|
/**
|
|
* 检查缓存是否过期
|
|
* @param timestamp 缓存时间戳
|
|
* @returns 是否过期
|
|
*/
|
|
function isCacheExpired(timestamp: number): boolean {
|
|
const now = Date.now();
|
|
const expireTime = CACHE_CONFIG.expireDays * 24 * 60 * 60 * 1000; // 7天的毫秒数
|
|
return now - timestamp > expireTime;
|
|
}
|
|
|
|
/**
|
|
* 从本地存储获取缓存数据
|
|
* @returns 缓存数据或null
|
|
*/
|
|
function getCacheData(): CacheData | null {
|
|
try {
|
|
const cacheStr = wx.getStorageSync(CACHE_CONFIG.key);
|
|
if (!cacheStr) {
|
|
return null;
|
|
}
|
|
|
|
const cacheData: CacheData = JSON.parse(cacheStr);
|
|
|
|
// 检查缓存是否过期
|
|
if (isCacheExpired(cacheData.timestamp)) {
|
|
console.log('SVG汉字数据缓存已过期，将重新获取');
|
|
// 清除过期缓存
|
|
wx.removeStorageSync(CACHE_CONFIG.key);
|
|
return null;
|
|
}
|
|
|
|
console.log(
|
|
'使用本地缓存的SVG汉字数据，缓存时间:',
|
|
new Date(cacheData.timestamp).toLocaleString(),
|
|
);
|
|
return cacheData;
|
|
} catch (error) {
|
|
console.error('读取SVG汉字数据缓存失败:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 保存数据到本地存储
|
|
* @param data SVG汉字数据
|
|
*/
|
|
function saveCacheData(data: Record<string, string[]>): void {
|
|
try {
|
|
const cacheData: CacheData = {
|
|
data,
|
|
timestamp: Date.now(),
|
|
version: '1.0', // 可以用于后续版本控制
|
|
};
|
|
|
|
wx.setStorageSync(CACHE_CONFIG.key, JSON.stringify(cacheData));
|
|
console.log('SVG汉字数据已缓存到本地存储');
|
|
} catch (error) {
|
|
console.error('保存SVG汉字数据缓存失败:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 从远程服务器获取SVG汉字数据
|
|
* @returns Promise<Record<string, string[]>>
|
|
*/
|
|
async function fetchRemoteData(): Promise<Record<string, string[]>> {
|
|
console.log('从远程服务器获取SVG汉字数据...');
|
|
|
|
const svgWordsData = await getJson<Record<string, string[]>>(
|
|
CACHE_CONFIG.url,
|
|
{
|
|
timeout: 15000, // 15秒超时
|
|
header: {
|
|
Accept: 'application/json',
|
|
'Cache-Control': 'no-cache',
|
|
},
|
|
},
|
|
);
|
|
|
|
console.log(
|
|
'远程SVG汉字数据获取成功，共',
|
|
Object.keys(svgWordsData).length,
|
|
'个汉字',
|
|
);
|
|
return svgWordsData;
|
|
}
|
|
|
|
/**
|
|
* 获取SVG汉字数据（带缓存机制）
|
|
* 优先使用本地缓存，如果缓存不存在或已过期，则从远程获取
|
|
* @returns Promise<Record<string, string[]>>
|
|
*/
|
|
export async function getWordsSvgData(): Promise<Record<string, string[]>> {
|
|
try {
|
|
// 1. 尝试从本地缓存获取数据
|
|
const cacheData = getCacheData();
|
|
if (cacheData) {
|
|
return cacheData.data;
|
|
}
|
|
|
|
// 2. 缓存不存在或已过期，从远程获取
|
|
const remoteData = await fetchRemoteData();
|
|
|
|
// 3. 保存到本地缓存
|
|
saveCacheData(remoteData);
|
|
|
|
return remoteData;
|
|
} catch (error) {
|
|
console.error('获取SVG汉字数据失败:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取汉字读音数据（带缓存机制）
|
|
* 数据格式参见 HanziReadingsMap 类型说明，单音字为一维数组，多音字为二维数组。
|
|
*/
|
|
export async function getHanziReadingsData(): Promise<HanziReadingsMap> {
|
|
try {
|
|
const cacheStr = wx.getStorageSync(READINGS_CACHE_CONFIG.key);
|
|
if (cacheStr) {
|
|
const cacheData = JSON.parse(cacheStr) as {
|
|
data: HanziReadingsMap;
|
|
timestamp: number;
|
|
};
|
|
const expireMs =
|
|
READINGS_CACHE_CONFIG.expireDays * 24 * 60 * 60 * 1000;
|
|
if (Date.now() - cacheData.timestamp <= expireMs) {
|
|
return cacheData.data;
|
|
}
|
|
wx.removeStorageSync(READINGS_CACHE_CONFIG.key);
|
|
}
|
|
} catch (error) {
|
|
console.error('读取汉字读音缓存失败:', error);
|
|
}
|
|
|
|
const remote = await getJson<HanziReadingsMap>(READINGS_CACHE_CONFIG.url, {
|
|
timeout: 15000,
|
|
header: {
|
|
Accept: 'application/json',
|
|
'Cache-Control': 'no-cache',
|
|
},
|
|
});
|
|
|
|
try {
|
|
wx.setStorageSync(
|
|
READINGS_CACHE_CONFIG.key,
|
|
JSON.stringify({ data: remote, timestamp: Date.now() }),
|
|
);
|
|
} catch (error) {
|
|
console.error('保存汉字读音缓存失败:', error);
|
|
}
|
|
|
|
return remote;
|
|
}
|
|
|
|
/**
|
|
* 取出汉字的主拼音（多音字取第一个发音），未命中或数据非法时返回空串。
|
|
*/
|
|
export function pickPrimaryPinyin(
|
|
readings: HanziReadingsMap,
|
|
char: string,
|
|
): string {
|
|
const entry = readings[char];
|
|
if (!entry) return '';
|
|
if (typeof entry[0] === 'string') {
|
|
return (entry as [string, string, string])[0] || '';
|
|
}
|
|
const first = (entry as [string, string, string][])[0];
|
|
return Array.isArray(first) ? first[0] || '' : '';
|
|
}
|
|
|
|
/**
|
|
* 清除SVG汉字数据缓存
|
|
*/
|
|
export function clearWordsSvgCache(): void {
|
|
try {
|
|
wx.removeStorageSync(CACHE_CONFIG.key);
|
|
console.log('SVG汉字数据缓存已清除');
|
|
} catch (error) {
|
|
console.error('清除SVG汉字数据缓存失败:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取缓存信息
|
|
* @returns 缓存信息对象
|
|
*/
|
|
export function getCacheInfo(): {
|
|
exists: boolean;
|
|
timestamp?: number;
|
|
isExpired?: boolean;
|
|
daysLeft?: number;
|
|
} {
|
|
try {
|
|
const cacheStr = wx.getStorageSync(CACHE_CONFIG.key);
|
|
if (!cacheStr) {
|
|
return { exists: false };
|
|
}
|
|
|
|
const cacheData: CacheData = JSON.parse(cacheStr);
|
|
const isExpired = isCacheExpired(cacheData.timestamp);
|
|
const daysLeft = isExpired
|
|
? 0
|
|
: Math.ceil(
|
|
(CACHE_CONFIG.expireDays * 24 * 60 * 60 * 1000 -
|
|
(Date.now() - cacheData.timestamp)) /
|
|
(24 * 60 * 60 * 1000),
|
|
);
|
|
|
|
return {
|
|
exists: true,
|
|
timestamp: cacheData.timestamp,
|
|
isExpired,
|
|
daysLeft,
|
|
};
|
|
} catch (error) {
|
|
console.error('获取缓存信息失败:', error);
|
|
return { exists: false };
|
|
}
|
|
}
|